Synchronise with Khronos-private Gitlab branch

The maintenance of the conformance tests is moving to Github.

This commit contains all the changes that have been done in
Gitlab since the first public release of the conformance tests.

Signed-off-by: Kevin Petit <kevin.petit@arm.com>

test_conformance/spir/CMakeLists.txt

@@ -0,0 +1,94 @@
+function (install_spir_artifacts suite_name)
+  install(FILES "${suite_name}.zip" DESTINATION "${CLConf_OUT_DIR}"
+          COMPONENT OpenCLCTS)
+endfunction()
+
+add_executable(
+    conformance_test_spir
+    main.cpp
+    datagen.cpp
+    run_build_test.cpp
+    run_services.cpp
+    kernelargs.cpp
+    ../../test_common/harness/errorHelpers.c
+    ../../test_common/harness/kernelHelpers.c
+    ../../test_common/harness/mt19937.c
+    ../../test_common/harness/msvc9.c
+    ../../test_common/harness/os_helpers.cpp
+    ../../test_common/harness/testHarness.c
+    ../../test_common/miniz/miniz.c)
+
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)" AND NOT MSVC)
+set_source_files_properties(
+        COMPILE_FLAGS -msse2)
+endif()
+
+if(UNIX)
+    set_target_properties(conformance_test_spir PROPERTIES
+	   COMPILE_FLAGS "-fexceptions -frtti")
+elseif(MSVC)
+    set_target_properties(conformance_test_spir PROPERTIES
+       COMPILE_FLAGS "/GR /EHs /EHc")
+endif()
+
+TARGET_LINK_LIBRARIES(conformance_test_spir
+	${CLConform_LIBRARIES})
+
+# Need to copy the spir zips to sit beside the executable
+add_custom_command(TARGET conformance_test_spir POST_BUILD
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/khr.csv" "$<TARGET_FILE_DIR:conformance_test_spir>/khr.csv"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/api.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/api.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/atomics.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/atomics.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/basic.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/basic.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/compile_and_link.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/compile_and_link.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/commonfns.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/commonfns.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/conversions.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/conversions.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/geometrics.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/geometrics.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/enum_values.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/enum_values.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/half.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/half.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/kernel_attributes.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/kernel_attributes.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/kernel_image_methods.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/kernel_image_methods.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/images_kernel_read_write.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/images_kernel_read_write.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/images_samplerlessRead.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/images_samplerlessRead.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/integer_ops.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/integer_ops.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/math_brute_force.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/math_brute_force.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/printf.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/printf.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/profiling.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/profiling.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/relationals.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/relationals.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/select.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/select.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/sampler_enumeration.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/sampler_enumeration.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/vec_align.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/vec_align.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/vec_step.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/vec_step.zip"
+	COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/binary_type.zip" "$<TARGET_FILE_DIR:conformance_test_spir>/binary_type.zip")
+
+add_dependencies(OpenCLCTS conformance_test_spir)
+install(TARGETS conformance_test_spir
+    DESTINATION "${CLConf_OUT_DIR}"
+    COMPONENT OpenCLCTS)
+
+install_spir_artifacts(api)
+install_spir_artifacts(atomics)
+install_spir_artifacts(basic)
+install_spir_artifacts(compile_and_link)
+install_spir_artifacts(commonfns)
+install_spir_artifacts(conversions)
+install_spir_artifacts(geometrics)
+install_spir_artifacts(enum_values)
+install_spir_artifacts(half)
+install_spir_artifacts(kernel_attributes)
+install_spir_artifacts(kernel_image_methods)
+install_spir_artifacts(images_kernel_read_write)
+install_spir_artifacts(images_samplerlessRead)
+install_spir_artifacts(integer_ops)
+install_spir_artifacts(math_brute_force)
+install_spir_artifacts(printf)
+install_spir_artifacts(profiling)
+install_spir_artifacts(relationals)
+install_spir_artifacts(select)
+install_spir_artifacts(sampler_enumeration)
+install_spir_artifacts(vec_align)
+install_spir_artifacts(vec_step)
+install_spir_artifacts(binary_type)
+install(FILES "khr.csv" DESTINATION "${CLConf_OUT_DIR}" COMPONENT OpenCLCTS)
+#Add any other runtime directories you need here.
+# end of file #

test_conformance/spir/Makefile

@@ -0,0 +1,45 @@
+ifdef BUILD_WITH_ATF
+ATF = -framework ATF
+USE_ATF = -DUSE_ATF
+endif
+
+SRCS = main.cpp datagen.cpp kernelargs.cpp run_build_test.cpp run_services.cpp \
+			../../test_common/miniz/miniz.c \
+			../../test_common/harness/testHarness.c \
+			../../test_common/harness/errorHelpers.c \
+			../../test_common/harness/typeWrappers.cpp \
+			../../test_common/harness/mt19937.c \
+			../../test_common/harness/os_helpers.c \
+			../../test_common/harness/kernelHelpers.c
+
+SOURCES = $(abspath $(SRCS))
+
+
+LIBPATH += -L/System/Library/Frameworks/OpenCL.framework/Libraries
+LIBPATH += -L.
+           
+FRAMEWORK = ${SOURCES}
+HEADERS = 
+TARGET = test_spir
+INCLUDE = 
+COMPILERFLAGS = -c -Wall -g -Wshorten-64-to-32
+#COMPILERFLAGS = -c -Wall -g -DUSE_LOCAL_THREADS
+CC = c++
+CFLAGS = $(COMPILERFLAGS) $(RC_CFLAGS) ${USE_ATF}
+CXXFLAGS= $(COMPILERFLAGS) $(RC_CFLAGS) ${USE_ATF}
+LIBRARIES = -framework OpenCL -framework OpenGL -framework GLUT -framework AppKit ${ATF}
+
+OBJECTS := ${SOURCES:.c=.o}
+OBJECTS := ${OBJECTS:.cpp=.o}
+           
+TARGETOBJECT =
+all: $(TARGET)
+
+$(TARGET): $(OBJECTS)
+	$(CC) $(RC_CFLAGS) $(OBJECTS) -o $@ $(LIBPATH) $(LIBRARIES)
+
+clean:
+	rm -f $(TARGET) $(OBJECTS)
+
+.DEFAULT:
+	@echo The target \"$@\" does not exist in Makefile.

test_conformance/spir/datagen.cpp

@@ -0,0 +1,644 @@
+//
+// Copyright (c) 2017 The Khronos Group Inc.
+// 
+// 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 "../../test_common/harness/compat.h"
+#include "exceptions.h"
+#include "datagen.h"
+
+RandomGenerator gRG;
+
+size_t WorkSizeInfo::getGlobalWorkSize() const
+{
+    switch( work_dim )
+    {
+    case 1: return global_work_size[0];
+    case 2: return global_work_size[0] * global_work_size[1];
+    case 3: return global_work_size[0] * global_work_size[1] * global_work_size[2];
+    default:
+        throw Exceptions::TestError("wrong work dimention\n");
+    }
+}
+
+/*
+ * DataGenerator
+ */
+
+DataGenerator* DataGenerator::Instance = NULL;
+
+DataGenerator* DataGenerator::getInstance()
+{
+    if (!Instance)
+        Instance = new DataGenerator();
+
+    return Instance;
+}
+
+DataGenerator::DataGenerator()
+{
+    #define TYPE_HNDL( type, isBuffer, base_element_size, vector_size, min_value, max_value, Generator) \
+    assert(m_argGenerators.find(type) == m_argGenerators.end()) ; \
+    m_argGenerators[type] = new Generator( isBuffer, vector_size, min_value, max_value);
+    #include "typeinfo.h"
+    #undef TYPE_HNDL
+}
+
+DataGenerator::~DataGenerator()
+{
+    ArgGeneratorsMap::iterator i = m_argGenerators.begin();
+    ArgGeneratorsMap::iterator e = m_argGenerators.end();
+
+    for(; i != e; ++i)
+    {
+        delete i->second;
+    }
+}
+
+KernelArgGenerator* DataGenerator::getArgGenerator( const KernelArgInfo& argInfo )
+{
+    //try to match the full type first
+    ArgGeneratorsMap::iterator i = m_argGenerators.find(argInfo.getTypeName());
+    ArgGeneratorsMap::iterator e = m_argGenerators.end();
+
+    if( i != e )
+    {
+        return i->second;
+    }
+    // search for the proper prefix of the type
+    for(i = m_argGenerators.begin(); i != e; ++i)
+    {
+        if( 0 == argInfo.getTypeName().find(i->first))
+        {
+            return i->second;
+        }
+    }
+    throw Exceptions::TestError(std::string("Can't find the generator for the type ")
+      + argInfo.getTypeName() + " for argument " + argInfo.getName() + "\n");
+}
+
+void DataGenerator::setArgGenerator(const KernelArgInfo& argInfo,
+                                    KernelArgGenerator* pGen)
+{
+    m_argGenerators[argInfo.getTypeName()] = pGen;
+}
+
+float get_random_float(float low, float high, MTdata d)
+{
+    float t = (float)((double)genrand_int32(d) / (double)0xFFFFFFFF);
+    return (1.0f - t) * low + t * high;
+}
+
+double get_random_double(double low, double high, MTdata d)
+{
+    cl_ulong u = (cl_ulong) genrand_int32(d) | ((cl_ulong) genrand_int32(d) << 32 );
+    double t = (double) u * MAKE_HEX_DOUBLE( 0x1.0p-64, 0x1, -64);
+    return (1.0f - t) * low + t * high;
+}
+
+size_t get_random_size_t(size_t low, size_t high, MTdata d)
+{
+  enum { N = sizeof(size_t)/sizeof(int) };
+
+  union {
+    int word[N];
+    size_t size;
+  } u;
+
+  for (unsigned i=0; i != N; ++i) {
+    u.word[i] = genrand_int32(d);
+  }
+
+  assert(low <= high && "Invalid random number range specified");
+  size_t range = high - low;
+
+  return (range) ? low + ((u.size - low) % range) : low;
+}
+
+size_t get_random_int32(int low, int high, MTdata d)
+{
+  int v = genrand_int32(d);
+
+  assert(low <= high && "Invalid random number range specified");
+  size_t range = high - low;
+
+  return (range) ? low + ((v - low) % range) : low;
+}
+
+/*
+ * KernelArgGeneratorSampler
+ */
+KernelArgGeneratorSampler::KernelArgGeneratorSampler(bool isBuffer,
+                                                     size_t vectorSize,
+                                                     int minValue,
+                                                     int maxValue) {
+  initToDefaults();
+}
+
+void KernelArgGeneratorSampler::initToDefaults() {
+  m_normalized = false;
+  m_addressingMode = CL_ADDRESS_NONE;
+  m_filterMode = CL_FILTER_NEAREST;
+}
+
+KernelArgGeneratorSampler::KernelArgGeneratorSampler() {
+  initToDefaults();
+
+}
+
+void KernelArgGeneratorSampler::setNormalized(cl_bool isNormalized)
+{
+    m_normalized = isNormalized;
+}
+
+void KernelArgGeneratorSampler::setAddressingMode(cl_addressing_mode mode)
+{
+    m_addressingMode = mode;
+}
+
+void KernelArgGeneratorSampler::setFiterMode(cl_filter_mode mode)
+{
+    m_filterMode = mode;
+}
+
+
+/*
+ * SamplerValuesGenerator.
+ */
+
+/*
+ * Static fields initialization.
+ */
+cl_bool SamplerValuesGenerator::coordNormalizations[] = {CL_TRUE, CL_FALSE};
+
+cl_filter_mode SamplerValuesGenerator::filterModes[]  = {
+    CL_FILTER_NEAREST,
+    CL_FILTER_LINEAR
+};
+
+cl_addressing_mode SamplerValuesGenerator::addressingModes[] = {
+    CL_ADDRESS_NONE,
+    CL_ADDRESS_CLAMP,
+    CL_ADDRESS_CLAMP_TO_EDGE,
+    CL_ADDRESS_REPEAT,
+    CL_ADDRESS_MIRRORED_REPEAT
+};
+
+const size_t NUM_NORM_MODES =
+    sizeof(SamplerValuesGenerator::coordNormalizations)/sizeof(cl_bool);
+
+const size_t NUM_FILTER_MODES =
+    sizeof(SamplerValuesGenerator::filterModes)/sizeof(cl_filter_mode);
+
+const size_t NUM_ADDR_MODES =
+    sizeof(SamplerValuesGenerator::addressingModes)/sizeof(cl_addressing_mode);
+
+SamplerValuesGenerator::iterator SamplerValuesGenerator::end()
+{
+    return iterator(NUM_NORM_MODES-1, NUM_FILTER_MODES-1, NUM_ADDR_MODES-1);
+}
+
+/*
+ * A constructor for generating an 'end iterator'.
+ */
+SamplerValuesGenerator::iterator::iterator(size_t norm, size_t filter,
+                                           size_t addressing):
+    m_normIndex(norm), m_filterIndex(filter), m_addressingModeIndex(addressing){}
+
+/*
+ * A constructor for generating a 'begin iterator'.
+ */
+SamplerValuesGenerator::iterator::iterator():
+    m_normIndex(0), m_filterIndex(0), m_addressingModeIndex(0){}
+
+SamplerValuesGenerator::iterator& SamplerValuesGenerator::iterator::operator ++()
+{
+    if (incrementIndex(m_normIndex, NUM_NORM_MODES)) return *this;
+    if (incrementIndex(m_filterIndex, NUM_FILTER_MODES)) return *this;
+    if (incrementIndex(m_addressingModeIndex, NUM_ADDR_MODES)) return *this;
+
+    assert(false && "incrementing end iterator!");
+    return *this;
+}
+
+bool SamplerValuesGenerator::iterator::incrementIndex(size_t &i,
+                                                      const size_t limit)
+{
+    i = (i+1) % limit;
+    return i != 0;
+}
+
+bool SamplerValuesGenerator::iterator::operator == (const iterator& other) const
+{
+    return m_normIndex == other.m_normIndex &&
+         m_filterIndex == other.m_filterIndex &&
+         m_addressingModeIndex == other.m_addressingModeIndex;
+}
+
+bool SamplerValuesGenerator::iterator::operator != (const iterator& other) const
+{
+    return !(*this == other);
+}
+
+cl_bool SamplerValuesGenerator::iterator::getNormalized() const
+{
+    assert(m_normIndex < NUM_NORM_MODES && "illegal index");
+    return coordNormalizations[m_normIndex];
+}
+
+cl_filter_mode SamplerValuesGenerator::iterator::getFilterMode() const
+{
+    assert(m_filterIndex < NUM_FILTER_MODES && "illegal index");
+    return filterModes[m_filterIndex];
+}
+
+cl_addressing_mode SamplerValuesGenerator::iterator::getAddressingMode() const
+{
+    assert(m_addressingModeIndex < NUM_ADDR_MODES && "illegal index");
+    return addressingModes[m_addressingModeIndex];
+}
+
+unsigned SamplerValuesGenerator::iterator::toBitmap() const
+{
+    unsigned norm, filter, addressingModes;
+    switch (getNormalized())
+    {
+    case CL_TRUE:
+        norm = 8;
+        break;
+    case CL_FALSE:
+        norm = 0;
+        break;
+    default:
+    assert(0 && "invalid normalize value");
+    }
+
+    switch (getFilterMode())
+    {
+    case CL_FILTER_NEAREST:
+        filter = 0;
+        break;
+    case CL_FILTER_LINEAR:
+        filter = 16;
+        break;
+    default:
+    assert(0 && "invalid filter value");
+    }
+
+    switch(getAddressingMode())
+    {
+    case CL_ADDRESS_NONE:
+        addressingModes = 0;
+        break;
+    case CL_ADDRESS_CLAMP:
+        addressingModes = 1;
+        break;
+    case CL_ADDRESS_CLAMP_TO_EDGE:
+        addressingModes = 2;
+        break;
+    case CL_ADDRESS_REPEAT:
+        addressingModes = 3;
+        break;
+    case CL_ADDRESS_MIRRORED_REPEAT:
+        addressingModes = 4;
+        break;
+    default:
+    assert(0 && "invalid filter value");
+    }
+
+    return norm | filter | addressingModes;
+}
+
+std::string SamplerValuesGenerator::iterator::toString() const
+{
+    std::string ret("(");
+
+    switch (getNormalized())
+    {
+    case CL_TRUE:
+        ret.append("Normalized | ");
+        break;
+    case CL_FALSE:
+        ret.append("Not Normalized | ");
+        break;
+    default:
+    assert(0 && "invalid normalize value");
+    }
+
+    switch (getFilterMode())
+    {
+    case CL_FILTER_NEAREST:
+        ret.append("Filter Nearest | ");
+        break;
+    case CL_FILTER_LINEAR:
+        ret.append("Filter Linear | ");
+        break;
+    default:
+    assert(0 && "invalid filter value");
+    }
+
+    switch(getAddressingMode())
+    {
+    case CL_ADDRESS_NONE:
+        ret.append("Address None");
+        break;
+    case CL_ADDRESS_CLAMP:
+        ret.append("Address clamp");
+        break;
+    case CL_ADDRESS_CLAMP_TO_EDGE:
+        ret.append("Address clamp to edge");
+        break;
+    case CL_ADDRESS_REPEAT:
+        ret.append("Address repeat");
+        break;
+    case CL_ADDRESS_MIRRORED_REPEAT:
+        ret.append("Address mirrored repeat");
+        break;
+    default:
+    assert(0 && "invalid filter value");
+    }
+
+    ret.append(")");
+    return ret;
+}
+
+/*
+ * ImageValuesGenerator.
+ */
+
+/*
+ * Static fields initialization.
+ */
+const char* ImageValuesGenerator::imageTypes[] = {
+    "image1d_array_float",
+    "image1d_array_int",
+    "image1d_array_uint",
+    "image1d_buffer_float",
+    "image1d_buffer_int",
+    "image1d_buffer_uint",
+    "image1d_float",
+    "image1d_int",
+    "image1d_uint",
+    "image2d_array_float",
+    "image2d_array_int",
+    "image2d_array_uint",
+    "image2d_float",
+    "image2d_int",
+    "image2d_uint",
+    "image3d_float",
+    "image3d_int",
+    "image3d_uint"
+};
+
+cl_channel_order ImageValuesGenerator::channelOrders[] = {
+    CL_A,
+    CL_R,
+    CL_Rx,
+    CL_RG,
+    CL_RGx,
+    CL_RA,
+    CL_RGB,
+    CL_RGBx,
+    CL_RGBA,
+    CL_ARGB,
+    CL_BGRA,
+    CL_INTENSITY,
+    CL_LUMINANCE,
+    CL_DEPTH,
+    CL_DEPTH_STENCIL
+};
+
+const size_t NUM_CHANNEL_ORDERS = sizeof(ImageValuesGenerator::channelOrders)/sizeof(ImageValuesGenerator::channelOrders[0]);
+const size_t NUM_IMG_TYS = sizeof(ImageValuesGenerator::imageTypes)/sizeof(ImageValuesGenerator::imageTypes[0]);
+
+ImageValuesGenerator::iterator ImageValuesGenerator::begin()
+{
+    return ImageValuesGenerator::iterator(this);
+}
+
+ImageValuesGenerator::iterator ImageValuesGenerator::end()
+{
+    return ImageValuesGenerator::iterator(0);
+}
+/*
+ * Class Iterator
+ */
+ImageValuesGenerator::iterator::iterator(ImageValuesGenerator *pParent):
+    m_parent(pParent), m_channelIndex(0), m_imgTyIndex(0)
+{
+}
+
+/*
+ * Initializes an 'end' iterator.
+ */
+ImageValuesGenerator::iterator::iterator(int):
+    m_parent(NULL),
+    m_channelIndex(NUM_CHANNEL_ORDERS),
+    m_imgTyIndex(NUM_IMG_TYS) {}
+
+ImageValuesGenerator::iterator& ImageValuesGenerator::iterator::operator ++()
+{
+    assert(m_channelIndex < NUM_CHANNEL_ORDERS && m_imgTyIndex < NUM_IMG_TYS &&
+           "Attempt to increment an end iterator");
+
+    ImageValuesGenerator::iterator endIter = iterator(0);
+    // Incrementing untill we find the next legal combination, or we reach the
+    // end value.
+    while (incrementIndex(m_channelIndex,NUM_CHANNEL_ORDERS))
+        if (isLegalCombination())
+            return *this;
+
+     // We have reach to this line because last increment caused an 'oveflow'
+     // in data channel order index.
+     if (incrementIndex(m_imgTyIndex, NUM_IMG_TYS))
+        // In case this combination is not legal, we go on to the next legal
+        // combo.
+        return isLegalCombination() ? *this : ++(*this);
+
+    *this = endIter;
+    return *this;
+}
+
+bool ImageValuesGenerator::iterator::operator == (
+    const ImageValuesGenerator::iterator& o) const
+{
+    return m_channelIndex == o.m_channelIndex &&
+           m_imgTyIndex == o.m_imgTyIndex;
+}
+
+bool ImageValuesGenerator::iterator::operator != (
+    const ImageValuesGenerator::iterator& o) const
+{
+    return !(*this == o);
+}
+
+std::string ImageValuesGenerator::iterator::getDataTypeName() const
+{
+    assert(m_imgTyIndex < NUM_IMG_TYS && "image type index is out of bound");
+
+    std::string tyName(imageTypes[m_imgTyIndex]);
+    // Find the last '_' and remove it (the suffix is _<channel type>).
+    size_t pos = tyName.find_last_of('_');
+    assert (std::string::npos != pos && "no under score in type name?");
+    tyName = tyName.erase(0, pos+1);
+    return tyName;
+}
+
+int ImageValuesGenerator::iterator::getOpenCLChannelOrder() const
+{
+    assert(m_channelIndex < NUM_CHANNEL_ORDERS && "channel index out of bound");
+    return channelOrders[m_channelIndex];
+}
+
+int ImageValuesGenerator::iterator::getSPIRChannelOrder() const
+{
+    return getOpenCLChannelOrder();
+}
+
+std::string ImageValuesGenerator::iterator::getImageTypeName() const
+{
+    assert(m_imgTyIndex < NUM_IMG_TYS && "image type index is out of bound");
+
+    std::string tyName = imageTypes[m_imgTyIndex];
+    // Find the last '_' and remove it (the suffix is _<channel type>).
+    size_t pos = tyName.find_last_of('_');
+    assert (std::string::npos != pos && "no under score in type name?");
+    tyName = tyName.erase(pos, tyName.size() - pos);
+
+    return tyName;
+}
+
+std::string ImageValuesGenerator::iterator::getImageGeneratorName() const
+{
+    assert(m_imgTyIndex < NUM_IMG_TYS && "image type index is out of bound");
+    return imageTypes[m_imgTyIndex];
+}
+
+std::string ImageValuesGenerator::iterator::getBaseImageGeneratorName() const
+{
+    assert(m_imgTyIndex < NUM_IMG_TYS && "image type index is out of bound");
+    std::string tyName = getImageTypeName();
+    tyName.append("_t");
+    return tyName;
+}
+
+int ImageValuesGenerator::iterator::getDataType() const
+{
+    assert(m_imgTyIndex < NUM_IMG_TYS && "image type index is out of bound");
+    std::string tyName = getDataTypeName();
+
+    if ("int" == tyName)
+       return SPIR_CLK_SIGNED_INT32;
+    if ("uint" == tyName)
+        return SPIR_CLK_UNSIGNED_INT32;
+    if ("float" == tyName)
+        return SPIR_CLK_FLOAT;
+    assert (false && "unkown image data type");
+    return -1;
+}
+
+std::string ImageValuesGenerator::iterator::toString() const
+{
+    if (*this == m_parent->end())
+        return "End iterator";
+
+    // Sanity.
+    assert(m_imgTyIndex < NUM_IMG_TYS && "image type index is out of bound");
+    assert(m_channelIndex < NUM_CHANNEL_ORDERS && "channel index out of bound");
+
+    std::string str = imageTypes[m_imgTyIndex];
+    str.append("_");
+
+    switch (channelOrders[m_channelIndex])
+    {
+    case CL_R:
+        str.append("cl_r");
+        break;
+    case CL_A:
+        str.append("cl_a");
+        break;
+    case CL_RG:
+        str.append("cl_rg");
+        break;
+    case CL_RA:
+        str.append("cl_ra");
+        break;
+    case CL_RGB:
+        str.append("cl_rgb");
+        break;
+    case CL_RGBA:
+        str.append("cl_rgba");
+        break;
+    case CL_BGRA:
+        str.append("cl_bgra");
+        break;
+    case CL_ARGB:
+        str.append("cl_argb");
+        break;
+    case CL_INTENSITY:
+        str.append("cl_intensity");
+        break;
+    case CL_LUMINANCE:
+        str.append("cl_luminace");
+        break;
+    case CL_Rx:
+        str.append("cl_Rx");
+        break;
+    case CL_RGx:
+        str.append("cl_RGx");
+        break;
+    case CL_RGBx:
+        str.append("cl_RGBx");
+        break;
+    case CL_DEPTH:
+        str.append("cl_depth");
+        break;
+    case CL_DEPTH_STENCIL:
+        str.append( "cl_depth_stencil");
+        break;
+    default:
+        assert(false && "Invalid channel order");
+        str.append("<invalid channel order>");
+        break;
+    }
+
+    return str;
+}
+
+bool ImageValuesGenerator::iterator::incrementIndex(size_t& index,
+                                                    size_t arrSize)
+{
+    index = (index + 1) % arrSize;
+    return index != 0;
+}
+
+bool ImageValuesGenerator::iterator::isLegalCombination() const
+{
+    cl_channel_order corder = channelOrders[m_channelIndex];
+    std::string strImgTy(imageTypes[m_imgTyIndex]);
+
+    if (corder == CL_INTENSITY || corder == CL_LUMINANCE)
+    {
+        return getDataTypeName() == std::string("float");
+    }
+
+    if (corder == CL_DEPTH)
+        return false;
+
+    if (corder == CL_RGBx || corder == CL_RGB // Can only be applied for int unorms.
+        || corder == CL_ARGB || corder == CL_BGRA) // Can only be applied for int8.
+        return false;
+
+    return true;
+}
+

test_conformance/spir/exceptions.h

@@ -0,0 +1,53 @@
+//
+// Copyright (c) 2017 The Khronos Group Inc.
+// 
+// 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.
+//
+#ifndef __EXCEPTIONS_H
+#define __EXCEPTIONS_H
+
+#include <stdexcept>
+#include "../../test_common/miniz/miniz.h"
+
+namespace Exceptions
+{
+    /**
+    Exception thrown on error in command line parameters
+    */
+    class CmdLineError : public std::runtime_error
+    {
+    public:
+        CmdLineError (const std::string& msg): std::runtime_error(msg){}
+    };
+
+    /**
+    Exception thrown on error in test run
+    */
+    class TestError : public std::runtime_error
+    {
+    public:
+        TestError (const std::string& msg, int errorCode = 1): std::runtime_error(msg), m_errorCode(errorCode){}
+
+        int getErrorCode() const { return m_errorCode; }
+    private:
+        int m_errorCode;
+    };
+
+    class ArchiveError : public std::runtime_error
+    {
+    public:
+        ArchiveError(int errCode): std::runtime_error(mz_error(errCode)){}
+    };
+}
+
+#endif

test_conformance/spir/kernelargs.cpp

@@ -0,0 +1,24 @@
+//
+// Copyright (c) 2017 The Khronos Group Inc.
+// 
+// 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 "../../test_common/harness/compat.h"
+#include "kernelargs.h"
+#include "datagen.h"
+
+KernelArg* KernelArg::clone(cl_context ctx, const WorkSizeInfo& ws, const cl_kernel kernel, const cl_device_id device) const
+{
+    return DataGenerator::getInstance()->generateKernelArg(ctx, m_argInfo, ws,
+                                                           this, kernel, device);
+}

test_conformance/spir/kernelargs.h

@@ -0,0 +1,444 @@
+//
+// Copyright (c) 2017 The Khronos Group Inc.
+// 
+// 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.
+//
+#ifndef __KERNELARGS_H
+#define __KERNELARGS_H
+
+
+#ifdef __APPLE__
+#include <OpenCL/opencl.h>
+#else
+#include <CL/cl.h>
+#endif
+
+#include <assert.h>
+
+#include <string>
+#include <vector>
+#include <iostream>
+
+#include "../../test_common/harness/typeWrappers.h"
+
+#include "exceptions.h"
+
+class WorkSizeInfo;
+
+/**
+ Represents the single kernel argument information
+ */
+class KernelArgInfo
+{
+public:
+    cl_kernel_arg_address_qualifier getAddressQualifier() const { return m_address_qualifier; }
+    cl_kernel_arg_access_qualifier  getAccessQualifier() const { return m_access_qualifier; }
+    cl_kernel_arg_type_qualifier    getTypeQualifier() const { return m_type_qualifier; }
+
+    cl_kernel_arg_address_qualifier* getAddressQualifierRef() { return &m_address_qualifier; }
+    cl_kernel_arg_access_qualifier*  getAccessQualifierRef() { return &m_access_qualifier; }
+    cl_kernel_arg_type_qualifier*    getTypeQualifierRef() { return &m_type_qualifier; }
+
+    void setTypeName( const char* name) { m_type.assign(name); }
+    void setName( const char* name) { m_name.assign(name); }
+
+    std::string getTypeName() const { return m_type; }
+    std::string getName() const { return m_name; }
+
+    bool operator == ( const KernelArgInfo& rhs ) const
+    {
+        return !m_name.compare(rhs.m_name) &&
+            !m_type.compare(rhs.m_type) &&
+            m_address_qualifier == rhs.m_address_qualifier &&
+            m_access_qualifier == rhs.m_access_qualifier &&
+            m_type_qualifier == rhs.m_type_qualifier;
+    }
+
+    bool operator != ( const KernelArgInfo& rhs ) const
+    {
+        return !(*this == rhs);
+    }
+
+private:
+    std::string m_name;
+    std::string m_type;
+    cl_kernel_arg_address_qualifier m_address_qualifier;
+    cl_kernel_arg_access_qualifier  m_access_qualifier;
+    cl_kernel_arg_type_qualifier    m_type_qualifier;
+};
+
+/**
+ Represents the single kernel's argument value.
+ Responsible for livekeeping of OCL objects.
+ */
+class KernelArg
+{
+public:
+    KernelArg(const KernelArgInfo& argInfo, void* buffer, size_t size):
+      m_argInfo(argInfo),
+      m_buffer(buffer),
+      m_size(size)
+    {}
+
+    virtual ~KernelArg()
+    {
+        align_free(m_buffer);
+    }
+
+    virtual size_t getArgSize() const
+    {
+        return m_size;
+    }
+
+    virtual const void* getBuffer() const
+    {
+        return m_buffer;
+    }
+
+    virtual const void* getArgValue() const
+    {
+        return m_buffer;
+    }
+
+    virtual bool compare( const KernelArg& rhs ) const
+    {
+        if( m_argInfo != rhs.m_argInfo )
+        {
+            return false;
+        }
+
+        if( m_size != rhs.m_size)
+        {
+            return false;
+        }
+
+        if( (NULL == m_buffer || NULL == rhs.m_buffer) && m_buffer != rhs.m_buffer )
+        {
+            return false;
+        }
+
+        //check two NULL buffers case
+        if( NULL == m_buffer && NULL == rhs.m_buffer )
+        {
+            return true;
+        }
+
+        if( memcmp( m_buffer, rhs.m_buffer, m_size) )
+        {
+            size_t compared = 0;
+            while (compared < m_size)
+            {
+                if ( *(((char*)m_buffer)+compared) != *(((char*)rhs.m_buffer)+compared) )
+                {
+                    std::cerr << std::endl << " difference is at offset " << compared << std::endl;
+                    return false;
+                }
+                compared++;
+            }
+        }
+
+        return true;
+    }
+
+    virtual void readToHost(cl_command_queue queue)
+    {
+        return;
+    }
+
+    KernelArg* clone(cl_context context, const WorkSizeInfo& ws, const cl_kernel kernel, const cl_device_id device) const;
+
+protected:
+    KernelArgInfo m_argInfo;
+    void*  m_buffer;
+    size_t m_size;
+};
+
+class KernelArgSampler:public KernelArg
+{
+public:
+    KernelArgSampler(cl_context context, cl_bool isNormalized,
+                     cl_addressing_mode addressMode, cl_filter_mode filterMode):
+    KernelArg(KernelArgInfo(), NULL, sizeof(cl_sampler))
+    {
+        m_argInfo.setTypeName("sampler_t");
+        int error = CL_SUCCESS;
+        m_samplerObj = clCreateSampler(context, isNormalized, addressMode,
+                                       filterMode, &error);
+        if( error != CL_SUCCESS )
+        {
+            throw Exceptions::TestError("clCreateSampler failed\n", error);
+        }
+    }
+
+    ~KernelArgSampler()
+    {
+        //~clSamplerWrapper() releases the sampler object
+    }
+
+    size_t getArgSize() const
+    {
+        return sizeof(cl_sampler);
+    }
+
+    const void* getArgValue() const
+    {
+        return &m_samplerObj;
+    }
+
+    bool compare( const KernelArg& rhs ) const
+    {
+        if (const KernelArgSampler *Rhs = dynamic_cast<const KernelArgSampler*>(&rhs))
+        {
+            return isNormalized() == Rhs->isNormalized() &&
+                   getAddressingMode() == Rhs->getAddressingMode() &&
+                   getFilterMode() == Rhs->getFilterMode();
+        }
+        return false;
+    }
+
+    cl_sampler getSampler() const
+    {
+      return (cl_sampler)m_samplerObj;
+    }
+
+protected:
+    mutable clSamplerWrapper m_samplerObj;
+
+    cl_bool isNormalized() const
+    {
+        cl_bool norm;
+        cl_int err = clGetSamplerInfo(getSampler(),
+                                      CL_SAMPLER_NORMALIZED_COORDS,
+                                      sizeof(cl_bool),
+                                      &norm,
+                                      NULL);
+        if (CL_SUCCESS != err)
+            throw Exceptions::TestError("clGetSamplerInfo failed\n", err);
+        return norm;
+    }
+
+    cl_addressing_mode getAddressingMode() const
+    {
+        cl_addressing_mode addressingmode;
+        cl_int err = clGetSamplerInfo(getSampler(),
+                                      CL_SAMPLER_ADDRESSING_MODE,
+                                      sizeof(cl_addressing_mode),
+                                      &addressingmode,
+                                      NULL);
+        if (CL_SUCCESS != err)
+            throw Exceptions::TestError("clGetSamplerInfo failed\n", err);
+        return addressingmode;
+    }
+
+    cl_filter_mode getFilterMode() const
+    {
+        cl_filter_mode filtermode;
+        cl_int err = clGetSamplerInfo(getSampler(),
+                                      CL_SAMPLER_FILTER_MODE,
+                                      sizeof(cl_filter_mode),
+                                      &filtermode,
+                                      NULL);
+        if (CL_SUCCESS != err)
+            throw Exceptions::TestError("clGetSamplerInfo failed\n", err);
+        return filtermode;
+    }
+
+};
+
+
+class KernelArgMemObj:public KernelArg
+{
+public:
+    KernelArgMemObj(const KernelArgInfo& argInfo, void* buffer, size_t size):
+      KernelArg(argInfo, buffer, size)
+    {
+        m_memObj = NULL;
+    }
+
+    ~KernelArgMemObj()
+    {
+        //~clMemWrapper() releases the memory object
+    }
+
+    virtual void readToHost(cl_command_queue queue)  = 0;
+
+
+    size_t getArgSize() const
+    {
+        if( NULL == m_buffer )
+            return m_size;              // local buffer
+        else
+            return sizeof(cl_mem);
+    }
+
+    const void* getArgValue() const
+    {
+        if( NULL == m_buffer )
+        {
+            return NULL;                // local buffer
+        }
+        else {
+            clMemWrapper* p = const_cast<clMemWrapper*>(&m_memObj);
+
+            return (const void*)(&(*p));
+        }
+    }
+
+protected:
+    clMemWrapper m_memObj;
+};
+
+/**
+ Represents the single kernel's argument value.
+ Responsible for livekeeping of OCL objects.
+ */
+class KernelArgBuffer:public KernelArgMemObj
+{
+public:
+    KernelArgBuffer(cl_context context, const KernelArgInfo& argInfo, void* buffer, size_t size):
+        KernelArgMemObj(argInfo, buffer, size)
+    {
+        if( NULL != buffer )
+        {
+            int error = CL_SUCCESS;
+            m_memObj = clCreateBuffer( context,
+                                       (cl_mem_flags)( CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR ),
+                                       size, buffer, &error );
+            if( error != CL_SUCCESS )
+            {
+                throw Exceptions::TestError("clCreateBuffer failed\n", error);
+            }
+        }
+    }
+
+    void readToHost(cl_command_queue queue)
+    {
+        if( NULL == m_buffer )
+        {
+            return;
+        }
+
+        int error = clEnqueueReadBuffer( queue, m_memObj, CL_TRUE, 0, m_size, m_buffer, 0, NULL, NULL);
+        if( error != CL_SUCCESS )
+        {
+            throw Exceptions::TestError("clEnqueueReadBuffer failed\n", error);
+        }
+    }
+};
+
+class KernelArgImage:public KernelArgMemObj
+{
+public:
+    KernelArgImage(cl_context context, const KernelArgInfo& argInfo,
+                   void* buffer, size_t size, cl_mem_flags flags,
+                   cl_image_format format, cl_image_desc desc):
+    KernelArgMemObj(argInfo, buffer, size), m_desc(desc)
+    {
+        if( NULL != buffer )
+        {
+            int error = CL_SUCCESS;
+            flags |= CL_MEM_COPY_HOST_PTR ;
+            if (CL_MEM_OBJECT_IMAGE1D_BUFFER == m_desc.image_type)
+            {
+                m_desc.buffer = clCreateBuffer( context, flags, m_desc.image_row_pitch, buffer, &error );
+                if( error != CL_SUCCESS )
+                {
+                    throw Exceptions::TestError("KernelArgImage clCreateBuffer failed\n", error);
+                }
+                buffer = NULL;
+                flags &= ~CL_MEM_COPY_HOST_PTR;
+                m_desc.image_row_pitch = 0;
+                m_desc.image_slice_pitch = 0;
+            }
+            m_memObj = clCreateImage( context, flags, &format, &m_desc, buffer, &error );
+            if( error != CL_SUCCESS )
+            {
+                throw Exceptions::TestError("KernelArgImage clCreateImage failed\n", error);
+            }
+        }
+    }
+
+    ~KernelArgImage()
+    {
+        if (CL_MEM_OBJECT_IMAGE1D_BUFFER == m_desc.image_type)
+        {
+             clReleaseMemObject(m_desc.buffer);
+        }
+    }
+
+    void readToHost(cl_command_queue queue)
+    {
+        if( NULL == m_buffer )
+        {
+            return;
+        }
+
+        size_t origin[3] = {0, 0, 0};
+        size_t region[3] = {m_desc.image_width , m_desc.image_height , m_desc.image_depth};
+
+        int error = clEnqueueReadImage (queue, m_memObj, CL_TRUE, origin, region, m_desc.image_row_pitch, m_desc.image_slice_pitch, m_buffer, 0, NULL, NULL);
+
+        if( error != CL_SUCCESS )
+        {
+            throw Exceptions::TestError("clEnqueueReadImage failed\n", error);
+        }
+    }
+
+private:
+    cl_image_desc m_desc;
+};
+
+/**
+ Represents the container for the kernel parameters
+ */
+class KernelArgs
+{
+    typedef std::vector<KernelArg*> KernelsArgsVector;
+public:
+    KernelArgs(){}
+    ~KernelArgs()
+    {
+        KernelsArgsVector::iterator i = m_args.begin();
+        KernelsArgsVector::iterator e = m_args.end();
+
+        for( ; i != e; ++i )
+        {
+            assert( NULL != *i );
+            delete *i;
+        }
+    }
+
+    void readToHost(cl_command_queue queue)
+    {
+        KernelsArgsVector::iterator i = m_args.begin();
+        KernelsArgsVector::iterator e = m_args.end();
+
+        for( ; i != e; ++i )
+        {
+            (*i)->readToHost(queue);
+        }
+    }
+
+    size_t getArgCount() const { return m_args.size(); }
+
+    KernelArg* getArg(size_t index ) { return m_args[index]; }
+
+    const KernelArg* getArg(size_t index) const { return m_args[index]; }
+
+    void addArg( KernelArg* arg ) { m_args.push_back(arg); }
+
+private:
+    KernelsArgsVector m_args;
+};
+
+#endif

test_conformance/spir/run_build_test.cpp

@@ -0,0 +1,422 @@
+//
+// Copyright (c) 2017 The Khronos Group Inc.
+// 
+// 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 "../../test_common/harness/compat.h"
+
+#ifdef __APPLE__
+#include <OpenCL/opencl.h>
+#else
+#include <CL/cl.h>
+#endif
+
+#include <sstream>
+#include <fstream>
+#include <assert.h>
+#include <functional>
+#include <memory>
+
+#include "../../test_common/harness/errorHelpers.h"
+#include "../../test_common/harness/kernelHelpers.h"
+#include "../../test_common/harness/typeWrappers.h"
+#include "../../test_common/harness/clImageHelper.h"
+#include "../../test_common/harness/os_helpers.h"
+
+#include "exceptions.h"
+#include "kernelargs.h"
+#include "datagen.h"
+#include "run_services.h"
+#include "run_build_test.h"
+
+//
+// Task
+//
+Task::Task(cl_device_id device, const char* options):
+m_devid(device) {
+  if (options)
+    m_options = options;
+}
+
+Task::~Task() {}
+
+const char* Task::getErrorLog() const {
+  return m_log.c_str();
+}
+
+void Task::setErrorLog(cl_program prog) {
+    size_t len = 0;
+    std::vector<char> log;
+
+    cl_int err_code = clGetProgramBuildInfo(prog, m_devid, CL_PROGRAM_BUILD_LOG, 0, NULL, &len);
+    if(err_code != CL_SUCCESS)
+    {
+        m_log = "Error: clGetProgramBuildInfo(CL_PROGRAM_BUILD_LOG, &len) failed.\n";
+        return;
+    }
+
+    log.resize(len, 0);
+
+    err_code = clGetProgramBuildInfo(prog, m_devid, CL_PROGRAM_BUILD_LOG, len, &log[0], NULL);
+    if(err_code != CL_SUCCESS)
+    {
+        m_log = "Error: clGetProgramBuildInfo(CL_PROGRAM_BUILD_LOG, &log) failed.\n";
+        return;
+    }
+    m_log.append(&log[0]);
+}
+
+//
+// BuildTask
+//
+BuildTask::BuildTask(cl_program prog, cl_device_id dev, const char* options) :
+    m_program(prog), Task(dev, options) {}
+
+bool BuildTask::execute() {
+    cl_int err_code = clBuildProgram(m_program, 0, NULL, m_options.c_str(), NULL, NULL);
+    if(CL_SUCCESS == err_code)
+        return true;
+
+    setErrorLog(m_program);
+    return false;
+}
+
+//
+// SpirBuildTask
+//
+SpirBuildTask::SpirBuildTask(cl_program prog, cl_device_id dev, const char* options) :
+    BuildTask(prog, dev, options) {}
+
+//
+// CompileTask
+//
+
+CompileTask::CompileTask(cl_program prog, cl_device_id dev, const char* options) :
+    m_program(prog), Task(dev, options) {}
+
+void CompileTask::addHeader(const char* hname, cl_program hprog) {
+    m_headers.push_back(std::make_pair(hname, hprog));
+}
+
+const char* first(std::pair<const char*,cl_program>& p) {
+    return p.first;
+}
+
+cl_program second(const std::pair<const char*, cl_program>& p) {
+    return p.second;
+}
+
+bool CompileTask::execute() {
+    // Generating the header names vector.
+    std::vector<const char*> names;
+    std::transform(m_headers.begin(), m_headers.end(), names.begin(), first);
+
+    // Generating the header programs vector.
+    std::vector<cl_program> programs;
+    std::transform(m_headers.begin(), m_headers.end(), programs.begin(), second);
+
+    const char** h_names = NULL;
+    const cl_program* h_programs = NULL;
+    if (!m_headers.empty())
+    {
+        h_programs = &programs[0];
+        h_names    = &names[0];
+    }
+
+    // Compiling with the headers.
+    cl_int err_code = clCompileProgram(
+        m_program,
+        1U,
+        &m_devid,
+        m_options.c_str(),
+        m_headers.size(), // # of headers
+        h_programs,
+        h_names,
+        NULL, NULL);
+    if (CL_SUCCESS == err_code)
+        return true;
+
+    setErrorLog(m_program);
+    return false;
+}
+
+//
+// SpirCompileTask
+//
+SpirCompileTask::SpirCompileTask(cl_program prog, cl_device_id dev, const char* options) :
+    CompileTask(prog, dev, options) {}
+
+
+//
+// LinkTask
+//
+LinkTask::LinkTask(cl_program* programs, int num_programs, cl_context ctxt,
+                   cl_device_id dev, const char* options) :
+    m_programs(programs), m_numPrograms(num_programs), m_context(ctxt), m_executable(NULL),
+    Task(dev, options) {}
+
+bool LinkTask::execute() {
+    cl_int err_code;
+    int i;
+
+    for(i = 0; i < m_numPrograms; ++i)
+    {
+        err_code = clCompileProgram(m_programs[i], 1, &m_devid, "-x spir -spir-std=1.2 -cl-kernel-arg-info", 0, NULL, NULL, NULL, NULL);
+        if (CL_SUCCESS != err_code)
+        {
+            setErrorLog(m_programs[i]);
+            return false;
+        }
+    }
+
+    m_executable = clLinkProgram(m_context, 1, &m_devid, m_options.c_str(), m_numPrograms, m_programs, NULL, NULL, &err_code);
+    if (CL_SUCCESS == err_code)
+      return true;
+
+    if(m_executable) setErrorLog(m_executable);
+    return false;
+}
+
+cl_program LinkTask::getExecutable() const {
+    return m_executable;
+}
+
+LinkTask::~LinkTask() {
+    if(m_executable) clReleaseProgram(m_executable);
+}
+
+//
+// KernelEnumerator
+//
+void KernelEnumerator::process(cl_program prog) {
+    const size_t MAX_KERNEL_NAME = 64;
+    size_t num_kernels;
+
+    cl_int err_code = clGetProgramInfo(
+        prog,
+        CL_PROGRAM_NUM_KERNELS,
+        sizeof(size_t),
+        &num_kernels,
+        NULL
+    );
+    if (CL_SUCCESS != err_code)
+        return;
+
+    // Querying for the number of kernels.
+    size_t buffer_len = sizeof(char)*num_kernels*MAX_KERNEL_NAME;
+    char* kernel_names = new char[buffer_len];
+    memset(kernel_names, '\0', buffer_len);
+    size_t str_len = 0;
+    err_code = clGetProgramInfo(
+        prog,
+        CL_PROGRAM_KERNEL_NAMES,
+        buffer_len,
+        (void *)kernel_names,
+        &str_len
+    );
+    if (CL_SUCCESS != err_code)
+        return;
+
+    //parsing the names and inserting them to the list
+    std::string names(kernel_names);
+    assert (str_len == 1+names.size() && "incompatible string lengths");
+    size_t offset = 0;
+    for(size_t i=0 ; i<names.size() ; ++i){
+        //kernel names are separated by semi colons
+        if (names[i] == ';'){
+            m_kernels.push_back(names.substr(offset, i-offset));
+            offset = i+1;
+        }
+    }
+    m_kernels.push_back(names.substr(offset, names.size()-offset));
+    delete[] kernel_names;
+}
+
+KernelEnumerator::KernelEnumerator(cl_program prog) {
+    process(prog);
+}
+
+KernelEnumerator::iterator KernelEnumerator::begin(){
+    return m_kernels.begin();
+}
+
+KernelEnumerator::iterator KernelEnumerator::end(){
+    return m_kernels.end();
+}
+
+size_t KernelEnumerator::size() const {
+    return m_kernels.size();
+}
+
+/**
+ Run the single test - run the test for both CL and SPIR versions of the kernel
+ */
+static bool run_test(cl_context context, cl_command_queue queue, cl_program clprog,
+    cl_program bcprog, const std::string& kernel_name, std::string& err, const cl_device_id device)
+{
+    WorkSizeInfo ws;
+    TestResult cl_result;
+    std::auto_ptr<TestResult> bc_result;
+    // first, run the single CL test
+    {
+        // make sure that the kernel will be released before the program
+        clKernelWrapper kernel = create_kernel_helper(clprog, kernel_name);
+        // based on the kernel characteristics, we are generating and initializing the arguments for both phases (cl and bc executions)
+        generate_kernel_data(context, kernel, ws, cl_result);
+        bc_result.reset(cl_result.clone(context, ws, kernel, device));
+        assert (compare_results(cl_result, *bc_result) && "not equal?");
+        run_kernel( kernel, queue, ws, cl_result );
+    }
+    // now, run the single BC test
+    {
+        // make sure that the kernel will be released before the program
+        clKernelWrapper kernel = create_kernel_helper(bcprog, kernel_name);
+        run_kernel( kernel, queue, ws, *bc_result );
+    }
+
+    int error = clFinish(queue);
+    if( CL_SUCCESS != error)
+    {
+        err = "clFinish failed\n";
+        return false;
+    }
+
+    // compare the results
+    if( !compare_results(cl_result, *bc_result) )
+    {
+        err = " (result diff in kernel '" + kernel_name + "').";
+        return false;
+    }
+    return true;
+}
+
+TestRunner::TestRunner(EventHandler *success, EventHandler *failure,
+                       const OclExtensions& devExt):
+    m_successHandler(success), m_failureHandler(failure), m_devExt(&devExt) {}
+
+/**
+ Based on the test name build the cl file name, the bc file name and execute
+ the kernel for both modes (cl and bc).
+ */
+bool TestRunner::runBuildTest(cl_device_id device, const char *folder,
+                              const char *test_name, cl_uint size_t_width)
+{
+    int failures = 0;
+    // Composing the name of the CSV file.
+    char* dir = get_exe_dir();
+    std::string csvName(dir);
+    csvName.append(dir_sep());
+    csvName.append("khr.csv");
+    free(dir);
+
+    log_info("%s...\n", test_name);
+
+    // Figure out whether the test can run on the device. If not, we skip it.
+    const KhrSupport& khrDb = *KhrSupport::get(csvName);
+    cl_bool images = khrDb.isImagesRequired(folder, test_name);
+    cl_bool images3D = khrDb.isImages3DRequired(folder, test_name);
+
+    char deviceProfile[64];
+    clGetDeviceInfo(device, CL_DEVICE_PROFILE, sizeof(deviceProfile), &deviceProfile, NULL);
+    std::string device_profile(deviceProfile, 64);
+
+    if(images == CL_TRUE && checkForImageSupport(device) != 0)
+    {
+        (*m_successHandler)(test_name, "");
+        std::cout << "Skipped. (Cannot run on device due to Images is not supported)." << std::endl;
+        return true;
+    }
+
+    if(images3D == CL_TRUE && checkFor3DImageSupport(device) != 0)
+    {
+        (*m_successHandler)(test_name, "");
+        std::cout << "Skipped. (Cannot run on device as 3D images are not supported)." << std::endl;
+        return true;
+    }
+
+    OclExtensions requiredExt = khrDb.getRequiredExtensions(folder, test_name);
+    if(!m_devExt->supports(requiredExt))
+    {
+        (*m_successHandler)(test_name, "");
+        std::cout << "Skipped. (Cannot run on device due to missing extensions: " << m_devExt->get_missing(requiredExt) << " )." << std::endl;
+        return true;
+    }
+
+    std::string cl_file_path, bc_file;
+    // Build cl file name based on the test name
+    get_cl_file_path(folder, test_name, cl_file_path);
+    // Build bc file name based on the test name
+    get_bc_file_path(folder, test_name, bc_file, size_t_width);
+    gRG.init(1);
+    //
+    // Processing each kernel in the program separately
+    //
+    clContextWrapper context;
+    clCommandQueueWrapper queue;
+    create_context_and_queue(device, &context, &queue);
+    clProgramWrapper clprog = create_program_from_cl(context, cl_file_path);
+    clProgramWrapper bcprog = create_program_from_bc(context, bc_file);
+
+    // Building the programs.
+    BuildTask clBuild(clprog, device, "-cl-kernel-arg-info");
+    if (!clBuild.execute()) {
+        std::cerr << clBuild.getErrorLog() << std::endl;
+        return false;
+    }
+
+    SpirBuildTask bcBuild(bcprog, device, "-x spir -spir-std=1.2 -cl-kernel-arg-info");
+    if (!bcBuild.execute()) {
+        std::cerr << bcBuild.getErrorLog() << std::endl;
+        return false;
+    }
+
+    KernelEnumerator clkernel_enumerator(clprog),
+                     bckernel_enumerator(bcprog);
+    if (clkernel_enumerator.size() != bckernel_enumerator.size()) {
+        std::cerr << "number of kernels in test" << test_name
+                  << " doesn't match in bc and cl files" << std::endl;
+        return false;
+    }
+    KernelEnumerator::iterator it = clkernel_enumerator.begin(),
+        e = clkernel_enumerator.end();
+    while (it != e)
+    {
+        std::string kernel_name = *it++;
+        std::string err;
+        try
+        {
+            bool success = run_test(context, queue, clprog, bcprog, kernel_name, err, device);
+            if (success)
+            {
+                log_info("kernel '%s' passed.\n", kernel_name.c_str());
+                (*m_successHandler)(test_name, kernel_name);
+            }
+            else
+            {
+                ++failures;
+                log_info("kernel '%s' failed.\n", kernel_name.c_str());
+                (*m_failureHandler)(test_name, kernel_name);
+            }
+        }
+        catch (std::runtime_error err)
+        {
+            ++failures;
+            log_info("kernel '%s' failed: %s\n", kernel_name.c_str(), err.what());
+            (*m_failureHandler)(test_name, kernel_name);
+        }
+    }
+
+    log_info("%s %s\n", test_name, failures ? "FAILED" : "passed.");
+    return failures == 0;
+}
+

test_conformance/spir/run_build_test.h

@@ -0,0 +1,145 @@
+//
+// Copyright (c) 2017 The Khronos Group Inc.
+// 
+// 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.
+//
+#ifndef __RUN_BUILD_TEST_H__
+#define __RUN_BUILD_TEST_H__
+
+#include <string>
+#include <list>
+#include <vector>
+#include <utility>
+
+class OclExtensions;
+
+struct EventHandler{
+    virtual void operator()(const std::string&, const std::string&) = 0;
+    virtual std::string toString()const {return std::string();}
+};
+
+/*
+ * Abstract task to be executed on a cl program.
+ */
+class Task{
+public:
+    Task(cl_device_id, const char* options);
+
+    virtual bool execute() = 0;
+
+    virtual ~Task();
+
+    const char* getErrorLog() const;
+
+protected:
+  void setErrorLog(cl_program);
+
+  cl_device_id m_devid;
+  std::string  m_log;
+  std::string  m_options;
+};
+
+/*
+ * Build task - builds a given program.
+ */
+class BuildTask: public Task {
+public:
+    BuildTask(cl_program, cl_device_id, const char* options);
+
+    bool execute();
+
+private:
+  cl_program m_program;
+};
+
+/*
+ * Spir build task - build programs from SPIR binaries.
+ */
+class SpirBuildTask : public BuildTask {
+public:
+  SpirBuildTask(cl_program, cl_device_id, const char* options);
+};
+
+/*
+ * Compile task - compiles a given program.
+ */
+class CompileTask: public Task {
+public:
+    CompileTask(cl_program, cl_device_id, const char* options);
+
+    void addHeader(const char* hname, cl_program hprog);
+
+    bool execute();
+
+private:
+  std::vector<std::pair<const char*,cl_program> > m_headers;
+  cl_program m_program;
+};
+
+/*
+ * Spir compile task - compiles programs from SPIR binaries.
+ */
+class SpirCompileTask: public CompileTask {
+public:
+  SpirCompileTask(cl_program, cl_device_id, const char* options);
+};
+
+/*
+ * Link task - links a given programs to an OpecnCL executable.
+ */
+class LinkTask: public Task{
+public:
+    LinkTask(cl_program* programs, int num_programs, cl_context, cl_device_id,
+             const char* options=NULL);
+
+    bool execute();
+
+    cl_program getExecutable() const;
+
+    ~LinkTask();
+private:
+    cl_program   m_executable;
+    cl_program*  m_programs;
+    int          m_numPrograms;
+    cl_context   m_context;
+};
+
+class TestRunner{
+    EventHandler*const m_successHandler, *const m_failureHandler;
+    const OclExtensions *m_devExt;
+
+public:
+    TestRunner(EventHandler *success, EventHandler *failure,
+               const OclExtensions& devExt);
+
+    bool runBuildTest(cl_device_id device, const char *folder,
+                      const char *test_name, cl_uint size_t_width);
+};
+
+//
+//Provides means to iterate over the kernels of a given program
+//
+class KernelEnumerator {
+    std::list<std::string> m_kernels;
+
+    void process(cl_program prog);
+public:
+    typedef std::list<std::string>::iterator iterator;
+
+    KernelEnumerator(cl_program prog);
+    iterator begin();
+    iterator end();
+    size_t size()const;
+};
+
+#endif//__RUN_BUILD_TEST_H__

test_conformance/spir/run_services.cpp

@@ -0,0 +1,767 @@
+//
+// Copyright (c) 2017 The Khronos Group Inc.
+// 
+// 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 "../../test_common/harness/compat.h"
+
+#ifdef __APPLE__
+#include <OpenCL/opencl.h>
+#else
+#include <CL/cl.h>
+#endif
+
+#include <assert.h>
+#include <string>
+#include <fstream>
+#include <iterator>
+#include <memory>
+#include <sstream>
+
+#include "exceptions.h"
+#include "datagen.h"
+#include "run_services.h"
+
+#define XSTR(A) STR(A)
+#define STR(A) #A
+
+/**
+ Based on the folder and the input string build the cl file nanme
+ */
+void get_cl_file_path (const char *folder, const char *test_name, std::string &cl_file_path)
+{
+    assert(folder && "folder is empty");
+    assert(test_name && "test_name is empty");
+
+    cl_file_path.append(folder);
+    cl_file_path.append("/");
+    cl_file_path.append(test_name);
+    cl_file_path.append(".cl");
+}
+
+/**
+ Based on the folder and the input string build the bc file nanme
+ */
+void get_bc_file_path (const char *folder, const char *test_name, std::string &bc_file_path, cl_uint size_t_width)
+{
+    assert(folder && "folder is empty");
+    assert(test_name && "test_name is empty");
+    bc_file_path.append(folder);
+    bc_file_path.append("/");
+    bc_file_path.append(test_name);
+    if (32 == size_t_width)
+        bc_file_path.append(".bc32");
+    else
+        bc_file_path.append(".bc64");
+}
+
+/**
+ Based on the folder and the input string build the h file nanme
+ */
+void get_h_file_path (const char *folder, const char *file_name, std::string &h_file_path)
+{
+    assert(folder && "folder is empty");
+    assert(file_name && "file_name is empty");
+
+    h_file_path.assign(folder);
+    h_file_path.append("/");
+    h_file_path.append(file_name);
+}
+
+/**
+ Fetch the kernel nanme from the test name
+ */
+void get_kernel_name (const char *test_name, std::string &kernel_name)
+{
+    char *temp_str, *p;
+    std::string temp;
+
+    temp.assign(test_name);
+
+    // Check if the test name includes '.' -
+    // the convention is that the test's kernel name is embedded in the test name up to the first '.'
+    temp_str = (char *)temp.c_str();
+    p = strstr(temp_str, ".");
+    if (p != NULL)
+    {
+        *p = '\0';
+    }
+    kernel_name.assign(temp_str);
+}
+
+extern "C" void CL_CALLBACK notify_callback(const char *errInfo, const void *privateInfo, size_t cb, void *userData);
+
+void create_context_and_queue(cl_device_id device, cl_context *out_context, cl_command_queue *out_queue)
+{
+    assert( out_context && "out_context arg must be a valid pointer");
+    assert( out_queue && "out_queue arg must be a valid pointer");
+
+    int error = CL_SUCCESS;
+
+    *out_context = clCreateContext( NULL, 1, &device, notify_callback, NULL, &error );
+    if( NULL == *out_context || error != CL_SUCCESS)
+    {
+        throw Exceptions::TestError("clCreateContext failed\n", error);
+    }
+
+    *out_queue = clCreateCommandQueue( *out_context, device, 0, &error );
+    if( NULL == *out_queue || error )
+    {
+        throw Exceptions::TestError("clCreateCommandQueue failed\n", error);
+    }
+}
+
+/**
+ Loads the kernel text from the given text file
+ */
+std::string load_file_cl( const std::string& file_name)
+{
+    std::ifstream ifs(file_name.c_str());
+    if( !ifs.good() )
+        throw Exceptions::TestError("Can't load the cl File " + file_name, 1);
+    std::string str( ( std::istreambuf_iterator<char>( ifs ) ), std::istreambuf_iterator<char>());
+    return str;
+}
+
+/**
+ Loads the kernel IR from the given binary file in SPIR BC format
+ */
+void* load_file_bc( const std::string& file_name, size_t *binary_size)
+{
+    assert(binary_size && "binary_size arg should be valid");
+
+    std::ifstream file(file_name.c_str(), std::ios::binary);
+
+    if( !file.good() )
+    {
+        throw Exceptions::TestError("Can't load the bc File " + file_name, 1);
+    }
+
+    file.seekg(0, std::ios::end);
+    *binary_size = (size_t)file.tellg();
+    file.seekg(0, std::ios::beg);
+
+    void* buffer = malloc(*binary_size);
+    file.read((char*)buffer, *binary_size);
+    file.close();
+
+    return buffer;
+}
+
+/**
+ Create program from the CL source file
+ */
+cl_program create_program_from_cl(cl_context context, const std::string& file_name)
+{
+    std::string text_file  = load_file_cl(file_name);
+    const char* text_str = text_file.c_str();
+    int error  = CL_SUCCESS;
+
+    cl_program program = clCreateProgramWithSource( context, 1, &text_str, NULL, &error );
+    if( program == NULL || error != CL_SUCCESS)
+    {
+        throw Exceptions::TestError("Error creating program\n", error);
+    }
+
+    return program;
+}
+
+/**
+ Create program from the BC source file
+ */
+cl_program create_program_from_bc (cl_context context, const std::string& file_name)
+{
+    cl_int load_error = CL_SUCCESS;
+    cl_int error;
+    size_t binary_size;
+    BufferOwningPtr<const unsigned char> binary(load_file_bc(file_name, &binary_size));
+    const unsigned char* ptr = binary;
+
+    cl_device_id device = get_context_device(context);
+    cl_program program = clCreateProgramWithBinary( context, 1, &device, &binary_size, &ptr, &load_error, &error );
+
+
+    if( program == NULL || error != CL_SUCCESS )
+    {
+        throw Exceptions::TestError("clCreateProgramWithBinary failed: Unable to load valid program binary\n", error);
+    }
+
+    if( load_error != CL_SUCCESS )
+    {
+         throw Exceptions::TestError("clCreateProgramWithBinary failed: Unable to load valid device binary into program\n", load_error);
+    }
+
+    return program;
+}
+
+/**
+ Creates the kernel with the given name from the given program.
+ */
+cl_kernel create_kernel_helper( cl_program program, const std::string& kernel_name )
+{
+    int error = CL_SUCCESS;
+    cl_kernel kernel = NULL;
+    cl_device_id device = get_program_device(program);
+    /* And create a kernel from it */
+    kernel = clCreateKernel( program, kernel_name.c_str(), &error );
+    if( kernel == NULL || error != CL_SUCCESS)
+        throw Exceptions::TestError("Unable to create kernel\n", error);
+    return kernel;
+}
+
+cl_device_id get_context_device (cl_context context)
+{
+    cl_device_id device[1];
+
+    int error = clGetContextInfo(context, CL_CONTEXT_DEVICES, sizeof(device), device, NULL);
+    if( error != CL_SUCCESS )
+    {
+        throw Exceptions::TestError("clGetContextInfo failed\n", error);
+    }
+
+    return device[0];
+}
+
+cl_device_id get_program_device (cl_program program)
+{
+    cl_device_id device[1];
+
+    int error = clGetProgramInfo(program, CL_PROGRAM_DEVICES, sizeof(device), device, NULL);
+    if( error != CL_SUCCESS )
+    {
+        throw Exceptions::TestError("clGetProgramInfo failed\n", error);
+    }
+
+    return device[0];
+}
+
+void generate_kernel_ws( cl_device_id device, cl_kernel kernel, WorkSizeInfo& ws)
+{
+    size_t compile_work_group_size[MAX_WORK_DIM];
+
+    memset(&ws, 0, sizeof(WorkSizeInfo));
+    ws.work_dim = 1;
+    ws.global_work_size[0] = (GLOBAL_WORK_SIZE <= 32) ? GLOBAL_WORK_SIZE : 32;        // kernels limitations
+    ws.local_work_size[0] = ((GLOBAL_WORK_SIZE % 4) == 0) ? (GLOBAL_WORK_SIZE / 4) : (GLOBAL_WORK_SIZE / 2);
+
+    //Check if the kernel was compiled with specific work group size
+    int error = clGetKernelWorkGroupInfo(kernel, device, CL_KERNEL_COMPILE_WORK_GROUP_SIZE, sizeof(compile_work_group_size), &compile_work_group_size, NULL);
+    if( error != CL_SUCCESS )
+    {
+        throw Exceptions::TestError("clGetKernelWorkGroupInfo failed\n", error);
+    }
+
+    // if compile_work_group_size[0] is not 0 - use the compiled values
+    if ( 0 != compile_work_group_size[0] )
+    {
+        // the kernel compiled with __attribute__((reqd_work_group_size(X, Y, Z)))
+        memcpy(ws.global_work_size, compile_work_group_size, sizeof(ws.global_work_size));
+
+        // Now, check the correctness of the local work size and fix it if necessary
+        for ( int i = 0; i < MAX_WORK_DIM; ++i )
+        {
+            if ( ws.local_work_size[i] > compile_work_group_size[i] )
+            {
+                ws.local_work_size[i] = compile_work_group_size[i];
+            }
+        }
+    }
+}
+
+TestResult* TestResult::clone(cl_context ctx, const WorkSizeInfo& ws, const cl_kernel kernel, const cl_device_id device) const
+{
+    TestResult *cpy = new TestResult();
+
+    for (size_t i=0; i<m_kernelArgs.getArgCount(); ++i)
+        cpy->m_kernelArgs.addArg(m_kernelArgs.getArg(i)->clone(ctx, ws, kernel, device));
+
+    return cpy;
+}
+
+/*
+ * class DataRow
+ */
+
+const std::string& DataRow::operator[](int column)const
+{
+    assert((column > -1 && (size_t)column < m_row.size()) && "Index out of bound");
+    return m_row[column];
+}
+
+std::string& DataRow::operator[](int column)
+{
+    assert((column > -1) && "Index out of bound");
+
+    if ((size_t)column < m_row.size())
+        return m_row[column];
+
+    if (column == m_row.size())
+    {
+        m_row.push_back("");
+        return m_row[column];
+    }
+
+    assert(0 && "Index out of bound.");
+}
+
+/*
+ * class DataTable
+ */
+
+size_t DataTable::getNumRows() const
+{
+    return m_rows.size();
+}
+
+void DataTable::addTableRow(DataRow *dr)
+{
+    m_rows.push_back(dr);
+}
+
+const DataRow& DataTable::operator[](int index)const
+{
+    assert((index > -1 && (size_t)index < m_rows.size()) && "Index out of bound");
+    return *m_rows[index];
+}
+
+DataRow& DataTable::operator[](int index)
+{
+    assert((index > -1 && (size_t)index < m_rows.size()) && "Index out of bound");
+    return *m_rows[index];
+}
+
+/*
+ * class OclExtensions
+ */
+OclExtensions OclExtensions::getDeviceCapabilities(cl_device_id devId)
+{
+    char extensions[1024] = {0};
+    size_t size;
+
+    // Querying the device for its supported extensions
+    cl_int errcode = clGetDeviceInfo(devId,
+                                     CL_DEVICE_EXTENSIONS,
+                                     sizeof(extensions),
+                                     extensions,
+                                     &size);
+    if (errcode)
+        throw Exceptions::TestError("Device query failed");
+
+    char device_profile[1024] = {0};
+    errcode = clGetDeviceInfo(devId,
+                              CL_DEVICE_PROFILE,
+                              sizeof(device_profile),
+                              device_profile,
+                              NULL);
+    if (errcode)
+        throw Exceptions::TestError("Device query failed");
+
+    OclExtensions ret = OclExtensions::empty();
+    assert(size < sizeof(extensions));
+    if (!size)
+      return ret;
+
+    // Iterate over the extensions, and convert them into the bit field.
+    std::list<std::string> extVector;
+    std::stringstream khrStream(extensions);
+    std::copy(std::istream_iterator<std::string>(khrStream),
+              std::istream_iterator<std::string>(),
+              std::back_inserter(extVector));
+
+    // full_profile devices supports embedded profile as core feature
+    if ( std::string( device_profile ) == "FULL_PROFILE" ) {
+        extVector.push_back("cles_khr_int64");
+        extVector.push_back("cles_khr_2d_image_array_writes");
+    }
+
+    for(std::list<std::string>::const_iterator it = extVector.begin(),
+                                               e = extVector.end(); it != e;
+                                               it++)
+    {
+        ret = ret | OclExtensions::fromString(*it);
+    }
+    return ret;
+}
+
+OclExtensions OclExtensions::empty()
+{
+    return OclExtensions(0);
+}
+
+OclExtensions OclExtensions::fromString(const std::string& e)
+{
+    std::string s = "OclExtensions::" + e;
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_int64_base_atomics);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_int64_extended_atomics);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_3d_image_writes);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_fp16);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_gl_sharing);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_gl_event);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_d3d10_sharing);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_dx9_media_sharing);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_d3d11_sharing);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_depth_images);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_gl_depth_images);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_gl_msaa_sharing);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_image2d_from_buffer);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_initialize_memory);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_spir);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_fp64);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_global_int32_base_atomics);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_global_int32_extended_atomics);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_local_int32_base_atomics);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_local_int32_extended_atomics);
+    RETURN_IF_ENUM(s, OclExtensions::cl_khr_byte_addressable_store);
+    RETURN_IF_ENUM(s, OclExtensions::cles_khr_int64);
+    RETURN_IF_ENUM(s, OclExtensions::cles_khr_2d_image_array_writes);
+    // Unknown KHR string.
+    return OclExtensions::empty();
+}
+
+std::string OclExtensions::toString()
+{
+
+    #define APPEND_STR_IF_SUPPORTS( STR, E)                          \
+        if ( this->supports(E) )                                     \
+        {                                                            \
+            std::string ext_str( #E );                               \
+            std::string prefix = "OclExtensions::";                  \
+            size_t pos = ext_str.find( prefix );                     \
+            if (  pos != std::string::npos )                         \
+            {                                                        \
+                ext_str.replace( pos, prefix.length(), "");          \
+            }                                                        \
+            STR += ext_str;                                          \
+        }
+
+    std::string s = "";
+
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_int64_base_atomics );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_int64_extended_atomics );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_3d_image_writes );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_fp16 );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_gl_sharing );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_gl_event );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_d3d10_sharing );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_dx9_media_sharing );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_d3d11_sharing );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_depth_images );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_gl_depth_images );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_gl_msaa_sharing );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_image2d_from_buffer );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_initialize_memory );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_spir );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_fp64 );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_global_int32_base_atomics );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_global_int32_extended_atomics );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_local_int32_base_atomics );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_local_int32_extended_atomics );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cl_khr_byte_addressable_store );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cles_khr_int64 );
+    APPEND_STR_IF_SUPPORTS( s, OclExtensions::cles_khr_2d_image_array_writes );
+
+    return s;
+}
+
+std::ostream& operator<<(std::ostream& os, OclExtensions ext)
+{
+    return os << ext.toString();
+}
+
+OclExtensions OclExtensions::operator|(const OclExtensions& b) const
+{
+    return OclExtensions(m_extVector | b.m_extVector);
+}
+
+bool OclExtensions::supports(const OclExtensions& b) const
+{
+    return ((b.m_extVector & m_extVector) == b.m_extVector);
+}
+
+OclExtensions OclExtensions::get_missing(const OclExtensions& b) const
+{
+    return OclExtensions( b.m_extVector & ( ~ m_extVector ) );
+}
+
+/*
+ * class KhrSupport
+ */
+
+KhrSupport *KhrSupport::m_instance = NULL;
+
+const KhrSupport* KhrSupport::get(const std::string& path)
+{
+    if(m_instance)
+        return m_instance;
+
+    m_instance = new KhrSupport();
+    // First invokation, parse the file into memory.
+    std::fstream csv(path.c_str(), std::ios_base::in);
+    if (!csv.is_open())
+    {
+        delete m_instance;
+        std::string msg;
+        msg.append("File ");
+        msg.append(path);
+        msg.append(" cannot be opened");
+        throw Exceptions::TestError(msg.c_str());
+    }
+
+    m_instance->parseCSV(csv);
+    csv.close();
+    return m_instance;
+}
+
+void KhrSupport::parseCSV(std::fstream& f)
+{
+    assert(f.is_open() && "file is not in reading state.") ;
+    char line[1024];
+    while (!f.getline(line, sizeof(line)).eof())
+    {
+        DataRow *dr = parseLine(std::string(line));
+        m_dt.addTableRow(dr);
+    }
+}
+
+DataRow* KhrSupport::parseLine(const std::string& line)
+{
+    const char DELIM = ',';
+    std::string token;
+    DataRow *dr = new DataRow();
+    int tIndex = 0;
+
+    for(std::string::const_iterator it = line.begin(), e = line.end(); it != e;
+        it++)
+    {
+        // Eat those characters away.
+        if(isspace(*it) || '"' == *it)
+            continue;
+
+        // If that's a delimiter, we need to tokenize the collected value.
+        if(*it == DELIM)
+        {
+            (*dr)[tIndex++] = token;
+            token.clear();
+            continue;
+        }
+
+        // Append to current token.
+        token.append(1U, *it);
+    }
+    if (!token.empty())
+        (*dr)[tIndex] = token;
+
+    assert(tIndex && "empty data row??");
+    return dr;
+}
+
+OclExtensions KhrSupport::getRequiredExtensions(const char* suite, const char* test) const
+{
+    OclExtensions ret = OclExtensions::empty();
+
+    const std::string strSuite(suite), strTest(test);
+    // Iterating on the DataTable, searching whether the row with th requested
+    // row exists.
+    for(size_t rowIndex = 0; rowIndex < m_dt.getNumRows(); rowIndex++)
+    {
+        const DataRow& dr = m_dt[rowIndex];
+        const std::string csvSuite = dr[SUITE_INDEX], csvTest = dr[TEST_INDEX];
+        bool sameSuite = (csvSuite == strSuite), sameTest = (csvTest == strTest)||(csvTest == "*");
+        if (sameTest && sameSuite)
+        {
+            ret = ret | OclExtensions::fromString(dr[EXT_INDEX]);
+        }
+    }
+
+    return ret;
+}
+
+cl_bool KhrSupport::isImagesRequired(const char* suite, const char* test) const
+{
+    cl_bool ret = CL_FALSE;
+    const std::string strSuite(suite), strTest(test);
+
+    // Iterating on the DataTable, searching whether the row with th requested
+    // row exists.
+    for(size_t rowIndex = 0; rowIndex < m_dt.getNumRows(); rowIndex++)
+    {
+        const DataRow& dr = m_dt[rowIndex];
+        const std::string csvSuite = dr[SUITE_INDEX], csvTest = dr[TEST_INDEX];
+        bool sameSuite = (csvSuite == strSuite), sameTest = (csvTest == strTest)||(csvTest == "*");
+        if (sameTest && sameSuite)
+        {
+            ret = (dr[IMAGES_INDEX] == "CL_TRUE") ? CL_TRUE : CL_FALSE;
+            break;
+        }
+    }
+
+    return ret;
+}
+
+cl_bool KhrSupport::isImages3DRequired(const char* suite, const char* test) const
+{
+    cl_bool ret = CL_FALSE;
+    const std::string strSuite(suite), strTest(test);
+
+    // Iterating on the DataTable, searching whether the row with th requested
+    // row exists.
+    for(size_t rowIndex = 0; rowIndex < m_dt.getNumRows(); rowIndex++)
+    {
+        const DataRow& dr = m_dt[rowIndex];
+        const std::string csvSuite = dr[SUITE_INDEX], csvTest = dr[TEST_INDEX];
+        bool sameSuite = (csvSuite == strSuite), sameTest = (csvTest == strTest)||(csvTest == "*");
+        if (sameTest && sameSuite)
+        {
+            ret = (dr[IMAGES_3D_INDEX] == "CL_TRUE") ? CL_TRUE : CL_FALSE;
+            break;
+        }
+    }
+
+    return ret;
+}
+
+
+static void generate_kernel_args(cl_context context, cl_kernel kernel, const WorkSizeInfo& ws, KernelArgs& cl_args, const cl_device_id device)
+{
+    int error = CL_SUCCESS;
+    cl_uint num_args = 0;
+    KernelArg* cl_arg = NULL;
+    DataGenerator* dg = DataGenerator::getInstance();
+
+    error = clGetKernelInfo( kernel, CL_KERNEL_NUM_ARGS, sizeof( num_args ), &num_args, NULL );
+    if( error != CL_SUCCESS )
+    {
+        throw Exceptions::TestError("Unable to get kernel arg count\n", error);
+    }
+
+    for ( cl_uint j = 0; j < num_args; ++j )
+    {
+        KernelArgInfo kernel_arg_info;
+        size_t size;
+        const int max_name_len = 512;
+        char name[max_name_len];
+
+        // Try to get the address qualifier of each argument.
+        error = clGetKernelArgInfo( kernel, j, CL_KERNEL_ARG_ADDRESS_QUALIFIER, sizeof(cl_kernel_arg_address_qualifier), kernel_arg_info.getAddressQualifierRef(), &size);
+        if( error != CL_SUCCESS )
+        {
+            throw Exceptions::TestError("Unable to get argument address qualifier\n", error);
+        }
+
+        // Try to get the access qualifier of each argument.
+        error = clGetKernelArgInfo( kernel, j, CL_KERNEL_ARG_ACCESS_QUALIFIER, sizeof(cl_kernel_arg_access_qualifier), kernel_arg_info.getAccessQualifierRef(), &size );
+        if( error != CL_SUCCESS )
+        {
+            throw Exceptions::TestError("Unable to get argument access qualifier\n", error);
+        }
+
+        // Try to get the type qualifier of each argument.
+        error = clGetKernelArgInfo( kernel, j, CL_KERNEL_ARG_TYPE_QUALIFIER, sizeof(cl_kernel_arg_type_qualifier), kernel_arg_info.getTypeQualifierRef(), &size );
+        if( error != CL_SUCCESS )
+        {
+            throw Exceptions::TestError("Unable to get argument type qualifier\n", error);
+        }
+
+        // Try to get the type of each argument.
+        memset( name, 0, max_name_len );
+        error = clGetKernelArgInfo(kernel, j, CL_KERNEL_ARG_TYPE_NAME, max_name_len, name, NULL );
+        if( error != CL_SUCCESS )
+        {
+            throw Exceptions::TestError("Unable to get argument type name\n", error);
+        }
+        kernel_arg_info.setTypeName(name);
+
+        // Try to get the name of each argument.
+        memset( name, 0, max_name_len );
+        error = clGetKernelArgInfo( kernel, j, CL_KERNEL_ARG_NAME, max_name_len, name, NULL );
+        if( error != CL_SUCCESS )
+        {
+            throw Exceptions::TestError("Unable to get argument name\n", error);
+        }
+        kernel_arg_info.setName(name);
+
+        cl_arg = dg->generateKernelArg(context, kernel_arg_info, ws, NULL, kernel, device);
+        cl_args.addArg( cl_arg );
+    }
+}
+
+void set_kernel_args( cl_kernel kernel, KernelArgs& args)
+{
+    int error = CL_SUCCESS;
+    for( size_t i = 0;  i < args.getArgCount(); ++ i )
+    {
+        error = clSetKernelArg( kernel, i, args.getArg(i)->getArgSize(), args.getArg(i)->getArgValue());
+        if( error != CL_SUCCESS )
+        {
+            throw Exceptions::TestError("clSetKernelArg failed\n", error);
+        }
+    }
+}
+
+/**
+ Run the single kernel
+ */
+void generate_kernel_data ( cl_context context, cl_kernel kernel, WorkSizeInfo &ws, TestResult& results)
+{
+    cl_device_id device = get_context_device(context);
+    generate_kernel_ws( device, kernel, ws);
+    generate_kernel_args(context, kernel, ws, results.kernelArgs(), device);
+}
+
+/**
+ Run the single kernel
+ */
+void run_kernel( cl_kernel kernel, cl_command_queue queue, WorkSizeInfo &ws, TestResult& result )
+{
+    clEventWrapper execute_event;
+
+    set_kernel_args(kernel, result.kernelArgs());
+
+    int error = clEnqueueNDRangeKernel( queue, kernel, ws.work_dim, ws.global_work_offset, ws.global_work_size, ws.local_work_size, 0, NULL, &execute_event );
+    if( error != CL_SUCCESS )
+    {
+        throw Exceptions::TestError("clEnqueueNDRangeKernel failed\n", error);
+    }
+
+    error = clWaitForEvents( 1, &execute_event );
+    if( error != CL_SUCCESS )
+    {
+        throw Exceptions::TestError("clWaitForEvents failed\n", error);
+    }
+
+    // read all the buffers back to host
+    result.readToHost(queue);
+}
+
+/**
+ Compare two test results
+ */
+bool compare_results( const TestResult& lhs, const TestResult& rhs )
+{
+    if( lhs.kernelArgs().getArgCount() != rhs.kernelArgs().getArgCount() )
+    {
+        log_error("number of kernel parameters differ between SPIR and CL version of the kernel\n");
+        return false;
+    }
+
+    for( size_t i = 0 ; i < lhs.kernelArgs().getArgCount(); ++i )
+    {
+        if( ! lhs.kernelArgs().getArg(i)->compare( *rhs.kernelArgs().getArg(i)) )
+        {
+            log_error("the kernel parameter (%d) is different between SPIR and CL version of the kernel\n", i);
+            return false;
+        }
+    }
+    return true;
+}
+

test_conformance/spir/run_services.h

@@ -0,0 +1,222 @@
+//
+// Copyright (c) 2017 The Khronos Group Inc.
+// 
+// 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.
+//
+#ifndef __RUN_SERVICES_H
+#define __RUN_SERVICES_H
+
+#include <string>
+#include "kernelargs.h"
+#include "datagen.h"
+#include <list>
+
+void get_cl_file_path(const char *folder, const char *str, std::string &cl_file_path);
+void get_bc_file_path(const char *folder, const char *str, std::string &bc_file_path, cl_uint size_t_width);
+void get_h_file_path(const char *folder, const char *str, std::string &h_file_path);
+void get_kernel_name(const char *test_name, std::string &kernel_name);
+
+cl_device_id get_context_device(cl_context context);
+
+void create_context_and_queue(cl_device_id device, cl_context *out_context, cl_command_queue *out_queue);
+cl_program create_program_from_cl(cl_context context, const std::string& file_name);
+cl_program create_program_from_bc(cl_context context, const std::string& file_name);
+/**
+ Retrieves the kernel with the given name from the program
+ */
+cl_kernel create_kernel_helper(cl_program program, const std::string& kernel_name);
+
+cl_device_id get_program_device (cl_program program);
+
+void generate_kernel_ws( cl_device_id device, cl_kernel kernel, WorkSizeInfo& ws);
+
+/**
+ Responsible for holding the result of a single test
+ */
+class TestResult
+{
+public:
+    TestResult(){};
+
+    KernelArgs& kernelArgs() { return m_kernelArgs; }
+
+    const KernelArgs& kernelArgs() const { return m_kernelArgs; }
+
+    void readToHost(cl_command_queue queue) { m_kernelArgs.readToHost(queue); }
+
+    /*
+     * Clones this object to a newly heap-allocated (deeply copied) object.
+     */
+    TestResult* clone(cl_context ctx, const WorkSizeInfo& ws, const cl_kernel kernel, const cl_device_id device) const;
+
+private:
+    KernelArgs m_kernelArgs;
+};
+
+template <int i>
+struct KhrValue
+{
+  enum {Mask = (1 << i)};
+};
+
+template <>
+struct KhrValue<0>
+{
+  enum {Mask = 1};
+};
+
+/*
+ * Represents a set of OpenCL extension.
+ */
+class OclExtensions
+{
+public:
+    static OclExtensions getDeviceCapabilities(cl_device_id);
+
+    static OclExtensions empty();
+
+    #define STRINIGFY(X) #X
+
+    #define RETURN_IF_ENUM(S, E) if(S == STRINIGFY(E)) return E
+
+
+    static OclExtensions fromString(const std::string&);
+
+    std::string toString();
+
+    // Operators
+
+    // Merges the given extension and this one together, and returns the merged
+    // value.
+    OclExtensions operator|(const OclExtensions&) const;
+
+
+    // Indicates whether each extension in this objects also resides in b.
+    bool supports(const OclExtensions& b) const;
+
+    // Return list of missing extensions
+    OclExtensions get_missing(const OclExtensions& b) const;
+
+
+    size_t get() const { return m_extVector; }
+private:
+
+    OclExtensions(size_t ext) : m_extVector(ext) {}
+
+// Fix a compilation error, since cl_khr_gl_sharing is defined as a macro.
+#ifdef cl_khr_gl_sharing
+#undef cl_khr_gl_sharing
+#endif//cl_khr_gl_sharing
+
+#ifdef cl_khr_icd
+#undef cl_khr_icd
+#endif//cl_khr_icd
+
+    enum ClKhrs
+    {
+        no_extensions                 = KhrValue<0>::Mask,
+        cl_khr_int64_base_atomics     = KhrValue<1>::Mask,
+        cl_khr_int64_extended_atomics = KhrValue<2>::Mask,
+        cl_khr_3d_image_writes        = KhrValue<3>::Mask,
+        cl_khr_fp16                   = KhrValue<4>::Mask,
+        cl_khr_gl_sharing             = KhrValue<5>::Mask,
+        cl_khr_gl_event               = KhrValue<6>::Mask,
+        cl_khr_d3d10_sharing          = KhrValue<7>::Mask,
+        cl_khr_dx9_media_sharing      = KhrValue<8>::Mask,
+        cl_khr_d3d11_sharing          = KhrValue<9>::Mask,
+        cl_khr_depth_images           = KhrValue<10>::Mask,
+        cl_khr_gl_depth_images        = KhrValue<11>::Mask,
+        cl_khr_gl_msaa_sharing        = KhrValue<12>::Mask,
+        cl_khr_image2d_from_buffer    = KhrValue<13>::Mask,
+        cl_khr_initialize_memory      = KhrValue<14>::Mask,
+        cl_khr_context_abort          = KhrValue<15>::Mask,
+        cl_khr_spir                   = KhrValue<16>::Mask,
+        cl_khr_fp64                   = KhrValue<17>::Mask,
+        cl_khr_global_int32_base_atomics     = KhrValue<18>::Mask,
+        cl_khr_global_int32_extended_atomics = KhrValue<19>::Mask,
+        cl_khr_local_int32_base_atomics      = KhrValue<20>::Mask,
+        cl_khr_local_int32_extended_atomics  = KhrValue<21>::Mask,
+        cl_khr_byte_addressable_store        = KhrValue<22>::Mask,
+        cles_khr_int64                         = KhrValue<23>::Mask,
+        cles_khr_2d_image_array_writes         = KhrValue<24>::Mask,
+    };
+
+    size_t m_extVector;
+};
+
+std::ostream& operator<<(std::ostream& os, OclExtensions ext);
+
+/*
+ * Indicates whether a given test needs KHR extension.
+ */
+
+class DataRow;
+
+class DataTable
+{
+  std::vector<DataRow*> m_rows;
+public:
+    size_t getNumRows() const;
+    void addTableRow(DataRow*);
+    const DataRow& operator[](int index)const;
+    DataRow& operator[](int index);
+};
+
+class KhrSupport
+{
+public:
+  static const KhrSupport* get(const std::string& csvFile);
+  DataRow* parseLine(const std::string&);
+  OclExtensions getRequiredExtensions(const char* suite, const char* test) const;
+  cl_bool isImagesRequired(const char* suite, const char* test) const;
+  cl_bool isImages3DRequired(const char* suite, const char* test) const;
+
+private:
+  static const int SUITE_INDEX     = 0;
+  static const int TEST_INDEX      = 1;
+  static const int EXT_INDEX       = 2;
+  static const int IMAGES_INDEX    = 3;
+  static const int IMAGES_3D_INDEX = 4;
+
+  void parseCSV(std::fstream&);
+
+  DataTable m_dt;
+  static KhrSupport* m_instance;
+};
+
+class DataRow
+{
+    std::vector<std::string> m_row;
+    DataRow() {}
+public:
+    const std::string& operator[](int)const;
+    std::string&      operator[](int);
+
+    friend DataRow* KhrSupport::parseLine(const std::string&);
+};
+
+/*
+ * Generates data for the given kernel.
+ * Parameters:
+ *   context - The context of the kernel.
+ *   kernel  - The kernel to which arguments will be generated
+ *   ws(OUT) - generated work size info.
+ *   res(OUT)- generated test results.
+ */
+void generate_kernel_data(cl_context context, cl_kernel kernel,
+                          WorkSizeInfo &ws, TestResult& res);
+
+void run_kernel(cl_kernel kernel, cl_command_queue queue, WorkSizeInfo &ws, TestResult& result);
+bool compare_results(const TestResult& lhs, const TestResult& rhs);
+
+#endif

test_conformance/spir/typeinfo.h

@@ -0,0 +1,244 @@
+//
+// Copyright (c) 2017 The Khronos Group Inc.
+// 
+// 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.
+//
+TYPE_HNDL("_Bool",                   false, 0,  1,                  false,               true,    KernelArgGeneratorT<bool>)
+TYPE_HNDL("_Bool*",                  true,  0, 16,                  false,               true,    KernelArgGeneratorT<bool>)
+TYPE_HNDL("bool",                    false, 0,  1,                  false,               true,    KernelArgGeneratorT<bool>)
+TYPE_HNDL("bool*",                   true,  0, 16,                  false,               true,    KernelArgGeneratorT<bool>)
+TYPE_HNDL("char",                    false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorT<cl_char>)
+TYPE_HNDL("char*",                   true,  0, 16,                    0x0,               0x7f,    KernelArgGeneratorT<cl_char>)
+TYPE_HNDL("char16",                  false, 0, 16,                    0x0,               0x7f,    KernelArgGeneratorT<cl_char>)
+TYPE_HNDL("char16*",                 true,  0, 16,                    0x0,               0x7f,    KernelArgGeneratorT<cl_char>)
+TYPE_HNDL("char2",                   false, 0,  2,                    0x0,               0x7f,    KernelArgGeneratorT<cl_char>)
+TYPE_HNDL("char2*",                  true,  0,  2,                    0x0,               0x7f,    KernelArgGeneratorT<cl_char>)
+TYPE_HNDL("char3",                   false, 0,  3,                    0x0,               0x7f,    KernelArgGeneratorT<cl_char>)
+TYPE_HNDL("char3*",                  true,  0,  3,                    0x0,               0x7f,    KernelArgGeneratorT<cl_char>)
+TYPE_HNDL("char4",                   false, 0,  4,                    0x0,               0x7f,    KernelArgGeneratorT<cl_char>)
+TYPE_HNDL("char4*",                  true,  0,  4,                    0x0,               0x7f,    KernelArgGeneratorT<cl_char>)
+TYPE_HNDL("char8",                   false, 0,  8,                    0x0,               0x7f,    KernelArgGeneratorT<cl_char>)
+TYPE_HNDL("char8*",                  true,  0,  8,                    0x0,               0x7f,    KernelArgGeneratorT<cl_char>)
+TYPE_HNDL("double",                  false, 0,  1,            -0x40000000,         0x40000000,    KernelArgGeneratorT<cl_double>)
+TYPE_HNDL("double*",                 true,  0, 16,            -0x40000000,         0x40000000,    KernelArgGeneratorT<cl_double>)
+TYPE_HNDL("double16",                false, 0, 16,            -0x40000000,         0x40000000,    KernelArgGeneratorT<cl_double>)
+TYPE_HNDL("double16*",               true,  0, 16,            -0x40000000,         0x40000000,    KernelArgGeneratorT<cl_double>)
+TYPE_HNDL("double2",                 false, 0,  2,            -0x40000000,         0x40000000,    KernelArgGeneratorT<cl_double>)
+TYPE_HNDL("double2*",                true,  0,  2,            -0x40000000,         0x40000000,    KernelArgGeneratorT<cl_double>)
+TYPE_HNDL("double3",                 false, 0,  3,            -0x40000000,         0x40000000,    KernelArgGeneratorT<cl_double>)
+TYPE_HNDL("double3*",                true,  0,  3,            -0x40000000,         0x40000000,    KernelArgGeneratorT<cl_double>)
+TYPE_HNDL("double4",                 false, 0,  4,            -0x40000000,         0x40000000,    KernelArgGeneratorT<cl_double>)
+TYPE_HNDL("double4*",                true,  0,  4,            -0x40000000,         0x40000000,    KernelArgGeneratorT<cl_double>)
+TYPE_HNDL("double8",                 false, 0,  8,            -0x40000000,         0x40000000,    KernelArgGeneratorT<cl_double>)
+TYPE_HNDL("double8*",                true,  0,  8,            -0x40000000,         0x40000000,    KernelArgGeneratorT<cl_double>)
+TYPE_HNDL("enum enum_type",          false, 0,  1,                      0,                  2,    KernelArgGeneratorT<cl_int>)                    // enum defines 0..2
+TYPE_HNDL("enum enum_type*",         true,  0,  1,                      0,                  2,    KernelArgGeneratorT<cl_int>)                    // enum defines 0..2
+TYPE_HNDL("float",                   false, 0,  1,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)
+TYPE_HNDL("float*",                  true,  0, 16,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)
+TYPE_HNDL("float16",                 false, 0, 16,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)
+TYPE_HNDL("float16*",                true,  0, 16,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)
+TYPE_HNDL("float2",                  false, 0,  2,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)
+TYPE_HNDL("float2*",                 true,  0,  2,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)
+TYPE_HNDL("float3",                  false, 0,  3,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)
+TYPE_HNDL("float3*",                 true,  0,  3,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)
+TYPE_HNDL("float4",                  false, 0,  4,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)
+TYPE_HNDL("float4*",                 true,  0,  4,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)
+TYPE_HNDL("float8",                  false, 0,  8,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)
+TYPE_HNDL("float8*",                 true,  0,  8,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)
+TYPE_HNDL("half",                    false, 0,  1,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_half>)
+TYPE_HNDL("half*",                   true,  0, 16,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_half>)
+TYPE_HNDL("half16",                  false, 0, 16,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_half>)
+TYPE_HNDL("half16*",                 true,  0, 16,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_half>)
+TYPE_HNDL("half2",                   false, 0,  2,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_half>)
+TYPE_HNDL("half2*",                  true,  0,  2,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_half>)
+TYPE_HNDL("half3",                   false, 0,  3,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_half>)
+TYPE_HNDL("half3*",                  true,  0,  3,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_half>)
+TYPE_HNDL("half4",                   false, 0,  4,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_half>)
+TYPE_HNDL("half4*",                  true,  0,  4,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_half>)
+TYPE_HNDL("half8",                   false, 0,  8,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_half>)
+TYPE_HNDL("half8*",                  true,  0,  8,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_half>)
+TYPE_HNDL("image1d_array_t",         false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dArray<CL_SIGNED_INT32>)
+TYPE_HNDL("image1d_buffer_t",        false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dBuffer<CL_SIGNED_INT32>)
+TYPE_HNDL("image1d_t",               false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1d<CL_SIGNED_INT32>)
+TYPE_HNDL("image2d_array_t",         false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2dArray<CL_SIGNED_INT32>)
+TYPE_HNDL("image2d_t",               false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2d<CL_SIGNED_INT32>)
+TYPE_HNDL("image3d_t",               false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage3d<CL_SIGNED_INT32>)
+TYPE_HNDL("image1d_array_float",     false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dArray<CL_FLOAT>)
+TYPE_HNDL("image1d_array_int",       false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dArray<CL_SIGNED_INT32>)
+TYPE_HNDL("image1d_array_uint",      false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dArray<CL_UNSIGNED_INT32>)
+TYPE_HNDL("image1d_buffer_float",    false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dBuffer<CL_FLOAT>)
+TYPE_HNDL("image1d_buffer_int",      false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dBuffer<CL_SIGNED_INT32>)
+TYPE_HNDL("image1d_buffer_uint",     false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dBuffer<CL_UNSIGNED_INT32>)
+TYPE_HNDL("image1d_float",           false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1d<CL_FLOAT>)
+TYPE_HNDL("image1d_int",             false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1d<CL_SIGNED_INT32>)
+TYPE_HNDL("image1d_uint",            false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1d<CL_UNSIGNED_INT32>)
+TYPE_HNDL("image2d_array_float",     false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2dArray<CL_FLOAT>)
+TYPE_HNDL("image2d_array_int",       false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2dArray<CL_SIGNED_INT32>)
+TYPE_HNDL("image2d_array_uint",      false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2dArray<CL_UNSIGNED_INT32>)
+TYPE_HNDL("image2d_float",           false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2d<CL_FLOAT>)
+TYPE_HNDL("image2d_int",             false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2d<CL_SIGNED_INT32>)
+TYPE_HNDL("image2d_uint",            false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2d<CL_UNSIGNED_INT32>)
+TYPE_HNDL("image3d_float",           false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage3d<CL_FLOAT>)
+TYPE_HNDL("image3d_int",             false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage3d<CL_SIGNED_INT32>)
+TYPE_HNDL("image3d_uint",            false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage3d<CL_UNSIGNED_INT32>)
+TYPE_HNDL("image_kernel_data",       false, 0,  1,                    0x0,         0xffffffff,    KernelStructTypeArgGenerator<image_kernel_data>)             //image_kernel_data defines as 5 X int
+TYPE_HNDL("image_kernel_data*",      true,  0,  1,                    0x0,         0xffffffff,    KernelStructTypeArgGenerator<image_kernel_data>)             //image_kernel_data defines as 5 X int
+TYPE_HNDL("read_only_image1d_array_float",       false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dArray<CL_FLOAT>)
+TYPE_HNDL("read_only_image1d_array_int",         false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dArray<CL_SIGNED_INT32>)
+TYPE_HNDL("read_only_image1d_array_uint",        false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dArray<CL_UNSIGNED_INT32>)
+TYPE_HNDL("read_only_image1d_buffer_float",      false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dBuffer<CL_FLOAT>)
+TYPE_HNDL("read_only_image1d_buffer_int",        false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dBuffer<CL_SIGNED_INT32>)
+TYPE_HNDL("read_only_image1d_buffer_uint",       false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dBuffer<CL_UNSIGNED_INT32>)
+TYPE_HNDL("read_only_image1d_float",             false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1d<CL_FLOAT>)
+TYPE_HNDL("read_only_image1d_int",               false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1d<CL_SIGNED_INT32>)
+TYPE_HNDL("read_only_image1d_uint",              false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1d<CL_UNSIGNED_INT32>)
+TYPE_HNDL("read_only_image2d_array_float",       false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2dArray<CL_FLOAT>)
+TYPE_HNDL("read_only_image2d_array_int",         false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2dArray<CL_SIGNED_INT32>)
+TYPE_HNDL("read_only_image2d_array_uint",        false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2dArray<CL_UNSIGNED_INT32>)
+TYPE_HNDL("read_only_image2d_float",             false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2d<CL_FLOAT>)
+TYPE_HNDL("read_only_image2d_int",               false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2d<CL_SIGNED_INT32>)
+TYPE_HNDL("read_only_image2d_uint",              false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2d<CL_UNSIGNED_INT32>)
+TYPE_HNDL("read_only_image3d_float",             false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage3d<CL_FLOAT>)
+TYPE_HNDL("read_only_image3d_int",               false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage3d<CL_SIGNED_INT32>)
+TYPE_HNDL("read_only_image3d_uint",              false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage3d<CL_UNSIGNED_INT32>)
+TYPE_HNDL("write_only_image1d_array_float",       false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dArray<CL_FLOAT>)
+TYPE_HNDL("write_only_image1d_array_int",         false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dArray<CL_SIGNED_INT32>)
+TYPE_HNDL("write_only_image1d_array_uint",        false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dArray<CL_UNSIGNED_INT32>)
+TYPE_HNDL("write_only_image1d_buffer_float",      false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dBuffer<CL_FLOAT>)
+TYPE_HNDL("write_only_image1d_buffer_int",        false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dBuffer<CL_SIGNED_INT32>)
+TYPE_HNDL("write_only_image1d_buffer_uint",       false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1dBuffer<CL_UNSIGNED_INT32>)
+TYPE_HNDL("write_only_image1d_float",             false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1d<CL_FLOAT>)
+TYPE_HNDL("write_only_image1d_int",               false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1d<CL_SIGNED_INT32>)
+TYPE_HNDL("write_only_image1d_uint",              false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage1d<CL_UNSIGNED_INT32>)
+TYPE_HNDL("write_only_image2d_array_float",       false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2dArray<CL_FLOAT>)
+TYPE_HNDL("write_only_image2d_array_int",         false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2dArray<CL_SIGNED_INT32>)
+TYPE_HNDL("write_only_image2d_array_uint",        false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2dArray<CL_UNSIGNED_INT32>)
+TYPE_HNDL("write_only_image2d_float",             false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2d<CL_FLOAT>)
+TYPE_HNDL("write_only_image2d_int",               false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2d<CL_SIGNED_INT32>)
+TYPE_HNDL("write_only_image2d_uint",              false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage2d<CL_UNSIGNED_INT32>)
+TYPE_HNDL("write_only_image3d_float",             false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage3d<CL_FLOAT>)
+TYPE_HNDL("write_only_image3d_int",               false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage3d<CL_SIGNED_INT32>)
+TYPE_HNDL("write_only_image3d_uint",              false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorImage3d<CL_UNSIGNED_INT32>)
+TYPE_HNDL("int",                     false, 0,  1,                    0x0,         0x7fffffff,    KernelArgGeneratorT<cl_int>)
+TYPE_HNDL("int*",                    true,  0, 16,                    0x0,         0x7fffffff,    KernelArgGeneratorT<cl_int>)
+TYPE_HNDL("int16",                   false, 0, 16,                    0x0,         0x7fffffff,    KernelArgGeneratorT<cl_int>)
+TYPE_HNDL("int16*",                  true,  0, 16,                    0x0,         0x7fffffff,    KernelArgGeneratorT<cl_int>)
+TYPE_HNDL("int2",                    false, 0,  2,                    0x0,         0x7fffffff,    KernelArgGeneratorT<cl_int>)
+TYPE_HNDL("int2*",                   true,  0,  2,                    0x0,         0x7fffffff,    KernelArgGeneratorT<cl_int>)
+TYPE_HNDL("int3",                    false, 0,  3,                    0x0,         0x7fffffff,    KernelArgGeneratorT<cl_int>)
+TYPE_HNDL("int3*",                   true,  0,  3,                    0x0,         0x7fffffff,    KernelArgGeneratorT<cl_int>)
+TYPE_HNDL("int4",                    false, 0,  4,                    0x0,         0x7fffffff,    KernelArgGeneratorT<cl_int>)
+TYPE_HNDL("int4*",                   true,  0,  4,                    0x0,         0x7fffffff,    KernelArgGeneratorT<cl_int>)
+TYPE_HNDL("int8",                    false, 0,  8,                    0x0,         0x7fffffff,    KernelArgGeneratorT<cl_int>)
+TYPE_HNDL("int8*",                   true,  0,  8,                    0x0,         0x7fffffff,    KernelArgGeneratorT<cl_int>)
+TYPE_HNDL("intptr_t",                false, 0,  1,                    0x0,         0xffffffff,    KernelArgGeneratorT<size_t>)
+TYPE_HNDL("intptr_t*",               true,  0,  1,                    0x0,         0xffffffff,    KernelArgGeneratorT<size_t>)
+TYPE_HNDL("long",                    false, 0,  1,                    0x0, 0x7fffffffffffffff,    KernelArgGeneratorT<cl_long>)
+TYPE_HNDL("long*",                   true,  0, 16,                    0x0, 0x7fffffffffffffff,    KernelArgGeneratorT<cl_long>)
+TYPE_HNDL("long16",                  false, 0, 16,                    0x0, 0x7fffffffffffffff,    KernelArgGeneratorT<cl_long>)
+TYPE_HNDL("long16*",                 true,  0, 16,                    0x0, 0x7fffffffffffffff,    KernelArgGeneratorT<cl_long>)
+TYPE_HNDL("long2",                   false, 0,  2,                    0x0, 0x7fffffffffffffff,    KernelArgGeneratorT<cl_long>)
+TYPE_HNDL("long2*",                  true,  0,  2,                    0x0, 0x7fffffffffffffff,    KernelArgGeneratorT<cl_long>)
+TYPE_HNDL("long3",                   false, 0,  3,                    0x0, 0x7fffffffffffffff,    KernelArgGeneratorT<cl_long>)
+TYPE_HNDL("long3*",                  true,  0,  3,                    0x0, 0x7fffffffffffffff,    KernelArgGeneratorT<cl_long>)
+TYPE_HNDL("long4",                   false, 0,  4,                    0x0, 0x7fffffffffffffff,    KernelArgGeneratorT<cl_long>)
+TYPE_HNDL("long4*",                  true,  0,  4,                    0x0, 0x7fffffffffffffff,    KernelArgGeneratorT<cl_long>)
+TYPE_HNDL("long8",                   false, 0,  8,                    0x0, 0x7fffffffffffffff,    KernelArgGeneratorT<cl_long>)
+TYPE_HNDL("long8*",                  true,  0,  8,                    0x0, 0x7fffffffffffffff,    KernelArgGeneratorT<cl_long>)
+TYPE_HNDL("ptrdiff_t",               false, 0,  1,                    0x0,         0xffffffff,    KernelArgGeneratorT<size_t>)
+TYPE_HNDL("ptrdiff_t*",              true,  0,  1,                    0x0,         0xffffffff,    KernelArgGeneratorT<size_t>)
+TYPE_HNDL("sampler_t",               false, 0,  1,                    0x0,               0x7f,    KernelArgGeneratorSampler)
+TYPE_HNDL("short",                   false, 0,  1,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_short>)
+TYPE_HNDL("short*",                  true,  0, 16,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_short>)
+TYPE_HNDL("short16",                 false, 0, 16,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_short>)
+TYPE_HNDL("short16*",                true,  0, 16,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_short>)
+TYPE_HNDL("short2",                  false, 0,  2,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_short>)
+TYPE_HNDL("short2*",                 true,  0,  2,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_short>)
+TYPE_HNDL("short3",                  false, 0,  3,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_short>)
+TYPE_HNDL("short3*",                 true,  0,  3,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_short>)
+TYPE_HNDL("short4",                  false, 0,  4,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_short>)
+TYPE_HNDL("short4*",                 true,  0,  4,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_short>)
+TYPE_HNDL("short8",                  false, 0,  8,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_short>)
+TYPE_HNDL("short8*",                 true,  0,  8,                    0x0,             0x7fff,    KernelArgGeneratorT<cl_short>)
+TYPE_HNDL("size_t",                  false, 0,  1,                    0x0,         0xffffffff,    KernelArgGeneratorT<size_t>)
+TYPE_HNDL("size_t*",                 true,  0,  1,                    0x0,         0xffffffff,    KernelArgGeneratorT<size_t>)
+TYPE_HNDL("struct",                  false, 0,  1,            -0x01000000,         0x01000000,    KernelArgGeneratorNI)
+TYPE_HNDL("struct struct_type",      false, 0,  1,            -0x01000000,         0x01000000,    KernelStructTypeArgGenerator<typedef_struct_type>)       //struct_type defines as {float4, int}
+TYPE_HNDL("struct struct_type*",     true,  0,  1,            -0x01000000,         0x01000000,    KernelStructTypeArgGenerator<typedef_struct_type>)       //struct_type defines as {float4, int}
+TYPE_HNDL("testStruct",              false, 0,  1,                    0x0,         0xffffffff,    KernelStructTypeArgGenerator<testStruct>)                //testStruct
+TYPE_HNDL("testStruct*",             true,  0,  1,                    0x0,         0xffffffff,    KernelStructTypeArgGenerator<testStruct>)                //testStruct
+TYPE_HNDL("typedef_enum_type",       false, 0,  1,                      0,                  2,    KernelArgGeneratorT<cl_int>)
+TYPE_HNDL("typedef_enum_type*",      true,  0,  1,                      0,                  2,    KernelArgGeneratorT<cl_int>)
+TYPE_HNDL("typedef_struct_type",     false, 0,  1,            -0x01000000,         0x01000000,    KernelStructTypeArgGenerator<typedef_struct_type>)       //typedef_struct_type defines as {float4, int}
+TYPE_HNDL("typedef_struct_type*",    true,  0,  1,            -0x01000000,         0x01000000,    KernelStructTypeArgGenerator<typedef_struct_type>)       //typedef_struct_type defines as {float4, int}
+TYPE_HNDL("typedef_type",            false, 0,  4,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)                //typeded_type defines as float4
+TYPE_HNDL("typedef_type*",           true,  0,  4,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)                //typeded_type defines as float4
+TYPE_HNDL("typedef_union_type",      false, 0,  4,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)                //typedef_union_type defines as float4/int4
+TYPE_HNDL("typedef_union_type*",     true,  0,  4,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)                //typedef_union_type defines as float4/int4
+TYPE_HNDL("uchar",                   false, 0,  1,                    0x0,               0xff,    KernelArgGeneratorT<cl_uchar>)
+TYPE_HNDL("uchar*",                  true,  0, 16,                    0x0,               0xff,    KernelArgGeneratorT<cl_uchar>)
+TYPE_HNDL("uchar16",                 false, 0, 16,                    0x0,               0xff,    KernelArgGeneratorT<cl_uchar>)
+TYPE_HNDL("uchar16*",                true,  0, 16,                    0x0,               0xff,    KernelArgGeneratorT<cl_uchar>)
+TYPE_HNDL("uchar2",                  false, 0,  2,                    0x0,               0xff,    KernelArgGeneratorT<cl_uchar>)
+TYPE_HNDL("uchar2*",                 true,  0,  2,                    0x0,               0xff,    KernelArgGeneratorT<cl_uchar>)
+TYPE_HNDL("uchar3",                  false, 0,  3,                    0x0,               0xff,    KernelArgGeneratorT<cl_uchar>)
+TYPE_HNDL("uchar3*",                 true,  0,  3,                    0x0,               0xff,    KernelArgGeneratorT<cl_uchar>)
+TYPE_HNDL("uchar4",                  false, 0,  4,                    0x0,               0xff,    KernelArgGeneratorT<cl_uchar>)
+TYPE_HNDL("uchar4*",                 true,  0,  4,                    0x0,               0xff,    KernelArgGeneratorT<cl_uchar>)
+TYPE_HNDL("uchar8",                  false, 0,  8,                    0x0,               0xff,    KernelArgGeneratorT<cl_uchar>)
+TYPE_HNDL("uchar8*",                 true,  0,  8,                    0x0,               0xff,    KernelArgGeneratorT<cl_uchar>)
+TYPE_HNDL("uint",                    false, 0,  1,                    0x0,         0xffffffff,    KernelArgGeneratorT<cl_uint>)
+TYPE_HNDL("uint*",                   true,  0, 16,                    0x0,         0xffffffff,    KernelArgGeneratorT<cl_uint>)
+TYPE_HNDL("uint16",                  false, 0, 16,                    0x0,         0xffffffff,    KernelArgGeneratorT<cl_uint>)
+TYPE_HNDL("uint16*",                 true,  0, 16,                    0x0,         0xffffffff,    KernelArgGeneratorT<cl_uint>)
+TYPE_HNDL("uint2",                   false, 0,  2,                    0x0,         0xffffffff,    KernelArgGeneratorT<cl_uint>)
+TYPE_HNDL("uint2*",                  true,  0,  2,                    0x0,         0xffffffff,    KernelArgGeneratorT<cl_uint>)
+TYPE_HNDL("uint3",                   false, 0,  3,                    0x0,         0xffffffff,    KernelArgGeneratorT<cl_uint>)
+TYPE_HNDL("uint3*",                  true,  0,  3,                    0x0,         0xffffffff,    KernelArgGeneratorT<cl_uint>)
+TYPE_HNDL("uint4",                   false, 0,  4,                    0x0,         0xffffffff,    KernelArgGeneratorT<cl_uint>)
+TYPE_HNDL("uint4*",                  true,  0,  4,                    0x0,         0xffffffff,    KernelArgGeneratorT<cl_uint>)
+TYPE_HNDL("uint8",                   false, 0,  8,                    0x0,         0xffffffff,    KernelArgGeneratorT<cl_uint>)
+TYPE_HNDL("uint8*",                  true,  0,  8,                    0x0,         0xffffffff,    KernelArgGeneratorT<cl_uint>)
+TYPE_HNDL("uintptr_t",               false, 0,  1,                    0x0,         0xffffffff,    KernelArgGeneratorT<size_t>)
+TYPE_HNDL("uintptr_t*",              true,  0,  1,                    0x0,         0xffffffff,    KernelArgGeneratorT<size_t>)
+TYPE_HNDL("ulong",                   false, 0,  1,                    0x0, 0xffffffffffffffff,    KernelArgGeneratorT<cl_ulong>)
+TYPE_HNDL("ulong*",                  true,  0, 16,                    0x0, 0xffffffffffffffff,    KernelArgGeneratorT<cl_ulong>)
+TYPE_HNDL("ulong16",                 false, 0, 16,                    0x0, 0xffffffffffffffff,    KernelArgGeneratorT<cl_ulong>)
+TYPE_HNDL("ulong16*",                true,  0, 16,                    0x0, 0xffffffffffffffff,    KernelArgGeneratorT<cl_ulong>)
+TYPE_HNDL("ulong2",                  false, 0,  2,                    0x0, 0xffffffffffffffff,    KernelArgGeneratorT<cl_ulong>)
+TYPE_HNDL("ulong2*",                 true,  0,  2,                    0x0, 0xffffffffffffffff,    KernelArgGeneratorT<cl_ulong>)
+TYPE_HNDL("ulong3",                  false, 0,  3,                    0x0, 0xffffffffffffffff,    KernelArgGeneratorT<cl_ulong>)
+TYPE_HNDL("ulong3*",                 true,  0,  3,                    0x0, 0xffffffffffffffff,    KernelArgGeneratorT<cl_ulong>)
+TYPE_HNDL("ulong4",                  false, 0,  4,                    0x0, 0xffffffffffffffff,    KernelArgGeneratorT<cl_ulong>)
+TYPE_HNDL("ulong4*",                 true,  0,  4,                    0x0, 0xffffffffffffffff,    KernelArgGeneratorT<cl_ulong>)
+TYPE_HNDL("ulong8",                  false, 0,  8,                    0x0, 0xffffffffffffffff,    KernelArgGeneratorT<cl_ulong>)
+TYPE_HNDL("ulong8*",                 true,  0,  8,                    0x0, 0xffffffffffffffff,    KernelArgGeneratorT<cl_ulong>)
+TYPE_HNDL("union union_type",        false, 0,  4,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)                //union union_type defines as float4/int4
+TYPE_HNDL("union union_type*",       true,  0,  4,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)                //union union_type defines as float4/int4
+TYPE_HNDL("union_type",              false, 0,  4,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)                //union_type defines as float4/int4
+TYPE_HNDL("union_type*",             true,  0,  4,            -0x01000000,         0x01000000,    KernelArgGeneratorT<cl_float>)                //union_type defines as float4/int4
+TYPE_HNDL("ushort",                  false, 0,  1,                    0x0,             0xffff,    KernelArgGeneratorT<cl_ushort>)
+TYPE_HNDL("ushort*",                 true,  0, 16,                    0x0,             0xffff,    KernelArgGeneratorT<cl_ushort>)
+TYPE_HNDL("ushort16",                false, 0, 16,                    0x0,             0xffff,    KernelArgGeneratorT<cl_ushort>)
+TYPE_HNDL("ushort16*",               true,  0, 16,                    0x0,             0xffff,    KernelArgGeneratorT<cl_ushort>)
+TYPE_HNDL("ushort2",                 false, 0,  2,                    0x0,             0xffff,    KernelArgGeneratorT<cl_ushort>)
+TYPE_HNDL("ushort2*",                true,  0,  2,                    0x0,             0xffff,    KernelArgGeneratorT<cl_ushort>)
+TYPE_HNDL("ushort3",                 false, 0,  3,                    0x0,             0xffff,    KernelArgGeneratorT<cl_ushort>)
+TYPE_HNDL("ushort3*",                true,  0,  3,                    0x0,             0xffff,    KernelArgGeneratorT<cl_ushort>)
+TYPE_HNDL("ushort4",                 false, 0,  4,                    0x0,             0xffff,    KernelArgGeneratorT<cl_ushort>)
+TYPE_HNDL("ushort4*",                true,  0,  4,                    0x0,             0xffff,    KernelArgGeneratorT<cl_ushort>)
+TYPE_HNDL("ushort8",                 false, 0,  8,                    0x0,             0xffff,    KernelArgGeneratorT<cl_ushort>)
+TYPE_HNDL("ushort8*",                true,  0,  8,                    0x0,             0xffff,    KernelArgGeneratorT<cl_ushort>)
+TYPE_HNDL("void*",                   true,  0, 16,                    0x0,               0xff,    KernelArgGeneratorT<cl_char>)
+TYPE_HNDL("work_item_data",          false, 0,  1,                    0x0,         0xffffffff,    KernelStructTypeArgGenerator<work_item_data>)                //work_item_data defines as uint, 6 X uint[3]
+TYPE_HNDL("work_item_data*",         true,  0,  1,                    0x0,         0xffffffff,    KernelStructTypeArgGenerator<work_item_data>)                //work_item_data defines as uint, 6 X uint[3]