Layers (#125)

* remove CMake option for OpenCL 3.0 provisional

* generate the OpenCL 3.0 APIs also

* Added layers.

* Added test print layer.

* Added missing cpp guards to cl_icd_layer.h.

* Rearrange includes in icd_windows.c to ensure DXGI.h has INITGUID defined when it's included

* Fix extern "C" usage in Windows build

* Ensure platforms are initialized before initializing layers.

* Fix faulty merge.

* Fix copy paste errors.

* Added ENABLE_OPENCL_LAYERS option to CMakeLists.

* Activate layers by default and fix bad copy paste...

* Added formal definition of Layer API entry points.

* Better variable name.

* Added a section dedicated to layers in the README.

* Changed value to proposed reserved enum range.

* Bumped version number for windows release.

* Added guard for MacOS.

Co-authored-by: Ben Ashbaugh <ben.ashbaugh@intel.com>
Co-authored-by: Jesse Natalie <jenatali@microsoft.com>

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 05455afd6696e3a39f4d3e04631fa134f429d9d2..fa791a322c8523d98f07aaf0a820f8c3ed293533 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -34,6 +34,11 @@ find_package (Threads REQUIRED)
 # advance. Use it with discretion.
 option (BUILD_SHARED_LIBS "Build shared libs" ON)
 
+# This option enables/disables support for OpenCL layers in the ICD loader.
+# It is currently needed default while the specification is being formalized,
+# and to study the performance impact.
+option (ENABLE_OPENCL_LAYERS "Enable OpenCL Layers" ON)
+
 include(CheckFunctionExists)
 check_function_exists(secure_getenv HAVE_SECURE_GETENV)
 check_function_exists(__secure_getenv HAVE___SECURE_GETENV)
@@ -49,6 +54,11 @@ set (OPENCL_ICD_LOADER_SOURCES
     loader/icd_envvars.h
     loader/icd_platform.h)
 
+if (ENABLE_OPENCL_LAYERS)
+    list (APPEND OPENCL_ICD_LOADER_SOURCES
+        include/cl_icd_layer.h)
+endif ()
+
 if (WIN32)
     list (APPEND OPENCL_ICD_LOADER_SOURCES 
         loader/windows/adapter.h
@@ -81,6 +91,8 @@ set (OPENCL_ICD_LOADER_HEADERS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/inc CACHE PATH "P
 add_library (OpenCL ${OPENCL_ICD_LOADER_SOURCES})
 set_target_properties (OpenCL PROPERTIES VERSION "1.2" SOVERSION "1")
 target_include_directories(OpenCL SYSTEM PUBLIC ${OPENCL_ICD_LOADER_HEADERS_DIR})
+target_include_directories(OpenCL PRIVATE include)
+
 
 if (WIN32)
     target_link_libraries (OpenCL cfgmgr32.lib runtimeobject.lib)
@@ -115,6 +127,10 @@ endif ()
 include_directories (${OPENCL_ICD_LOADER_HEADERS_DIR})
 add_definitions (-DCL_TARGET_OPENCL_VERSION=300)
 
+if (ENABLE_OPENCL_LAYERS)
+    add_definitions (-DCL_ENABLE_LAYERS)
+endif ()
+
 target_include_directories (OpenCL PRIVATE ${CMAKE_CURRENT_BINARY_DIR} loader)
 target_link_libraries (OpenCL ${CMAKE_DL_LIBS})
 

diff --git a/README.md b/README.md
index a51815845cbf6dbf4b3d202933e2c99d796d412d..e0a5d26f45d5795ed105aa6915e56eb11a0816d2 100644 (file)
--- a/README.md
+++ b/README.md
@@ -108,6 +108,23 @@ The CMake-generated build files may be able to invoke the OpenCL ICD Loader test
 
 Manually remove the file or registry keys added during Test Setup.
 
+## About Layers
+
+Layers have been added as an experimental feature in the OpenCL ICD Loader. We do not
+expect the API or ABI to change significantly, but the OpenCL Working Group reserves
+the right to do so. The layer support can also be completely deactivated during
+configuration by using the `ENABLE_OPENCL_LAYERS` (`ON` by default) cmake variable:
+
+```bash
+cmake -DENABLE_OPENCL_LAYERS=OFF
+```
+
+For now, runtime configuration of layers is done using the `OCL_ICD_LAYERS` environment
+variable. A colon (Linux) or semicolon (Windows) list of layers to use can be provided
+through this environment variable.
+
+We are looking for feedback.
+
 ## Support
 
 Please create a GitHub issue to report an issue or ask questions.
@@ -125,3 +142,4 @@ The following debug environment variables are available for use with the OpenCL
 |:---------------------------------:|---------------------|----------------------|
 | OCL_ICD_FILENAMES                 | Specifies a list of additional ICDs to load.  The ICDs will be enumerated first, before any ICDs discovered via default mechanisms. | `export OCL_ICD_FILENAMES=libVendorA.so:libVendorB.so`<br/><br/>`set OCL_ICD_FILENAMES=vendor_a.dll;vendor_b.dll` |
 | OCL_ICD_VENDORS                   | On Linux and Android, specifies a directory to scan for ICDs to enumerate in place of the default `/etc/OpenCL/vendors'. |  `export OCL_ICD_VENDORS=/my/local/icd/search/path` |
+| OCL_ICD_LAYERS                    | Specifies a list of layers to load. |  `export OCL_ICD_LAYERS=libLayerA.so:libLayerB.so`<br/><br/>`set OCL_ICD_LAYERS=libLayerA.dll;libLayerB.dll` |

diff --git a/include/cl_icd_layer.h b/include/cl_icd_layer.h
new file mode 100644 (file)
index 0000000..629f8f4
--- /dev/null
+++ b/include/cl_icd_layer.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2020 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.
+ *
+ * OpenCL is a trademark of Apple Inc. used under license by Khronos.
+ */
+
+#ifndef __ICD_LAYER_H
+#define __ICD_LAYER_H
+
+#include <CL/cl.h>
+#include <CL/cl_icd.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef cl_uint cl_layer_info;
+typedef cl_uint cl_layer_api_version;
+#define CL_LAYER_API_VERSION 0x4240
+#define CL_LAYER_API_VERSION_100 100
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clGetLayerInfo(cl_layer_info  param_name,
+               size_t         param_value_size,
+               void          *param_value,
+               size_t        *param_value_size_ret);
+
+CL_API_ENTRY typedef cl_int
+(CL_API_CALL *pfn_clGetLayerInfo)(cl_layer_info  param_name,
+                                  size_t         param_value_size,
+                                  void          *param_value,
+                                  size_t        *param_value_size_ret);
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clInitLayer(cl_uint                         num_entries,
+            const struct _cl_icd_dispatch  *target_dispatch,
+            cl_uint                        *num_entries_ret,
+            const struct _cl_icd_dispatch **layer_dispatch_ret);
+
+CL_API_ENTRY typedef cl_int
+(CL_API_CALL *pfn_clInitLayer)(cl_uint                         num_entries,
+                               const struct _cl_icd_dispatch  *target_dispatch,
+                               cl_uint                        *num_entries_ret,
+                               const struct _cl_icd_dispatch **layer_dispatch_ret);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __ICD_LAYER_H */

diff --git a/loader/icd.c b/loader/icd.c
index ea8306ab1a831092a4a00b1fee27d1a8d8fe512d..b43ecd70b3cd8c88fd7f8b665224942a6c7ca1ca 100644 (file)
--- a/loader/icd.c
+++ b/loader/icd.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2019 The Khronos Group Inc.
+ * Copyright (c) 2016-2020 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.
@@ -19,10 +19,16 @@
 #include "icd.h"
 #include "icd_dispatch.h"
 #include "icd_envvars.h"
+#if defined(CL_ENABLE_LAYERS)
+#include "cl_icd_layer.h"
+#endif // defined(CL_ENABLE_LAYERS)
 #include <stdlib.h>
 #include <string.h>
 
 KHRicdVendor *khrIcdVendors = NULL;
+#if defined(CL_ENABLE_LAYERS)
+struct KHRLayer *khrFirstLayer = NULL;
+#endif // defined(CL_ENABLE_LAYERS)
 
 // entrypoint to initialize the ICD and add all vendors
 void khrIcdInitialize(void)
@@ -189,6 +195,129 @@ Done:
     }
 }
 
+#if defined(CL_ENABLE_LAYERS)
+void khrIcdLayerAdd(const char *libraryName)
+{
+    void *library = NULL;
+    cl_int result = CL_SUCCESS;
+    pfn_clGetLayerInfo p_clGetLayerInfo = NULL;
+    pfn_clInitLayer p_clInitLayer = NULL;
+    struct KHRLayer *layerIterator = NULL;
+    struct KHRLayer *layer = NULL;
+    cl_layer_api_version api_version = 0;
+    const struct _cl_icd_dispatch *targetDispatch = NULL;
+    const struct _cl_icd_dispatch *layerDispatch = NULL;
+    cl_uint layerDispatchNumEntries = 0;
+    cl_uint loaderDispatchNumEntries = 0;
+
+    // require that the library name be valid
+    if (!libraryName)
+    {
+        goto Done;
+    }
+    KHR_ICD_TRACE("attempting to add layer %s...\n", libraryName);
+
+    // load its library and query its function pointers
+    library = khrIcdOsLibraryLoad(libraryName);
+    if (!library)
+    {
+        KHR_ICD_TRACE("failed to load library %s\n", libraryName);
+        goto Done;
+    }
+
+    // ensure that we haven't already loaded this layer
+    for (layerIterator = khrFirstLayer; layerIterator; layerIterator = layerIterator->next)
+    {
+        if (layerIterator->library == library)
+        {
+            KHR_ICD_TRACE("already loaded layer %s, nothing to do here\n", libraryName);
+            goto Done;
+        }
+    }
+
+    // get the library's clGetLayerInfo pointer
+    p_clGetLayerInfo = (pfn_clGetLayerInfo)(size_t)khrIcdOsLibraryGetFunctionAddress(library, "clGetLayerInfo");
+    if (!p_clGetLayerInfo)
+    {
+        KHR_ICD_TRACE("failed to get function address clGetLayerInfo\n");
+        goto Done;
+    }
+
+    // use that function to get the clInitLayer function pointer
+    p_clInitLayer = (pfn_clInitLayer)(size_t)khrIcdOsLibraryGetFunctionAddress(library, "clInitLayer");
+    if (!p_clInitLayer)
+    {
+        KHR_ICD_TRACE("failed to get function address clInitLayer\n");
+        goto Done;
+    }
+
+    result = p_clGetLayerInfo(CL_LAYER_API_VERSION, sizeof(api_version), &api_version, NULL);
+    if (CL_SUCCESS != result)
+    {
+        KHR_ICD_TRACE("failed to query layer version\n");
+        goto Done;
+    }
+
+    if (CL_LAYER_API_VERSION_100 != api_version)
+    {
+        KHR_ICD_TRACE("unsupported api version\n");
+        goto Done;
+    }
+
+    layer = (struct KHRLayer*)calloc(sizeof(struct KHRLayer), 1);
+    if (!layer)
+    {
+        KHR_ICD_TRACE("failed to allocate memory\n");
+        goto Done;
+    }
+
+    if (khrFirstLayer) {
+        targetDispatch = &(khrFirstLayer->dispatch);
+    } else {
+        targetDispatch = &khrMasterDispatch;
+    }
+
+    loaderDispatchNumEntries = sizeof(khrMasterDispatch)/sizeof(void*);
+    result = p_clInitLayer(
+        loaderDispatchNumEntries,
+        targetDispatch,
+        &layerDispatchNumEntries,
+        &layerDispatch);
+    if (CL_SUCCESS != result)
+    {
+        KHR_ICD_TRACE("failed to initialize layer\n");
+        goto Done;
+    }
+
+    layer->next = khrFirstLayer;
+    khrFirstLayer = layer;
+    layer->library = library;
+
+    cl_uint limit = layerDispatchNumEntries < loaderDispatchNumEntries ? layerDispatchNumEntries : loaderDispatchNumEntries;
+
+    for (cl_uint i = 0; i < limit; i++) {
+        ((void **)&(layer->dispatch))[i] =
+            ((void **)layerDispatch)[i] ?
+                ((void **)layerDispatch)[i] : ((void **)targetDispatch)[i];
+    }
+    for (cl_uint i = limit; i < loaderDispatchNumEntries; i++) {
+        ((void **)&(layer->dispatch))[i] = ((void **)targetDispatch)[i];
+    }
+
+    KHR_ICD_TRACE("successfully added layer %s\n", libraryName);
+    return;
+Done:
+    if (library)
+    {
+        khrIcdOsLibraryUnload(library);
+    }
+    if (layer)
+    {
+        free(layer);
+    }
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
 // Get next file or dirname given a string list or registry key path.
 // Note: the input string may be modified!
 static char *loader_get_next_path(char *path) {
@@ -229,6 +358,29 @@ void khrIcdVendorsEnumerateEnv(void)
     }
 }
 
+#if defined(CL_ENABLE_LAYERS)
+void khrIcdLayersEnumerateEnv(void)
+{
+    char* layerFilenames = khrIcd_secure_getenv("OCL_ICD_LAYERS");
+    char* cur_file = NULL;
+    char* next_file = NULL;
+    if (layerFilenames)
+    {
+        KHR_ICD_TRACE("Found OCL_ICD_LAYERS environment variable.\n");
+
+        next_file = layerFilenames;
+        while (NULL != next_file && *next_file != '\0') {
+            cur_file = next_file;
+            next_file = loader_get_next_path(cur_file);
+
+            khrIcdLayerAdd(cur_file);
+        }
+
+        khrIcd_free_getenv(layerFilenames);
+    }
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
 void khrIcdContextPropertiesGetPlatform(const cl_context_properties *properties, cl_platform_id *outPlatform)
 {
     if (properties == NULL && khrIcdVendors != NULL)

diff --git a/loader/icd.h b/loader/icd.h
index 34751e958c22a07ade037dffdb60acb3aa54ec64..dd3115b2098b2a373310b4f3ca63dc009b63d8e9 100644 (file)
--- a/loader/icd.h
+++ b/loader/icd.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2019 The Khronos Group Inc.
+ * Copyright (c) 2016-2020 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.
@@ -35,6 +35,7 @@
 
 #include <CL/cl.h>
 #include <CL/cl_ext.h>
+#include <CL/cl_icd.h>
 
 /*
  * type definitions
@@ -83,6 +84,28 @@ struct KHRicdVendorRec
 // the global state
 extern KHRicdVendor * khrIcdVendors;
 
+#if defined(CL_ENABLE_LAYERS)
+/*
+ * KHRLayer
+ *
+ * Data for a single Layer
+ */
+struct KHRLayer;
+struct KHRLayer
+{
+    // the loaded library object (true type varies on Linux versus Windows)
+    void *library;
+    // the dispatch table of the layer
+    struct _cl_icd_dispatch dispatch;
+    // The next layer in the chain
+    struct KHRLayer *next;
+};
+
+// the global layer state
+extern struct KHRLayer * khrFirstLayer;
+extern struct _cl_icd_dispatch khrMasterDispatch;
+#endif // defined(CL_ENABLE_LAYERS)
+
 /* 
  * khrIcd interface
  */
@@ -105,6 +128,12 @@ void khrIcdVendorsEnumerateEnv(void);
 // add a vendor's implementation to the list of libraries
 void khrIcdVendorAdd(const char *libraryName);
 
+// read layers from environment variables
+void khrIcdLayersEnumerateEnv(void);
+
+// add a layer to the layer chain
+void khrIcdLayerAdd(const char *libraryName);
+
 // dynamically load a library.  returns NULL on failure
 // n.b, this call is OS-specific
 void *khrIcdOsLibraryLoad(const char *libraryName);

diff --git a/loader/icd_dispatch.c b/loader/icd_dispatch.c
index 2d1e4bd4120658003f7115162dff8227007d0174..420389cfe374ce70ae8118ddda201c49ef0e470c 100644 (file)
--- a/loader/icd_dispatch.c
+++ b/loader/icd_dispatch.c
@@ -101,17 +101,14 @@ static void* khrIcdGetExtensionFunctionAddress(const char* function_name)
 extern "C" {
 #endif
 
-CL_API_ENTRY cl_int CL_API_CALL clGetPlatformIDs(
+static inline cl_int clGetPlatformIDs_body(
     cl_uint num_entries,
     cl_platform_id* platforms,
-    cl_uint* num_platforms) CL_API_SUFFIX__VERSION_1_0
+    cl_uint* num_platforms)
 {
     KHRicdVendor* vendor = NULL;
     cl_uint i;
 
-    // initialize the platforms (in case they have not been already)
-    khrIcdInitialize();
-
     if (!num_entries && platforms)
     {
         return CL_INVALID_VALUE;
@@ -150,8 +147,40 @@ CL_API_ENTRY cl_int CL_API_CALL clGetPlatformIDs(
     return CL_SUCCESS;
 }
 
-CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddress(
-    const char* function_name) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+CL_API_ENTRY cl_int CL_API_CALL clGetPlatformIDs_disp(
+    cl_uint num_entries,
+    cl_platform_id* platforms,
+    cl_uint* num_platforms) CL_API_SUFFIX__VERSION_1_0
+{
+    return clGetPlatformIDs_body(
+        num_entries,
+        platforms,
+        num_platforms);
+}
+
+CL_API_ENTRY cl_int CL_API_CALL clGetPlatformIDs(
+    cl_uint num_entries,
+    cl_platform_id* platforms,
+    cl_uint* num_platforms) CL_API_SUFFIX__VERSION_1_0
+{
+    // initialize the platforms (in case they have not been already)
+    khrIcdInitialize();
+
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetPlatformIDs(
+            num_entries,
+            platforms,
+            num_platforms);
+#endif // defined(CL_ENABLE_LAYERS)
+    return clGetPlatformIDs_body(
+        num_entries,
+        platforms,
+        num_platforms);
+}
+
+static inline void* clGetExtensionFunctionAddress_body(
+    const char* function_name)
 {
     void* function_address = NULL;
     size_t function_name_length = 0;
@@ -159,9 +188,6 @@ CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddress(
 
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL);
 
-    // make sure the ICD is initialized
-    khrIcdInitialize();
-
     // check if this is an ICD-aware extension
     function_address = khrIcdGetExtensionFunctionAddress(function_name);
     if (function_address)
@@ -189,7 +215,29 @@ CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddress(
     return NULL;
 }
 
-CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddressForPlatform(
+CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddress_disp(
+    const char* function_name) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+    return clGetExtensionFunctionAddress_body(
+        function_name);
+}
+
+CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddress(
+    const char* function_name) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+    // make sure the ICD is initialized
+    khrIcdInitialize();
+
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetExtensionFunctionAddress(
+            function_name);
+#endif // defined(CL_ENABLE_LAYERS)
+    return clGetExtensionFunctionAddress_body(
+        function_name);
+}
+
+static inline void* clGetExtensionFunctionAddressForPlatform_body(
     cl_platform_id platform,
     const char* function_name) CL_API_SUFFIX__VERSION_1_2
 {
@@ -197,9 +245,6 @@ CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddressForPlatform(
 
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL);
 
-    // make sure the ICD is initialized
-    khrIcdInitialize();
-
     // check if this is an ICD-aware extension
     function_address = khrIcdGetExtensionFunctionAddress(function_name);
     if (function_address)
@@ -216,6 +261,32 @@ CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddressForPlatform(
         function_name);
 }
 
+CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddressForPlatform_disp(
+    cl_platform_id platform,
+    const char* function_name) CL_API_SUFFIX__VERSION_1_2
+{
+    return clGetExtensionFunctionAddressForPlatform_body(
+        platform,
+        function_name);
+}
+
+CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddressForPlatform(
+    cl_platform_id platform,
+    const char* function_name) CL_API_SUFFIX__VERSION_1_2
+{
+    // make sure the ICD is initialized
+    khrIcdInitialize();
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetExtensionFunctionAddressForPlatform(
+            platform,
+            function_name);
+#endif // defined(CL_ENABLE_LAYERS)
+    return clGetExtensionFunctionAddressForPlatform_body(
+        platform,
+        function_name);
+}
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/loader/icd_dispatch_generated.c b/loader/icd_dispatch_generated.c
index 8498563b8a0950279acabf071f8b372f0d079146..deced702010cc45c516425011ae069816368c388 100644 (file)
--- a/loader/icd_dispatch_generated.c
+++ b/loader/icd_dispatch_generated.c
@@ -25,6 +25,13 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////////////////////
 // Core APIs:
+#if defined(CL_ENABLE_LAYERS)
+extern CL_API_ENTRY cl_int CL_API_CALL clGetPlatformIDs_disp(
+    cl_uint num_entries,
+    cl_platform_id* platforms,
+    cl_uint* num_platforms) CL_API_SUFFIX__VERSION_1_0;
+#endif // defined(CL_ENABLE_LAYERS)
+
 
 CL_API_ENTRY cl_int CL_API_CALL clGetPlatformInfo(
     cl_platform_id platform,
@@ -32,6 +39,33 @@ CL_API_ENTRY cl_int CL_API_CALL clGetPlatformInfo(
     size_t param_value_size,
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetPlatformInfo(
+            platform,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
+    return platform->dispatch->clGetPlatformInfo(
+        platform,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetPlatformInfo_disp(
+    cl_platform_id platform,
+    cl_platform_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
     return platform->dispatch->clGetPlatformInfo(
@@ -41,6 +75,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetPlatformInfo(
         param_value,
         param_value_size_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -50,6 +85,33 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDs(
     cl_uint num_entries,
     cl_device_id* devices,
     cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetDeviceIDs(
+            platform,
+            device_type,
+            num_entries,
+            devices,
+            num_devices);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
+    return platform->dispatch->clGetDeviceIDs(
+        platform,
+        device_type,
+        num_entries,
+        devices,
+        num_devices);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDs_disp(
+    cl_platform_id platform,
+    cl_device_type device_type,
+    cl_uint num_entries,
+    cl_device_id* devices,
+    cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
     return platform->dispatch->clGetDeviceIDs(
@@ -59,6 +121,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDs(
         devices,
         num_devices);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -68,6 +131,33 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceInfo(
     size_t param_value_size,
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetDeviceInfo(
+            device,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
+    return device->dispatch->clGetDeviceInfo(
+        device,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceInfo_disp(
+    cl_device_id device,
+    cl_device_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
     return device->dispatch->clGetDeviceInfo(
@@ -77,6 +167,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceInfo(
         param_value,
         param_value_size_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -87,6 +178,39 @@ CL_API_ENTRY cl_context CL_API_CALL clCreateContext(
     void (CL_CALLBACK* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data),
     void* user_data,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateContext(
+            properties,
+            num_devices,
+            devices,
+            pfn_notify,
+            user_data,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    if (num_devices == 0 || devices == NULL) {
+        KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(NULL, CL_INVALID_VALUE);
+    }
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(devices[0], CL_INVALID_DEVICE);
+    return devices[0]->dispatch->clCreateContext(
+        properties,
+        num_devices,
+        devices,
+        pfn_notify,
+        user_data,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_context CL_API_CALL clCreateContext_disp(
+    const cl_context_properties* properties,
+    cl_uint num_devices,
+    const cl_device_id* devices,
+    void (CL_CALLBACK* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data),
+    void* user_data,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
     if (num_devices == 0 || devices == NULL) {
         KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(NULL, CL_INVALID_VALUE);
@@ -100,6 +224,7 @@ CL_API_ENTRY cl_context CL_API_CALL clCreateContext(
         user_data,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -110,8 +235,38 @@ CL_API_ENTRY cl_context CL_API_CALL clCreateContextFromType(
     void* user_data,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
+    khrIcdInitialize();
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateContextFromType(
+            properties,
+            device_type,
+            pfn_notify,
+            user_data,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
     cl_platform_id platform = NULL;
+    khrIcdContextPropertiesGetPlatform(properties, &platform);
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(platform, CL_INVALID_PLATFORM);
+    return platform->dispatch->clCreateContextFromType(
+        properties,
+        device_type,
+        pfn_notify,
+        user_data,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_context CL_API_CALL clCreateContextFromType_disp(
+    const cl_context_properties* properties,
+    cl_device_type device_type,
+    void (CL_CALLBACK* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data),
+    void* user_data,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
     khrIcdInitialize();
+    cl_platform_id platform = NULL;
     khrIcdContextPropertiesGetPlatform(properties, &platform);
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(platform, CL_INVALID_PLATFORM);
     return platform->dispatch->clCreateContextFromType(
@@ -121,26 +276,59 @@ CL_API_ENTRY cl_context CL_API_CALL clCreateContextFromType(
         user_data,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clRetainContext(
     cl_context context) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clRetainContext(
+            context);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clRetainContext(
+        context);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clRetainContext_disp(
+    cl_context context) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
     return context->dispatch->clRetainContext(
         context);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clReleaseContext(
     cl_context context) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clReleaseContext(
+            context);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clReleaseContext(
+        context);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseContext_disp(
+    cl_context context) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
     return context->dispatch->clReleaseContext(
         context);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -150,6 +338,33 @@ CL_API_ENTRY cl_int CL_API_CALL clGetContextInfo(
     size_t param_value_size,
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetContextInfo(
+            context,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clGetContextInfo(
+        context,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetContextInfo_disp(
+    cl_context context,
+    cl_context_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
     return context->dispatch->clGetContextInfo(
@@ -159,26 +374,59 @@ CL_API_ENTRY cl_int CL_API_CALL clGetContextInfo(
         param_value,
         param_value_size_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clRetainCommandQueue(
     cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clRetainCommandQueue(
+            command_queue);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clRetainCommandQueue(
+        command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clRetainCommandQueue_disp(
+    cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clRetainCommandQueue(
         command_queue);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clReleaseCommandQueue(
     cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clReleaseCommandQueue(
+            command_queue);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clReleaseCommandQueue(
+        command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseCommandQueue_disp(
+    cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clReleaseCommandQueue(
         command_queue);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -188,6 +436,33 @@ CL_API_ENTRY cl_int CL_API_CALL clGetCommandQueueInfo(
     size_t param_value_size,
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetCommandQueueInfo(
+            command_queue,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clGetCommandQueueInfo(
+        command_queue,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetCommandQueueInfo_disp(
+    cl_command_queue command_queue,
+    cl_command_queue_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clGetCommandQueueInfo(
@@ -197,6 +472,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetCommandQueueInfo(
         param_value,
         param_value_size_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -206,6 +482,33 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateBuffer(
     size_t size,
     void* host_ptr,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateBuffer(
+            context,
+            flags,
+            size,
+            host_ptr,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateBuffer(
+        context,
+        flags,
+        size,
+        host_ptr,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateBuffer_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    size_t size,
+    void* host_ptr,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateBuffer(
@@ -215,26 +518,59 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateBuffer(
         host_ptr,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clRetainMemObject(
     cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clRetainMemObject(
+            memobj);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
+    return memobj->dispatch->clRetainMemObject(
+        memobj);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clRetainMemObject_disp(
+    cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
     return memobj->dispatch->clRetainMemObject(
         memobj);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clReleaseMemObject(
     cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clReleaseMemObject(
+            memobj);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
+    return memobj->dispatch->clReleaseMemObject(
+        memobj);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseMemObject_disp(
+    cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
     return memobj->dispatch->clReleaseMemObject(
         memobj);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -245,6 +581,36 @@ CL_API_ENTRY cl_int CL_API_CALL clGetSupportedImageFormats(
     cl_uint num_entries,
     cl_image_format* image_formats,
     cl_uint* num_image_formats) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetSupportedImageFormats(
+            context,
+            flags,
+            image_type,
+            num_entries,
+            image_formats,
+            num_image_formats);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clGetSupportedImageFormats(
+        context,
+        flags,
+        image_type,
+        num_entries,
+        image_formats,
+        num_image_formats);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetSupportedImageFormats_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    cl_mem_object_type image_type,
+    cl_uint num_entries,
+    cl_image_format* image_formats,
+    cl_uint* num_image_formats) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
     return context->dispatch->clGetSupportedImageFormats(
@@ -255,6 +621,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetSupportedImageFormats(
         image_formats,
         num_image_formats);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -264,6 +631,33 @@ CL_API_ENTRY cl_int CL_API_CALL clGetMemObjectInfo(
     size_t param_value_size,
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetMemObjectInfo(
+            memobj,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
+    return memobj->dispatch->clGetMemObjectInfo(
+        memobj,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetMemObjectInfo_disp(
+    cl_mem memobj,
+    cl_mem_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
     return memobj->dispatch->clGetMemObjectInfo(
@@ -273,6 +667,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetMemObjectInfo(
         param_value,
         param_value_size_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -282,6 +677,33 @@ CL_API_ENTRY cl_int CL_API_CALL clGetImageInfo(
     size_t param_value_size,
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetImageInfo(
+            image,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(image, CL_INVALID_MEM_OBJECT);
+    return image->dispatch->clGetImageInfo(
+        image,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetImageInfo_disp(
+    cl_mem image,
+    cl_image_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(image, CL_INVALID_MEM_OBJECT);
     return image->dispatch->clGetImageInfo(
@@ -291,26 +713,59 @@ CL_API_ENTRY cl_int CL_API_CALL clGetImageInfo(
         param_value,
         param_value_size_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clRetainSampler(
     cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clRetainSampler(
+            sampler);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
+    return sampler->dispatch->clRetainSampler(
+        sampler);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clRetainSampler_disp(
+    cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
     return sampler->dispatch->clRetainSampler(
         sampler);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clReleaseSampler(
     cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clReleaseSampler(
+            sampler);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
+    return sampler->dispatch->clReleaseSampler(
+        sampler);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseSampler_disp(
+    cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
     return sampler->dispatch->clReleaseSampler(
         sampler);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -321,6 +776,15 @@ CL_API_ENTRY cl_int CL_API_CALL clGetSamplerInfo(
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetSamplerInfo(
+            sampler,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
     return sampler->dispatch->clGetSamplerInfo(
         sampler,
@@ -331,10 +795,56 @@ CL_API_ENTRY cl_int CL_API_CALL clGetSamplerInfo(
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-
-CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithSource(
-    cl_context context,
-    cl_uint count,
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetSamplerInfo_disp(
+    cl_sampler sampler,
+    cl_sampler_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
+    return sampler->dispatch->clGetSamplerInfo(
+        sampler,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithSource(
+    cl_context context,
+    cl_uint count,
+    const char** strings,
+    const size_t* lengths,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateProgramWithSource(
+            context,
+            count,
+            strings,
+            lengths,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateProgramWithSource(
+        context,
+        count,
+        strings,
+        lengths,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithSource_disp(
+    cl_context context,
+    cl_uint count,
     const char** strings,
     const size_t* lengths,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
@@ -347,6 +857,7 @@ CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithSource(
         lengths,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -358,6 +869,39 @@ CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBinary(
     const unsigned char** binaries,
     cl_int* binary_status,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateProgramWithBinary(
+            context,
+            num_devices,
+            device_list,
+            lengths,
+            binaries,
+            binary_status,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateProgramWithBinary(
+        context,
+        num_devices,
+        device_list,
+        lengths,
+        binaries,
+        binary_status,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBinary_disp(
+    cl_context context,
+    cl_uint num_devices,
+    const cl_device_id* device_list,
+    const size_t* lengths,
+    const unsigned char** binaries,
+    cl_int* binary_status,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateProgramWithBinary(
@@ -369,27 +913,60 @@ CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBinary(
         binary_status,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clRetainProgram(
     cl_program program) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clRetainProgram(
+            program);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+    return program->dispatch->clRetainProgram(
+        program);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clRetainProgram_disp(
+    cl_program program) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
     return program->dispatch->clRetainProgram(
         program);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clReleaseProgram(
     cl_program program) CL_API_SUFFIX__VERSION_1_0
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clReleaseProgram(
+            program);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
     return program->dispatch->clReleaseProgram(
         program);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseProgram_disp(
+    cl_program program) CL_API_SUFFIX__VERSION_1_0
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+    return program->dispatch->clReleaseProgram(
+        program);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clBuildProgram(
@@ -399,6 +976,36 @@ CL_API_ENTRY cl_int CL_API_CALL clBuildProgram(
     const char* options,
     void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
     void* user_data) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clBuildProgram(
+            program,
+            num_devices,
+            device_list,
+            options,
+            pfn_notify,
+            user_data);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+    return program->dispatch->clBuildProgram(
+        program,
+        num_devices,
+        device_list,
+        options,
+        pfn_notify,
+        user_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clBuildProgram_disp(
+    cl_program program,
+    cl_uint num_devices,
+    const cl_device_id* device_list,
+    const char* options,
+    void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
+    void* user_data) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
     return program->dispatch->clBuildProgram(
@@ -409,6 +1016,7 @@ CL_API_ENTRY cl_int CL_API_CALL clBuildProgram(
         pfn_notify,
         user_data);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -418,6 +1026,33 @@ CL_API_ENTRY cl_int CL_API_CALL clGetProgramInfo(
     size_t param_value_size,
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetProgramInfo(
+            program,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+    return program->dispatch->clGetProgramInfo(
+        program,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetProgramInfo_disp(
+    cl_program program,
+    cl_program_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
     return program->dispatch->clGetProgramInfo(
@@ -427,6 +1062,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetProgramInfo(
         param_value,
         param_value_size_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -437,6 +1073,36 @@ CL_API_ENTRY cl_int CL_API_CALL clGetProgramBuildInfo(
     size_t param_value_size,
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetProgramBuildInfo(
+            program,
+            device,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+    return program->dispatch->clGetProgramBuildInfo(
+        program,
+        device,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetProgramBuildInfo_disp(
+    cl_program program,
+    cl_device_id device,
+    cl_program_build_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
     return program->dispatch->clGetProgramBuildInfo(
@@ -447,6 +1113,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetProgramBuildInfo(
         param_value,
         param_value_size_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -454,6 +1121,27 @@ CL_API_ENTRY cl_kernel CL_API_CALL clCreateKernel(
     cl_program program,
     const char* kernel_name,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateKernel(
+            program,
+            kernel_name,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(program, CL_INVALID_PROGRAM);
+    return program->dispatch->clCreateKernel(
+        program,
+        kernel_name,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_kernel CL_API_CALL clCreateKernel_disp(
+    cl_program program,
+    const char* kernel_name,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(program, CL_INVALID_PROGRAM);
     return program->dispatch->clCreateKernel(
@@ -461,6 +1149,7 @@ CL_API_ENTRY cl_kernel CL_API_CALL clCreateKernel(
         kernel_name,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -469,6 +1158,30 @@ CL_API_ENTRY cl_int CL_API_CALL clCreateKernelsInProgram(
     cl_uint num_kernels,
     cl_kernel* kernels,
     cl_uint* num_kernels_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateKernelsInProgram(
+            program,
+            num_kernels,
+            kernels,
+            num_kernels_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+    return program->dispatch->clCreateKernelsInProgram(
+        program,
+        num_kernels,
+        kernels,
+        num_kernels_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clCreateKernelsInProgram_disp(
+    cl_program program,
+    cl_uint num_kernels,
+    cl_kernel* kernels,
+    cl_uint* num_kernels_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
     return program->dispatch->clCreateKernelsInProgram(
@@ -477,26 +1190,59 @@ CL_API_ENTRY cl_int CL_API_CALL clCreateKernelsInProgram(
         kernels,
         num_kernels_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clRetainKernel(
     cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clRetainKernel(
+            kernel);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+    return kernel->dispatch->clRetainKernel(
+        kernel);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clRetainKernel_disp(
+    cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
     return kernel->dispatch->clRetainKernel(
         kernel);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clReleaseKernel(
     cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clReleaseKernel(
+            kernel);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+    return kernel->dispatch->clReleaseKernel(
+        kernel);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseKernel_disp(
+    cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
     return kernel->dispatch->clReleaseKernel(
         kernel);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -505,6 +1251,30 @@ CL_API_ENTRY cl_int CL_API_CALL clSetKernelArg(
     cl_uint arg_index,
     size_t arg_size,
     const void* arg_value) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clSetKernelArg(
+            kernel,
+            arg_index,
+            arg_size,
+            arg_value);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+    return kernel->dispatch->clSetKernelArg(
+        kernel,
+        arg_index,
+        arg_size,
+        arg_value);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clSetKernelArg_disp(
+    cl_kernel kernel,
+    cl_uint arg_index,
+    size_t arg_size,
+    const void* arg_value) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
     return kernel->dispatch->clSetKernelArg(
@@ -513,6 +1283,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetKernelArg(
         arg_size,
         arg_value);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -522,6 +1293,33 @@ CL_API_ENTRY cl_int CL_API_CALL clGetKernelInfo(
     size_t param_value_size,
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetKernelInfo(
+            kernel,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+    return kernel->dispatch->clGetKernelInfo(
+        kernel,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetKernelInfo_disp(
+    cl_kernel kernel,
+    cl_kernel_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
     return kernel->dispatch->clGetKernelInfo(
@@ -531,6 +1329,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetKernelInfo(
         param_value,
         param_value_size_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -541,6 +1340,36 @@ CL_API_ENTRY cl_int CL_API_CALL clGetKernelWorkGroupInfo(
     size_t param_value_size,
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetKernelWorkGroupInfo(
+            kernel,
+            device,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+    return kernel->dispatch->clGetKernelWorkGroupInfo(
+        kernel,
+        device,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetKernelWorkGroupInfo_disp(
+    cl_kernel kernel,
+    cl_device_id device,
+    cl_kernel_work_group_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
     return kernel->dispatch->clGetKernelWorkGroupInfo(
@@ -551,12 +1380,34 @@ CL_API_ENTRY cl_int CL_API_CALL clGetKernelWorkGroupInfo(
         param_value,
         param_value_size_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clWaitForEvents(
     cl_uint num_events,
     const cl_event* event_list) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clWaitForEvents(
+            num_events,
+            event_list);
+#endif // defined(CL_ENABLE_LAYERS)
+    if (num_events == 0 || event_list == NULL) {
+        return CL_INVALID_VALUE;
+    }
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event_list[0], CL_INVALID_EVENT);
+    return event_list[0]->dispatch->clWaitForEvents(
+        num_events,
+        event_list);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clWaitForEvents_disp(
+    cl_uint num_events,
+    const cl_event* event_list) CL_API_SUFFIX__VERSION_1_0
 {
     if (num_events == 0 || event_list == NULL) {
         return CL_INVALID_VALUE;
@@ -566,6 +1417,7 @@ CL_API_ENTRY cl_int CL_API_CALL clWaitForEvents(
         num_events,
         event_list);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -575,6 +1427,33 @@ CL_API_ENTRY cl_int CL_API_CALL clGetEventInfo(
     size_t param_value_size,
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetEventInfo(
+            event,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
+    return event->dispatch->clGetEventInfo(
+        event,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetEventInfo_disp(
+    cl_event event,
+    cl_event_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
     return event->dispatch->clGetEventInfo(
@@ -584,64 +1463,157 @@ CL_API_ENTRY cl_int CL_API_CALL clGetEventInfo(
         param_value,
         param_value_size_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clRetainEvent(
     cl_event event) CL_API_SUFFIX__VERSION_1_0
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clRetainEvent(
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
     return event->dispatch->clRetainEvent(
         event);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-
-CL_API_ENTRY cl_int CL_API_CALL clReleaseEvent(
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clRetainEvent_disp(
     cl_event event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
-    return event->dispatch->clReleaseEvent(
+    return event->dispatch->clRetainEvent(
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
-CL_API_ENTRY cl_int CL_API_CALL clGetEventProfilingInfo(
-    cl_event event,
-    cl_profiling_info param_name,
-    size_t param_value_size,
-    void* param_value,
-    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+CL_API_ENTRY cl_int CL_API_CALL clReleaseEvent(
+    cl_event event) CL_API_SUFFIX__VERSION_1_0
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clReleaseEvent(
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
-    return event->dispatch->clGetEventProfilingInfo(
+    return event->dispatch->clReleaseEvent(
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseEvent_disp(
+    cl_event event) CL_API_SUFFIX__VERSION_1_0
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
+    return event->dispatch->clReleaseEvent(
+        event);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clGetEventProfilingInfo(
+    cl_event event,
+    cl_profiling_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetEventProfilingInfo(
+            event,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
+    return event->dispatch->clGetEventProfilingInfo(
+        event,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetEventProfilingInfo_disp(
+    cl_event event,
+    cl_profiling_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
+    return event->dispatch->clGetEventProfilingInfo(
         event,
         param_name,
         param_value_size,
         param_value,
         param_value_size_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clFlush(
     cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clFlush(
+            command_queue);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clFlush(
+        command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clFlush_disp(
+    cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clFlush(
         command_queue);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clFinish(
     cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clFinish(
+            command_queue);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clFinish(
+        command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clFinish_disp(
+    cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clFinish(
         command_queue);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -655,6 +1627,45 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBuffer(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueReadBuffer(
+            command_queue,
+            buffer,
+            blocking_read,
+            offset,
+            size,
+            ptr,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueReadBuffer(
+        command_queue,
+        buffer,
+        blocking_read,
+        offset,
+        size,
+        ptr,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBuffer_disp(
+    cl_command_queue command_queue,
+    cl_mem buffer,
+    cl_bool blocking_read,
+    size_t offset,
+    size_t size,
+    void* ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueReadBuffer(
@@ -668,6 +1679,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBuffer(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -681,6 +1693,45 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBuffer(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueWriteBuffer(
+            command_queue,
+            buffer,
+            blocking_write,
+            offset,
+            size,
+            ptr,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueWriteBuffer(
+        command_queue,
+        buffer,
+        blocking_write,
+        offset,
+        size,
+        ptr,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBuffer_disp(
+    cl_command_queue command_queue,
+    cl_mem buffer,
+    cl_bool blocking_write,
+    size_t offset,
+    size_t size,
+    const void* ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueWriteBuffer(
@@ -694,6 +1745,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBuffer(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -707,6 +1759,45 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBuffer(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueCopyBuffer(
+            command_queue,
+            src_buffer,
+            dst_buffer,
+            src_offset,
+            dst_offset,
+            size,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueCopyBuffer(
+        command_queue,
+        src_buffer,
+        dst_buffer,
+        src_offset,
+        dst_offset,
+        size,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBuffer_disp(
+    cl_command_queue command_queue,
+    cl_mem src_buffer,
+    cl_mem dst_buffer,
+    size_t src_offset,
+    size_t dst_offset,
+    size_t size,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueCopyBuffer(
@@ -720,6 +1811,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBuffer(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -735,6 +1827,51 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadImage(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueReadImage(
+            command_queue,
+            image,
+            blocking_read,
+            origin,
+            region,
+            row_pitch,
+            slice_pitch,
+            ptr,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueReadImage(
+        command_queue,
+        image,
+        blocking_read,
+        origin,
+        region,
+        row_pitch,
+        slice_pitch,
+        ptr,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadImage_disp(
+    cl_command_queue command_queue,
+    cl_mem image,
+    cl_bool blocking_read,
+    const size_t* origin,
+    const size_t* region,
+    size_t row_pitch,
+    size_t slice_pitch,
+    void* ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueReadImage(
@@ -750,6 +1887,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadImage(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -765,6 +1903,51 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteImage(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueWriteImage(
+            command_queue,
+            image,
+            blocking_write,
+            origin,
+            region,
+            input_row_pitch,
+            input_slice_pitch,
+            ptr,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueWriteImage(
+        command_queue,
+        image,
+        blocking_write,
+        origin,
+        region,
+        input_row_pitch,
+        input_slice_pitch,
+        ptr,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteImage_disp(
+    cl_command_queue command_queue,
+    cl_mem image,
+    cl_bool blocking_write,
+    const size_t* origin,
+    const size_t* region,
+    size_t input_row_pitch,
+    size_t input_slice_pitch,
+    const void* ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueWriteImage(
@@ -780,6 +1963,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteImage(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -793,6 +1977,45 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImage(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueCopyImage(
+            command_queue,
+            src_image,
+            dst_image,
+            src_origin,
+            dst_origin,
+            region,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueCopyImage(
+        command_queue,
+        src_image,
+        dst_image,
+        src_origin,
+        dst_origin,
+        region,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImage_disp(
+    cl_command_queue command_queue,
+    cl_mem src_image,
+    cl_mem dst_image,
+    const size_t* src_origin,
+    const size_t* dst_origin,
+    const size_t* region,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueCopyImage(
@@ -806,6 +2029,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImage(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -819,6 +2043,45 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImageToBuffer(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueCopyImageToBuffer(
+            command_queue,
+            src_image,
+            dst_buffer,
+            src_origin,
+            region,
+            dst_offset,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueCopyImageToBuffer(
+        command_queue,
+        src_image,
+        dst_buffer,
+        src_origin,
+        region,
+        dst_offset,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImageToBuffer_disp(
+    cl_command_queue command_queue,
+    cl_mem src_image,
+    cl_mem dst_buffer,
+    const size_t* src_origin,
+    const size_t* region,
+    size_t dst_offset,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueCopyImageToBuffer(
@@ -832,6 +2095,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImageToBuffer(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -845,6 +2109,45 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferToImage(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueCopyBufferToImage(
+            command_queue,
+            src_buffer,
+            dst_image,
+            src_offset,
+            dst_origin,
+            region,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueCopyBufferToImage(
+        command_queue,
+        src_buffer,
+        dst_image,
+        src_offset,
+        dst_origin,
+        region,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferToImage_disp(
+    cl_command_queue command_queue,
+    cl_mem src_buffer,
+    cl_mem dst_image,
+    size_t src_offset,
+    const size_t* dst_origin,
+    const size_t* region,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueCopyBufferToImage(
@@ -858,6 +2161,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferToImage(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -873,6 +2177,20 @@ CL_API_ENTRY void* CL_API_CALL clEnqueueMapBuffer(
     cl_event* event,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueMapBuffer(
+            command_queue,
+            buffer,
+            blocking_map,
+            map_flags,
+            offset,
+            size,
+            num_events_in_wait_list,
+            event_wait_list,
+            event,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueMapBuffer(
         command_queue,
@@ -888,7 +2206,36 @@ CL_API_ENTRY void* CL_API_CALL clEnqueueMapBuffer(
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY void* CL_API_CALL clEnqueueMapBuffer_disp(
+    cl_command_queue command_queue,
+    cl_mem buffer,
+    cl_bool blocking_map,
+    cl_map_flags map_flags,
+    size_t offset,
+    size_t size,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueMapBuffer(
+        command_queue,
+        buffer,
+        blocking_map,
+        map_flags,
+        offset,
+        size,
+        num_events_in_wait_list,
+        event_wait_list,
+        event,
+        errcode_ret);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
+///////////////////////////////////////////////////////////////////////////////
+
 CL_API_ENTRY void* CL_API_CALL clEnqueueMapImage(
     cl_command_queue command_queue,
     cl_mem image,
@@ -902,6 +2249,54 @@ CL_API_ENTRY void* CL_API_CALL clEnqueueMapImage(
     const cl_event* event_wait_list,
     cl_event* event,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueMapImage(
+            command_queue,
+            image,
+            blocking_map,
+            map_flags,
+            origin,
+            region,
+            image_row_pitch,
+            image_slice_pitch,
+            num_events_in_wait_list,
+            event_wait_list,
+            event,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueMapImage(
+        command_queue,
+        image,
+        blocking_map,
+        map_flags,
+        origin,
+        region,
+        image_row_pitch,
+        image_slice_pitch,
+        num_events_in_wait_list,
+        event_wait_list,
+        event,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY void* CL_API_CALL clEnqueueMapImage_disp(
+    cl_command_queue command_queue,
+    cl_mem image,
+    cl_bool blocking_map,
+    cl_map_flags map_flags,
+    const size_t* origin,
+    const size_t* region,
+    size_t* image_row_pitch,
+    size_t* image_slice_pitch,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueMapImage(
@@ -918,6 +2313,7 @@ CL_API_ENTRY void* CL_API_CALL clEnqueueMapImage(
         event,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -928,6 +2324,36 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueUnmapMemObject(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueUnmapMemObject(
+            command_queue,
+            memobj,
+            mapped_ptr,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueUnmapMemObject(
+        command_queue,
+        memobj,
+        mapped_ptr,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueUnmapMemObject_disp(
+    cl_command_queue command_queue,
+    cl_mem memobj,
+    void* mapped_ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueUnmapMemObject(
@@ -938,6 +2364,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueUnmapMemObject(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -951,6 +2378,45 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueNDRangeKernel(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueNDRangeKernel(
+            command_queue,
+            kernel,
+            work_dim,
+            global_work_offset,
+            global_work_size,
+            local_work_size,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueNDRangeKernel(
+        command_queue,
+        kernel,
+        work_dim,
+        global_work_offset,
+        global_work_size,
+        local_work_size,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueNDRangeKernel_disp(
+    cl_command_queue command_queue,
+    cl_kernel kernel,
+    cl_uint work_dim,
+    const size_t* global_work_offset,
+    const size_t* global_work_size,
+    const size_t* local_work_size,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueNDRangeKernel(
@@ -964,6 +2430,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueNDRangeKernel(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -978,6 +2445,48 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueNativeKernel(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueNativeKernel(
+            command_queue,
+            user_func,
+            args,
+            cb_args,
+            num_mem_objects,
+            mem_list,
+            args_mem_loc,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueNativeKernel(
+        command_queue,
+        user_func,
+        args,
+        cb_args,
+        num_mem_objects,
+        mem_list,
+        args_mem_loc,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueNativeKernel_disp(
+    cl_command_queue command_queue,
+    void (CL_CALLBACK* user_func)(void*),
+    void* args,
+    size_t cb_args,
+    cl_uint num_mem_objects,
+    const cl_mem* mem_list,
+    const void** args_mem_loc,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueNativeKernel(
@@ -992,6 +2501,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueNativeKernel(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1000,6 +2510,30 @@ CL_API_ENTRY cl_int CL_API_CALL clSetCommandQueueProperty(
     cl_command_queue_properties properties,
     cl_bool enable,
     cl_command_queue_properties* old_properties) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clSetCommandQueueProperty(
+            command_queue,
+            properties,
+            enable,
+            old_properties);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clSetCommandQueueProperty(
+        command_queue,
+        properties,
+        enable,
+        old_properties);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clSetCommandQueueProperty_disp(
+    cl_command_queue command_queue,
+    cl_command_queue_properties properties,
+    cl_bool enable,
+    cl_command_queue_properties* old_properties) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clSetCommandQueueProperty(
@@ -1008,6 +2542,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetCommandQueueProperty(
         enable,
         old_properties);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1020,6 +2555,42 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateImage2D(
     size_t image_row_pitch,
     void* host_ptr,
     cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateImage2D(
+            context,
+            flags,
+            image_format,
+            image_width,
+            image_height,
+            image_row_pitch,
+            host_ptr,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateImage2D(
+        context,
+        flags,
+        image_format,
+        image_width,
+        image_height,
+        image_row_pitch,
+        host_ptr,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateImage2D_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    const cl_image_format* image_format,
+    size_t image_width,
+    size_t image_height,
+    size_t image_row_pitch,
+    void* host_ptr,
+    cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateImage2D(
@@ -1032,6 +2603,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateImage2D(
         host_ptr,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1046,6 +2618,48 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateImage3D(
     size_t image_slice_pitch,
     void* host_ptr,
     cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateImage3D(
+            context,
+            flags,
+            image_format,
+            image_width,
+            image_height,
+            image_depth,
+            image_row_pitch,
+            image_slice_pitch,
+            host_ptr,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateImage3D(
+        context,
+        flags,
+        image_format,
+        image_width,
+        image_height,
+        image_depth,
+        image_row_pitch,
+        image_slice_pitch,
+        host_ptr,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateImage3D_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    const cl_image_format* image_format,
+    size_t image_width,
+    size_t image_height,
+    size_t image_depth,
+    size_t image_row_pitch,
+    size_t image_slice_pitch,
+    void* host_ptr,
+    cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateImage3D(
@@ -1060,18 +2674,38 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateImage3D(
         host_ptr,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarker(
     cl_command_queue command_queue,
     cl_event* event) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueMarker(
+            command_queue,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueMarker(
+        command_queue,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarker_disp(
+    cl_command_queue command_queue,
+    cl_event* event) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueMarker(
         command_queue,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1079,6 +2713,27 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueWaitForEvents(
     cl_command_queue command_queue,
     cl_uint num_events,
     const cl_event* event_list) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueWaitForEvents(
+            command_queue,
+            num_events,
+            event_list);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueWaitForEvents(
+        command_queue,
+        num_events,
+        event_list);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWaitForEvents_disp(
+    cl_command_queue command_queue,
+    cl_uint num_events,
+    const cl_event* event_list) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueWaitForEvents(
@@ -1086,33 +2741,94 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueWaitForEvents(
         num_events,
         event_list);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrier(
     cl_command_queue command_queue) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueBarrier(
+            command_queue);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueBarrier(
+        command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrier_disp(
+    cl_command_queue command_queue) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueBarrier(
         command_queue);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clUnloadCompiler(
     void ) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clUnloadCompiler(
+            );
+#endif // defined(CL_ENABLE_LAYERS)
+    // Nothing!
+    return CL_SUCCESS;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clUnloadCompiler_disp(
+    void ) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
 {
     // Nothing!
     return CL_SUCCESS;
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+extern CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddress_disp(
+    const char* func_name) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED;
+#endif // defined(CL_ENABLE_LAYERS)
+
 
 CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueue(
     cl_context context,
     cl_device_id device,
     cl_command_queue_properties properties,
     cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_2_DEPRECATED
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateCommandQueue(
+            context,
+            device,
+            properties,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateCommandQueue(
+        context,
+        device,
+        properties,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueue_disp(
+    cl_context context,
+    cl_device_id device,
+    cl_command_queue_properties properties,
+    cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_2_DEPRECATED
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateCommandQueue(
@@ -1121,6 +2837,7 @@ CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueue(
         properties,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1130,6 +2847,33 @@ CL_API_ENTRY cl_sampler CL_API_CALL clCreateSampler(
     cl_addressing_mode addressing_mode,
     cl_filter_mode filter_mode,
     cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_2_DEPRECATED
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateSampler(
+            context,
+            normalized_coords,
+            addressing_mode,
+            filter_mode,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateSampler(
+        context,
+        normalized_coords,
+        addressing_mode,
+        filter_mode,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_sampler CL_API_CALL clCreateSampler_disp(
+    cl_context context,
+    cl_bool normalized_coords,
+    cl_addressing_mode addressing_mode,
+    cl_filter_mode filter_mode,
+    cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_2_DEPRECATED
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateSampler(
@@ -1139,6 +2883,7 @@ CL_API_ENTRY cl_sampler CL_API_CALL clCreateSampler(
         filter_mode,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1149,6 +2894,15 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueTask(
     const cl_event* event_wait_list,
     cl_event* event) CL_EXT_SUFFIX__VERSION_1_2_DEPRECATED
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueTask(
+            command_queue,
+            kernel,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueTask(
         command_queue,
@@ -1159,13 +2913,59 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueTask(
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueTask_disp(
+    cl_command_queue command_queue,
+    cl_kernel kernel,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_EXT_SUFFIX__VERSION_1_2_DEPRECATED
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueTask(
+        command_queue,
+        kernel,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
+///////////////////////////////////////////////////////////////////////////////
+
 CL_API_ENTRY cl_mem CL_API_CALL clCreateSubBuffer(
     cl_mem buffer,
     cl_mem_flags flags,
     cl_buffer_create_type buffer_create_type,
     const void* buffer_create_info,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateSubBuffer(
+            buffer,
+            flags,
+            buffer_create_type,
+            buffer_create_info,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(buffer, CL_INVALID_MEM_OBJECT);
+    return buffer->dispatch->clCreateSubBuffer(
+        buffer,
+        flags,
+        buffer_create_type,
+        buffer_create_info,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateSubBuffer_disp(
+    cl_mem buffer,
+    cl_mem_flags flags,
+    cl_buffer_create_type buffer_create_type,
+    const void* buffer_create_info,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(buffer, CL_INVALID_MEM_OBJECT);
     return buffer->dispatch->clCreateSubBuffer(
@@ -1175,6 +2975,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateSubBuffer(
         buffer_create_info,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1182,6 +2983,27 @@ CL_API_ENTRY cl_int CL_API_CALL clSetMemObjectDestructorCallback(
     cl_mem memobj,
     void (CL_CALLBACK* pfn_notify)(cl_mem memobj, void* user_data),
     void* user_data) CL_API_SUFFIX__VERSION_1_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clSetMemObjectDestructorCallback(
+            memobj,
+            pfn_notify,
+            user_data);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
+    return memobj->dispatch->clSetMemObjectDestructorCallback(
+        memobj,
+        pfn_notify,
+        user_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clSetMemObjectDestructorCallback_disp(
+    cl_mem memobj,
+    void (CL_CALLBACK* pfn_notify)(cl_mem memobj, void* user_data),
+    void* user_data) CL_API_SUFFIX__VERSION_1_1
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
     return memobj->dispatch->clSetMemObjectDestructorCallback(
@@ -1189,30 +3011,69 @@ CL_API_ENTRY cl_int CL_API_CALL clSetMemObjectDestructorCallback(
         pfn_notify,
         user_data);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_event CL_API_CALL clCreateUserEvent(
     cl_context context,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateUserEvent(
+            context,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateUserEvent(
+        context,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_event CL_API_CALL clCreateUserEvent_disp(
+    cl_context context,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateUserEvent(
         context,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clSetUserEventStatus(
     cl_event event,
     cl_int execution_status) CL_API_SUFFIX__VERSION_1_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clSetUserEventStatus(
+            event,
+            execution_status);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
+    return event->dispatch->clSetUserEventStatus(
+        event,
+        execution_status);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clSetUserEventStatus_disp(
+    cl_event event,
+    cl_int execution_status) CL_API_SUFFIX__VERSION_1_1
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
     return event->dispatch->clSetUserEventStatus(
         event,
         execution_status);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1221,6 +3082,30 @@ CL_API_ENTRY cl_int CL_API_CALL clSetEventCallback(
     cl_int command_exec_callback_type,
     void (CL_CALLBACK* pfn_notify)(cl_event event, cl_int event_command_status, void *user_data),
     void* user_data) CL_API_SUFFIX__VERSION_1_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clSetEventCallback(
+            event,
+            command_exec_callback_type,
+            pfn_notify,
+            user_data);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
+    return event->dispatch->clSetEventCallback(
+        event,
+        command_exec_callback_type,
+        pfn_notify,
+        user_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clSetEventCallback_disp(
+    cl_event event,
+    cl_int command_exec_callback_type,
+    void (CL_CALLBACK* pfn_notify)(cl_event event, cl_int event_command_status, void *user_data),
+    void* user_data) CL_API_SUFFIX__VERSION_1_1
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
     return event->dispatch->clSetEventCallback(
@@ -1229,6 +3114,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetEventCallback(
         pfn_notify,
         user_data);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1247,6 +3133,60 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBufferRect(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueReadBufferRect(
+            command_queue,
+            buffer,
+            blocking_read,
+            buffer_offset,
+            host_offset,
+            region,
+            buffer_row_pitch,
+            buffer_slice_pitch,
+            host_row_pitch,
+            host_slice_pitch,
+            ptr,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueReadBufferRect(
+        command_queue,
+        buffer,
+        blocking_read,
+        buffer_offset,
+        host_offset,
+        region,
+        buffer_row_pitch,
+        buffer_slice_pitch,
+        host_row_pitch,
+        host_slice_pitch,
+        ptr,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBufferRect_disp(
+    cl_command_queue command_queue,
+    cl_mem buffer,
+    cl_bool blocking_read,
+    const size_t* buffer_offset,
+    const size_t* host_offset,
+    const size_t* region,
+    size_t buffer_row_pitch,
+    size_t buffer_slice_pitch,
+    size_t host_row_pitch,
+    size_t host_slice_pitch,
+    void* ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_1
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueReadBufferRect(
@@ -1265,6 +3205,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBufferRect(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1283,6 +3224,60 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBufferRect(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueWriteBufferRect(
+            command_queue,
+            buffer,
+            blocking_write,
+            buffer_offset,
+            host_offset,
+            region,
+            buffer_row_pitch,
+            buffer_slice_pitch,
+            host_row_pitch,
+            host_slice_pitch,
+            ptr,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueWriteBufferRect(
+        command_queue,
+        buffer,
+        blocking_write,
+        buffer_offset,
+        host_offset,
+        region,
+        buffer_row_pitch,
+        buffer_slice_pitch,
+        host_row_pitch,
+        host_slice_pitch,
+        ptr,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBufferRect_disp(
+    cl_command_queue command_queue,
+    cl_mem buffer,
+    cl_bool blocking_write,
+    const size_t* buffer_offset,
+    const size_t* host_offset,
+    const size_t* region,
+    size_t buffer_row_pitch,
+    size_t buffer_slice_pitch,
+    size_t host_row_pitch,
+    size_t host_slice_pitch,
+    const void* ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_1
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueWriteBufferRect(
@@ -1301,6 +3296,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBufferRect(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1318,6 +3314,57 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferRect(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueCopyBufferRect(
+            command_queue,
+            src_buffer,
+            dst_buffer,
+            src_origin,
+            dst_origin,
+            region,
+            src_row_pitch,
+            src_slice_pitch,
+            dst_row_pitch,
+            dst_slice_pitch,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueCopyBufferRect(
+        command_queue,
+        src_buffer,
+        dst_buffer,
+        src_origin,
+        dst_origin,
+        region,
+        src_row_pitch,
+        src_slice_pitch,
+        dst_row_pitch,
+        dst_slice_pitch,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferRect_disp(
+    cl_command_queue command_queue,
+    cl_mem src_buffer,
+    cl_mem dst_buffer,
+    const size_t* src_origin,
+    const size_t* dst_origin,
+    const size_t* region,
+    size_t src_row_pitch,
+    size_t src_slice_pitch,
+    size_t dst_row_pitch,
+    size_t dst_slice_pitch,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_1
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueCopyBufferRect(
@@ -1335,6 +3382,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferRect(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1344,6 +3392,33 @@ CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevices(
     cl_uint num_devices,
     cl_device_id* out_devices,
     cl_uint* num_devices_ret) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateSubDevices(
+            in_device,
+            properties,
+            num_devices,
+            out_devices,
+            num_devices_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
+    return in_device->dispatch->clCreateSubDevices(
+        in_device,
+        properties,
+        num_devices,
+        out_devices,
+        num_devices_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevices_disp(
+    cl_device_id in_device,
+    const cl_device_partition_property* properties,
+    cl_uint num_devices,
+    cl_device_id* out_devices,
+    cl_uint* num_devices_ret) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
     return in_device->dispatch->clCreateSubDevices(
@@ -1353,26 +3428,59 @@ CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevices(
         out_devices,
         num_devices_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clRetainDevice(
     cl_device_id device) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clRetainDevice(
+            device);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
+    return device->dispatch->clRetainDevice(
+        device);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clRetainDevice_disp(
+    cl_device_id device) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
     return device->dispatch->clRetainDevice(
         device);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clReleaseDevice(
     cl_device_id device) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clReleaseDevice(
+            device);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
+    return device->dispatch->clReleaseDevice(
+        device);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseDevice_disp(
+    cl_device_id device) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
     return device->dispatch->clReleaseDevice(
         device);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1383,6 +3491,36 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateImage(
     const cl_image_desc* image_desc,
     void* host_ptr,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateImage(
+            context,
+            flags,
+            image_format,
+            image_desc,
+            host_ptr,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateImage(
+        context,
+        flags,
+        image_format,
+        image_desc,
+        host_ptr,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateImage_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    const cl_image_format* image_format,
+    const cl_image_desc* image_desc,
+    void* host_ptr,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateImage(
@@ -1393,6 +3531,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateImage(
         host_ptr,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1402,6 +3541,33 @@ CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBuiltInKernels(
     const cl_device_id* device_list,
     const char* kernel_names,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateProgramWithBuiltInKernels(
+            context,
+            num_devices,
+            device_list,
+            kernel_names,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateProgramWithBuiltInKernels(
+        context,
+        num_devices,
+        device_list,
+        kernel_names,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBuiltInKernels_disp(
+    cl_context context,
+    cl_uint num_devices,
+    const cl_device_id* device_list,
+    const char* kernel_names,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateProgramWithBuiltInKernels(
@@ -1411,6 +3577,7 @@ CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBuiltInKernels(
         kernel_names,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1425,6 +3592,19 @@ CL_API_ENTRY cl_int CL_API_CALL clCompileProgram(
     void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
     void* user_data) CL_API_SUFFIX__VERSION_1_2
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCompileProgram(
+            program,
+            num_devices,
+            device_list,
+            options,
+            num_input_headers,
+            input_headers,
+            header_include_names,
+            pfn_notify,
+            user_data);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
     return program->dispatch->clCompileProgram(
         program,
@@ -1439,17 +3619,83 @@ CL_API_ENTRY cl_int CL_API_CALL clCompileProgram(
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-
-CL_API_ENTRY cl_program CL_API_CALL clLinkProgram(
-    cl_context context,
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clCompileProgram_disp(
+    cl_program program,
     cl_uint num_devices,
     const cl_device_id* device_list,
     const char* options,
-    cl_uint num_input_programs,
-    const cl_program* input_programs,
+    cl_uint num_input_headers,
+    const cl_program* input_headers,
+    const char** header_include_names,
     void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
-    void* user_data,
-    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+    void* user_data) CL_API_SUFFIX__VERSION_1_2
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+    return program->dispatch->clCompileProgram(
+        program,
+        num_devices,
+        device_list,
+        options,
+        num_input_headers,
+        input_headers,
+        header_include_names,
+        pfn_notify,
+        user_data);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_program CL_API_CALL clLinkProgram(
+    cl_context context,
+    cl_uint num_devices,
+    const cl_device_id* device_list,
+    const char* options,
+    cl_uint num_input_programs,
+    const cl_program* input_programs,
+    void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
+    void* user_data,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clLinkProgram(
+            context,
+            num_devices,
+            device_list,
+            options,
+            num_input_programs,
+            input_programs,
+            pfn_notify,
+            user_data,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clLinkProgram(
+        context,
+        num_devices,
+        device_list,
+        options,
+        num_input_programs,
+        input_programs,
+        pfn_notify,
+        user_data,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_program CL_API_CALL clLinkProgram_disp(
+    cl_context context,
+    cl_uint num_devices,
+    const cl_device_id* device_list,
+    const char* options,
+    cl_uint num_input_programs,
+    const cl_program* input_programs,
+    void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
+    void* user_data,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clLinkProgram(
@@ -1463,16 +3709,33 @@ CL_API_ENTRY cl_program CL_API_CALL clLinkProgram(
         user_data,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clUnloadPlatformCompiler(
     cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clUnloadPlatformCompiler(
+            platform);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
+    return platform->dispatch->clUnloadPlatformCompiler(
+        platform);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clUnloadPlatformCompiler_disp(
+    cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
     return platform->dispatch->clUnloadPlatformCompiler(
         platform);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1484,6 +3747,16 @@ CL_API_ENTRY cl_int CL_API_CALL clGetKernelArgInfo(
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_2
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetKernelArgInfo(
+            kernel,
+            arg_index,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
     return kernel->dispatch->clGetKernelArgInfo(
         kernel,
@@ -1494,6 +3767,27 @@ CL_API_ENTRY cl_int CL_API_CALL clGetKernelArgInfo(
         param_value_size_ret);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetKernelArgInfo_disp(
+    cl_kernel kernel,
+    cl_uint arg_index,
+    cl_kernel_arg_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_2
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+    return kernel->dispatch->clGetKernelArgInfo(
+        kernel,
+        arg_index,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillBuffer(
@@ -1506,6 +3800,45 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillBuffer(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueFillBuffer(
+            command_queue,
+            buffer,
+            pattern,
+            pattern_size,
+            offset,
+            size,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueFillBuffer(
+        command_queue,
+        buffer,
+        pattern,
+        pattern_size,
+        offset,
+        size,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillBuffer_disp(
+    cl_command_queue command_queue,
+    cl_mem buffer,
+    const void* pattern,
+    size_t pattern_size,
+    size_t offset,
+    size_t size,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueFillBuffer(
@@ -1519,6 +3852,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillBuffer(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1532,6 +3866,18 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillImage(
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_2
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueFillImage(
+            command_queue,
+            image,
+            fill_color,
+            origin,
+            region,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueFillImage(
         command_queue,
@@ -1544,6 +3890,31 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillImage(
         event);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillImage_disp(
+    cl_command_queue command_queue,
+    cl_mem image,
+    const void* fill_color,
+    const size_t* origin,
+    const size_t* region,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueFillImage(
+        command_queue,
+        image,
+        fill_color,
+        origin,
+        region,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemObjects(
@@ -1554,6 +3925,39 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemObjects(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueMigrateMemObjects(
+            command_queue,
+            num_mem_objects,
+            mem_objects,
+            flags,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueMigrateMemObjects(
+        command_queue,
+        num_mem_objects,
+        mem_objects,
+        flags,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemObjects_disp(
+    cl_command_queue command_queue,
+    cl_uint num_mem_objects,
+    const cl_mem* mem_objects,
+    cl_mem_migration_flags flags,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueMigrateMemObjects(
@@ -1565,6 +3969,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemObjects(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1573,6 +3978,30 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarkerWithWaitList(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueMarkerWithWaitList(
+            command_queue,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueMarkerWithWaitList(
+        command_queue,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarkerWithWaitList_disp(
+    cl_command_queue command_queue,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueMarkerWithWaitList(
@@ -1581,6 +4010,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarkerWithWaitList(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1590,6 +4020,14 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrierWithWaitList(
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_2
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueBarrierWithWaitList(
+            command_queue,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueBarrierWithWaitList(
         command_queue,
@@ -1599,6 +4037,29 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrierWithWaitList(
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrierWithWaitList_disp(
+    cl_command_queue command_queue,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueBarrierWithWaitList(
+        command_queue,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+extern CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddressForPlatform_disp(
+    cl_platform_id platform,
+    const char* func_name) CL_API_SUFFIX__VERSION_1_2;
+#endif // defined(CL_ENABLE_LAYERS)
+
 
 CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(
     cl_context context,
@@ -1606,6 +4067,14 @@ CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(
     const cl_queue_properties* properties,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateCommandQueueWithProperties(
+            context,
+            device,
+            properties,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateCommandQueueWithProperties(
         context,
@@ -1614,6 +4083,23 @@ CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(
         errcode_ret);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties_disp(
+    cl_context context,
+    cl_device_id device,
+    const cl_queue_properties* properties,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateCommandQueueWithProperties(
+        context,
+        device,
+        properties,
+        errcode_ret);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_mem CL_API_CALL clCreatePipe(
@@ -1624,6 +4110,16 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreatePipe(
     const cl_pipe_properties* properties,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreatePipe(
+            context,
+            flags,
+            pipe_packet_size,
+            pipe_max_packets,
+            properties,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreatePipe(
         context,
@@ -1634,6 +4130,27 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreatePipe(
         errcode_ret);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreatePipe_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    cl_uint pipe_packet_size,
+    cl_uint pipe_max_packets,
+    const cl_pipe_properties* properties,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreatePipe(
+        context,
+        flags,
+        pipe_packet_size,
+        pipe_max_packets,
+        properties,
+        errcode_ret);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clGetPipeInfo(
@@ -1643,6 +4160,15 @@ CL_API_ENTRY cl_int CL_API_CALL clGetPipeInfo(
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_2_0
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetPipeInfo(
+            pipe,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(pipe, CL_INVALID_MEM_OBJECT);
     return pipe->dispatch->clGetPipeInfo(
         pipe,
@@ -1652,6 +4178,25 @@ CL_API_ENTRY cl_int CL_API_CALL clGetPipeInfo(
         param_value_size_ret);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetPipeInfo_disp(
+    cl_mem pipe,
+    cl_pipe_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_2_0
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(pipe, CL_INVALID_MEM_OBJECT);
+    return pipe->dispatch->clGetPipeInfo(
+        pipe,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY void* CL_API_CALL clSVMAlloc(
@@ -1659,6 +4204,30 @@ CL_API_ENTRY void* CL_API_CALL clSVMAlloc(
     cl_svm_mem_flags flags,
     size_t size,
     cl_uint alignment) CL_API_SUFFIX__VERSION_2_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clSVMAlloc(
+            context,
+            flags,
+            size,
+            alignment);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, NULL);
+    return context->dispatch->clSVMAlloc(
+        context,
+        flags,
+        size,
+        alignment);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY void* CL_API_CALL clSVMAlloc_disp(
+    cl_context context,
+    cl_svm_mem_flags flags,
+    size_t size,
+    cl_uint alignment) CL_API_SUFFIX__VERSION_2_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, NULL);
     return context->dispatch->clSVMAlloc(
@@ -1667,6 +4236,7 @@ CL_API_ENTRY void* CL_API_CALL clSVMAlloc(
         size,
         alignment);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1674,18 +4244,58 @@ CL_API_ENTRY void CL_API_CALL clSVMFree(
     cl_context context,
     void* svm_pointer) CL_API_SUFFIX__VERSION_2_0
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clSVMFree(
+            context,
+            svm_pointer);
+#endif // defined(CL_ENABLE_LAYERS)
     if (context == NULL) return;
     context->dispatch->clSVMFree(
         context,
         svm_pointer);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY void CL_API_CALL clSVMFree_disp(
+    cl_context context,
+    void* svm_pointer) CL_API_SUFFIX__VERSION_2_0
+{
+    if (context == NULL) return;
+    context->dispatch->clSVMFree(
+        context,
+        svm_pointer);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_sampler CL_API_CALL clCreateSamplerWithProperties(
     cl_context context,
     const cl_sampler_properties* sampler_properties,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateSamplerWithProperties(
+            context,
+            sampler_properties,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateSamplerWithProperties(
+        context,
+        sampler_properties,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_sampler CL_API_CALL clCreateSamplerWithProperties_disp(
+    cl_context context,
+    const cl_sampler_properties* sampler_properties,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateSamplerWithProperties(
@@ -1693,6 +4303,7 @@ CL_API_ENTRY cl_sampler CL_API_CALL clCreateSamplerWithProperties(
         sampler_properties,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1701,6 +4312,13 @@ CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgSVMPointer(
     cl_uint arg_index,
     const void* arg_value) CL_API_SUFFIX__VERSION_2_0
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clSetKernelArgSVMPointer(
+            kernel,
+            arg_index,
+            arg_value);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
     return kernel->dispatch->clSetKernelArgSVMPointer(
         kernel,
@@ -1708,6 +4326,21 @@ CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgSVMPointer(
         arg_value);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgSVMPointer_disp(
+    cl_kernel kernel,
+    cl_uint arg_index,
+    const void* arg_value) CL_API_SUFFIX__VERSION_2_0
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+    return kernel->dispatch->clSetKernelArgSVMPointer(
+        kernel,
+        arg_index,
+        arg_value);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clSetKernelExecInfo(
@@ -1716,6 +4349,14 @@ CL_API_ENTRY cl_int CL_API_CALL clSetKernelExecInfo(
     size_t param_value_size,
     const void* param_value) CL_API_SUFFIX__VERSION_2_0
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clSetKernelExecInfo(
+            kernel,
+            param_name,
+            param_value_size,
+            param_value);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
     return kernel->dispatch->clSetKernelExecInfo(
         kernel,
@@ -1724,6 +4365,23 @@ CL_API_ENTRY cl_int CL_API_CALL clSetKernelExecInfo(
         param_value);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clSetKernelExecInfo_disp(
+    cl_kernel kernel,
+    cl_kernel_exec_info param_name,
+    size_t param_value_size,
+    const void* param_value) CL_API_SUFFIX__VERSION_2_0
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+    return kernel->dispatch->clSetKernelExecInfo(
+        kernel,
+        param_name,
+        param_value_size,
+        param_value);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMFree(
@@ -1735,61 +4393,208 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMFree(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_2_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueSVMFree(
+            command_queue,
+            num_svm_pointers,
+            svm_pointers,
+            pfn_free_func,
+            user_data,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueSVMFree(
+        command_queue,
+        num_svm_pointers,
+        svm_pointers,
+        pfn_free_func,
+        user_data,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMFree_disp(
+    cl_command_queue command_queue,
+    cl_uint num_svm_pointers,
+    void* svm_pointers[],
+    void (CL_CALLBACK* pfn_free_func)(cl_command_queue queue, cl_uint num_svm_pointers, void* svm_pointers[], void* user_data),
+    void* user_data,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_2_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueSVMFree(
         command_queue,
-        num_svm_pointers,
-        svm_pointers,
-        pfn_free_func,
-        user_data,
+        num_svm_pointers,
+        svm_pointers,
+        pfn_free_func,
+        user_data,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemcpy(
+    cl_command_queue command_queue,
+    cl_bool blocking_copy,
+    void* dst_ptr,
+    const void* src_ptr,
+    size_t size,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_2_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueSVMMemcpy(
+            command_queue,
+            blocking_copy,
+            dst_ptr,
+            src_ptr,
+            size,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueSVMMemcpy(
+        command_queue,
+        blocking_copy,
+        dst_ptr,
+        src_ptr,
+        size,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemcpy_disp(
+    cl_command_queue command_queue,
+    cl_bool blocking_copy,
+    void* dst_ptr,
+    const void* src_ptr,
+    size_t size,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_2_0
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueSVMMemcpy(
+        command_queue,
+        blocking_copy,
+        dst_ptr,
+        src_ptr,
+        size,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
+///////////////////////////////////////////////////////////////////////////////
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemFill(
+    cl_command_queue command_queue,
+    void* svm_ptr,
+    const void* pattern,
+    size_t pattern_size,
+    size_t size,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_2_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueSVMMemFill(
+            command_queue,
+            svm_ptr,
+            pattern,
+            pattern_size,
+            size,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueSVMMemFill(
+        command_queue,
+        svm_ptr,
+        pattern,
+        pattern_size,
+        size,
         num_events_in_wait_list,
         event_wait_list,
         event);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-
-CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemcpy(
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemFill_disp(
     cl_command_queue command_queue,
-    cl_bool blocking_copy,
-    void* dst_ptr,
-    const void* src_ptr,
+    void* svm_ptr,
+    const void* pattern,
+    size_t pattern_size,
     size_t size,
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_2_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
-    return command_queue->dispatch->clEnqueueSVMMemcpy(
+    return command_queue->dispatch->clEnqueueSVMMemFill(
         command_queue,
-        blocking_copy,
-        dst_ptr,
-        src_ptr,
+        svm_ptr,
+        pattern,
+        pattern_size,
         size,
         num_events_in_wait_list,
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
-CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemFill(
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMap(
     cl_command_queue command_queue,
+    cl_bool blocking_map,
+    cl_map_flags flags,
     void* svm_ptr,
-    const void* pattern,
-    size_t pattern_size,
     size_t size,
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_2_0
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueSVMMap(
+            command_queue,
+            blocking_map,
+            flags,
+            svm_ptr,
+            size,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
-    return command_queue->dispatch->clEnqueueSVMMemFill(
+    return command_queue->dispatch->clEnqueueSVMMap(
         command_queue,
+        blocking_map,
+        flags,
         svm_ptr,
-        pattern,
-        pattern_size,
         size,
         num_events_in_wait_list,
         event_wait_list,
@@ -1797,8 +4602,8 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemFill(
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-
-CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMap(
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMap_disp(
     cl_command_queue command_queue,
     cl_bool blocking_map,
     cl_map_flags flags,
@@ -1819,6 +4624,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMap(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1828,6 +4634,33 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMUnmap(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_2_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueSVMUnmap(
+            command_queue,
+            svm_ptr,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueSVMUnmap(
+        command_queue,
+        svm_ptr,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMUnmap_disp(
+    cl_command_queue command_queue,
+    void* svm_ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_2_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueSVMUnmap(
@@ -1837,6 +4670,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMUnmap(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1844,6 +4678,27 @@ CL_API_ENTRY cl_int CL_API_CALL clSetDefaultDeviceCommandQueue(
     cl_context context,
     cl_device_id device,
     cl_command_queue command_queue) CL_API_SUFFIX__VERSION_2_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clSetDefaultDeviceCommandQueue(
+            context,
+            device,
+            command_queue);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clSetDefaultDeviceCommandQueue(
+        context,
+        device,
+        command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clSetDefaultDeviceCommandQueue_disp(
+    cl_context context,
+    cl_device_id device,
+    cl_command_queue command_queue) CL_API_SUFFIX__VERSION_2_1
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
     return context->dispatch->clSetDefaultDeviceCommandQueue(
@@ -1851,6 +4706,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetDefaultDeviceCommandQueue(
         device,
         command_queue);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1858,6 +4714,27 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceAndHostTimer(
     cl_device_id device,
     cl_ulong* device_timestamp,
     cl_ulong* host_timestamp) CL_API_SUFFIX__VERSION_2_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetDeviceAndHostTimer(
+            device,
+            device_timestamp,
+            host_timestamp);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
+    return device->dispatch->clGetDeviceAndHostTimer(
+        device,
+        device_timestamp,
+        host_timestamp);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceAndHostTimer_disp(
+    cl_device_id device,
+    cl_ulong* device_timestamp,
+    cl_ulong* host_timestamp) CL_API_SUFFIX__VERSION_2_1
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
     return device->dispatch->clGetDeviceAndHostTimer(
@@ -1865,18 +4742,38 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceAndHostTimer(
         device_timestamp,
         host_timestamp);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_int CL_API_CALL clGetHostTimer(
     cl_device_id device,
     cl_ulong* host_timestamp) CL_API_SUFFIX__VERSION_2_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetHostTimer(
+            device,
+            host_timestamp);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
+    return device->dispatch->clGetHostTimer(
+        device,
+        host_timestamp);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetHostTimer_disp(
+    cl_device_id device,
+    cl_ulong* host_timestamp) CL_API_SUFFIX__VERSION_2_1
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
     return device->dispatch->clGetHostTimer(
         device,
         host_timestamp);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1885,6 +4782,30 @@ CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithIL(
     const void* il,
     size_t length,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateProgramWithIL(
+            context,
+            il,
+            length,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateProgramWithIL(
+        context,
+        il,
+        length,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithIL_disp(
+    cl_context context,
+    const void* il,
+    size_t length,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateProgramWithIL(
@@ -1893,18 +4814,38 @@ CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithIL(
         length,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 CL_API_ENTRY cl_kernel CL_API_CALL clCloneKernel(
     cl_kernel source_kernel,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCloneKernel(
+            source_kernel,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(source_kernel, CL_INVALID_KERNEL);
+    return source_kernel->dispatch->clCloneKernel(
+        source_kernel,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_kernel CL_API_CALL clCloneKernel_disp(
+    cl_kernel source_kernel,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(source_kernel, CL_INVALID_KERNEL);
     return source_kernel->dispatch->clCloneKernel(
         source_kernel,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1917,6 +4858,42 @@ CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfo(
     size_t param_value_size,
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_2_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetKernelSubGroupInfo(
+            kernel,
+            device,
+            param_name,
+            input_value_size,
+            input_value,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
+    return kernel->dispatch->clGetKernelSubGroupInfo(
+        kernel,
+        device,
+        param_name,
+        input_value_size,
+        input_value,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfo_disp(
+    cl_kernel kernel,
+    cl_device_id device,
+    cl_kernel_sub_group_info param_name,
+    size_t input_value_size,
+    const void* input_value,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_2_1
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
     return kernel->dispatch->clGetKernelSubGroupInfo(
@@ -1929,6 +4906,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfo(
         param_value,
         param_value_size_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1941,6 +4919,42 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMigrateMem(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_2_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueSVMMigrateMem(
+            command_queue,
+            num_svm_pointers,
+            svm_pointers,
+            sizes,
+            flags,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueSVMMigrateMem(
+        command_queue,
+        num_svm_pointers,
+        svm_pointers,
+        sizes,
+        flags,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMigrateMem_disp(
+    cl_command_queue command_queue,
+    cl_uint num_svm_pointers,
+    const void** svm_pointers,
+    const size_t* sizes,
+    cl_mem_migration_flags flags,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_2_1
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueSVMMigrateMem(
@@ -1953,6 +4967,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMigrateMem(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1961,6 +4976,30 @@ CL_API_ENTRY cl_int CL_API_CALL clSetProgramSpecializationConstant(
     cl_uint spec_id,
     size_t spec_size,
     const void* spec_value) CL_API_SUFFIX__VERSION_2_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clSetProgramSpecializationConstant(
+            program,
+            spec_id,
+            spec_size,
+            spec_value);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+    return program->dispatch->clSetProgramSpecializationConstant(
+        program,
+        spec_id,
+        spec_size,
+        spec_value);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clSetProgramSpecializationConstant_disp(
+    cl_program program,
+    cl_uint spec_id,
+    size_t spec_size,
+    const void* spec_value) CL_API_SUFFIX__VERSION_2_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
     return program->dispatch->clSetProgramSpecializationConstant(
@@ -1969,6 +5008,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetProgramSpecializationConstant(
         spec_size,
         spec_value);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1976,6 +5016,27 @@ CL_API_ENTRY cl_int CL_API_CALL clSetProgramReleaseCallback(
     cl_program program,
     void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
     void* user_data) CL_EXT_SUFFIX__VERSION_2_2_DEPRECATED
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clSetProgramReleaseCallback(
+            program,
+            pfn_notify,
+            user_data);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
+    return program->dispatch->clSetProgramReleaseCallback(
+        program,
+        pfn_notify,
+        user_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clSetProgramReleaseCallback_disp(
+    cl_program program,
+    void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
+    void* user_data) CL_EXT_SUFFIX__VERSION_2_2_DEPRECATED
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
     return program->dispatch->clSetProgramReleaseCallback(
@@ -1983,6 +5044,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetProgramReleaseCallback(
         pfn_notify,
         user_data);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1990,6 +5052,27 @@ CL_API_ENTRY cl_int CL_API_CALL clSetContextDestructorCallback(
     cl_context context,
     void (CL_CALLBACK* pfn_notify)(cl_context context, void* user_data),
     void* user_data) CL_API_SUFFIX__VERSION_3_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clSetContextDestructorCallback(
+            context,
+            pfn_notify,
+            user_data);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clSetContextDestructorCallback(
+        context,
+        pfn_notify,
+        user_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clSetContextDestructorCallback_disp(
+    cl_context context,
+    void (CL_CALLBACK* pfn_notify)(cl_context context, void* user_data),
+    void* user_data) CL_API_SUFFIX__VERSION_3_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
     return context->dispatch->clSetContextDestructorCallback(
@@ -1997,6 +5080,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetContextDestructorCallback(
         pfn_notify,
         user_data);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -2007,6 +5091,36 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateBufferWithProperties(
     size_t size,
     void* host_ptr,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_3_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateBufferWithProperties(
+            context,
+            properties,
+            flags,
+            size,
+            host_ptr,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateBufferWithProperties(
+        context,
+        properties,
+        flags,
+        size,
+        host_ptr,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateBufferWithProperties_disp(
+    cl_context context,
+    const cl_mem_properties* properties,
+    cl_mem_flags flags,
+    size_t size,
+    void* host_ptr,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_3_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateBufferWithProperties(
@@ -2017,6 +5131,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateBufferWithProperties(
         host_ptr,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -2028,6 +5143,39 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateImageWithProperties(
     const cl_image_desc* image_desc,
     void* host_ptr,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_3_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateImageWithProperties(
+            context,
+            properties,
+            flags,
+            image_format,
+            image_desc,
+            host_ptr,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateImageWithProperties(
+        context,
+        properties,
+        flags,
+        image_format,
+        image_desc,
+        host_ptr,
+        errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateImageWithProperties_disp(
+    cl_context context,
+    const cl_mem_properties* properties,
+    cl_mem_flags flags,
+    const cl_image_format* image_format,
+    const cl_image_desc* image_desc,
+    void* host_ptr,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_3_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateImageWithProperties(
@@ -2039,6 +5187,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateImageWithProperties(
         host_ptr,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -2047,20 +5196,73 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateImageWithProperties(
 CL_API_ENTRY cl_int CL_API_CALL clReleaseDeviceEXT(
     cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clReleaseDeviceEXT(
+            device);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
     return device->dispatch->clReleaseDeviceEXT(
         device);
 }
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseDeviceEXT_disp(
+    cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
+    return device->dispatch->clReleaseDeviceEXT(
+        device);
+}
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_int CL_API_CALL clRetainDeviceEXT(
     cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1
 {
-    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
-    return device->dispatch->clRetainDeviceEXT(
-        device);
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clRetainDeviceEXT(
+            device);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
+    return device->dispatch->clRetainDeviceEXT(
+        device);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clRetainDeviceEXT_disp(
+    cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
+    return device->dispatch->clRetainDeviceEXT(
+        device);
+}
+#endif // defined(CL_ENABLE_LAYERS)
+
+CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevicesEXT(
+    cl_device_id in_device,
+    const cl_device_partition_property_ext* properties,
+    cl_uint num_entries,
+    cl_device_id* out_devices,
+    cl_uint* num_devices) CL_EXT_SUFFIX__VERSION_1_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateSubDevicesEXT(
+            in_device,
+            properties,
+            num_entries,
+            out_devices,
+            num_devices);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
+    return in_device->dispatch->clCreateSubDevicesEXT(
+        in_device,
+        properties,
+        num_entries,
+        out_devices,
+        num_devices);
 }
-
-CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevicesEXT(
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevicesEXT_disp(
     cl_device_id in_device,
     const cl_device_partition_property_ext* properties,
     cl_uint num_entries,
@@ -2075,6 +5277,7 @@ CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevicesEXT(
         out_devices,
         num_devices);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -2090,6 +5293,37 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR(
     cl_uint num_entries,
     cl_device_id* devices,
     cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetDeviceIDsFromD3D10KHR(
+            platform,
+            d3d_device_source,
+            d3d_object,
+            d3d_device_set,
+            num_entries,
+            devices,
+            num_devices);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
+    return platform->dispatch->clGetDeviceIDsFromD3D10KHR(
+        platform,
+        d3d_device_source,
+        d3d_object,
+        d3d_device_set,
+        num_entries,
+        devices,
+        num_devices);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR_disp(
+    cl_platform_id platform,
+    cl_d3d10_device_source_khr d3d_device_source,
+    void* d3d_object,
+    cl_d3d10_device_set_khr d3d_device_set,
+    cl_uint num_entries,
+    cl_device_id* devices,
+    cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
     return platform->dispatch->clGetDeviceIDsFromD3D10KHR(
@@ -2101,12 +5335,35 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR(
         devices,
         num_devices);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10BufferKHR(
     cl_context context,
     cl_mem_flags flags,
     ID3D10Buffer* resource,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateFromD3D10BufferKHR(
+            context,
+            flags,
+            resource,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateFromD3D10BufferKHR(
+        context,
+        flags,
+        resource,
+        errcode_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10BufferKHR_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    ID3D10Buffer* resource,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateFromD3D10BufferKHR(
@@ -2115,6 +5372,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10BufferKHR(
         resource,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR(
     cl_context context,
@@ -2122,6 +5380,31 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR(
     ID3D10Texture2D* resource,
     UINT subresource,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateFromD3D10Texture2DKHR(
+            context,
+            flags,
+            resource,
+            subresource,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateFromD3D10Texture2DKHR(
+        context,
+        flags,
+        resource,
+        subresource,
+        errcode_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    ID3D10Texture2D* resource,
+    UINT subresource,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateFromD3D10Texture2DKHR(
@@ -2131,6 +5414,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR(
         subresource,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR(
     cl_context context,
@@ -2138,6 +5422,31 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR(
     ID3D10Texture3D* resource,
     UINT subresource,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateFromD3D10Texture3DKHR(
+            context,
+            flags,
+            resource,
+            subresource,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateFromD3D10Texture3DKHR(
+        context,
+        flags,
+        resource,
+        subresource,
+        errcode_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    ID3D10Texture3D* resource,
+    UINT subresource,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateFromD3D10Texture3DKHR(
@@ -2147,6 +5456,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR(
         subresource,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR(
     cl_command_queue command_queue,
@@ -2155,6 +5465,34 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueAcquireD3D10ObjectsKHR(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueAcquireD3D10ObjectsKHR(
+        command_queue,
+        num_objects,
+        mem_objects,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR_disp(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueAcquireD3D10ObjectsKHR(
@@ -2165,6 +5503,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR(
     cl_command_queue command_queue,
@@ -2173,6 +5512,34 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueReleaseD3D10ObjectsKHR(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueReleaseD3D10ObjectsKHR(
+        command_queue,
+        num_objects,
+        mem_objects,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR_disp(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueReleaseD3D10ObjectsKHR(
@@ -2183,6 +5550,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 #endif // defined(_WIN32)
 
@@ -2200,6 +5568,37 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR(
     cl_uint num_entries,
     cl_device_id* devices,
     cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetDeviceIDsFromD3D11KHR(
+            platform,
+            d3d_device_source,
+            d3d_object,
+            d3d_device_set,
+            num_entries,
+            devices,
+            num_devices);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
+    return platform->dispatch->clGetDeviceIDsFromD3D11KHR(
+        platform,
+        d3d_device_source,
+        d3d_object,
+        d3d_device_set,
+        num_entries,
+        devices,
+        num_devices);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR_disp(
+    cl_platform_id platform,
+    cl_d3d11_device_source_khr d3d_device_source,
+    void* d3d_object,
+    cl_d3d11_device_set_khr d3d_device_set,
+    cl_uint num_entries,
+    cl_device_id* devices,
+    cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
     return platform->dispatch->clGetDeviceIDsFromD3D11KHR(
@@ -2211,12 +5610,35 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR(
         devices,
         num_devices);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11BufferKHR(
     cl_context context,
     cl_mem_flags flags,
     ID3D11Buffer* resource,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateFromD3D11BufferKHR(
+            context,
+            flags,
+            resource,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateFromD3D11BufferKHR(
+        context,
+        flags,
+        resource,
+        errcode_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11BufferKHR_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    ID3D11Buffer* resource,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateFromD3D11BufferKHR(
@@ -2225,6 +5647,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11BufferKHR(
         resource,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR(
     cl_context context,
@@ -2232,6 +5655,31 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR(
     ID3D11Texture2D* resource,
     UINT subresource,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateFromD3D11Texture2DKHR(
+            context,
+            flags,
+            resource,
+            subresource,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateFromD3D11Texture2DKHR(
+        context,
+        flags,
+        resource,
+        subresource,
+        errcode_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    ID3D11Texture2D* resource,
+    UINT subresource,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateFromD3D11Texture2DKHR(
@@ -2241,6 +5689,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR(
         subresource,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR(
     cl_context context,
@@ -2248,6 +5697,31 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR(
     ID3D11Texture3D* resource,
     UINT subresource,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateFromD3D11Texture3DKHR(
+            context,
+            flags,
+            resource,
+            subresource,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateFromD3D11Texture3DKHR(
+        context,
+        flags,
+        resource,
+        subresource,
+        errcode_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    ID3D11Texture3D* resource,
+    UINT subresource,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateFromD3D11Texture3DKHR(
@@ -2257,6 +5731,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR(
         subresource,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR(
     cl_command_queue command_queue,
@@ -2266,6 +5741,16 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR(
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_2
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueAcquireD3D11ObjectsKHR(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueAcquireD3D11ObjectsKHR(
         command_queue,
@@ -2275,6 +5760,25 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR(
         event_wait_list,
         event);
 }
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR_disp(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueAcquireD3D11ObjectsKHR(
+        command_queue,
+        num_objects,
+        mem_objects,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR(
     cl_command_queue command_queue,
@@ -2283,6 +5787,34 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueReleaseD3D11ObjectsKHR(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueReleaseD3D11ObjectsKHR(
+        command_queue,
+        num_objects,
+        mem_objects,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR_disp(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueReleaseD3D11ObjectsKHR(
@@ -2293,6 +5825,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 #endif // defined(_WIN32)
 
@@ -2312,6 +5845,18 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR(
     cl_device_id* devices,
     cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetDeviceIDsFromDX9MediaAdapterKHR(
+            platform,
+            num_media_adapters,
+            media_adapter_type,
+            media_adapters,
+            media_adapter_set,
+            num_entries,
+            devices,
+            num_devices);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
     return platform->dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR(
         platform,
@@ -2323,6 +5868,29 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR(
         devices,
         num_devices);
 }
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR_disp(
+    cl_platform_id platform,
+    cl_uint num_media_adapters,
+    cl_dx9_media_adapter_type_khr* media_adapter_type,
+    void* media_adapters,
+    cl_dx9_media_adapter_set_khr media_adapter_set,
+    cl_uint num_entries,
+    cl_device_id* devices,
+    cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
+    return platform->dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR(
+        platform,
+        num_media_adapters,
+        media_adapter_type,
+        media_adapters,
+        media_adapter_set,
+        num_entries,
+        devices,
+        num_devices);
+}
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR(
     cl_context context,
@@ -2331,6 +5899,34 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR(
     void* surface_info,
     cl_uint plane,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateFromDX9MediaSurfaceKHR(
+            context,
+            flags,
+            adapter_type,
+            surface_info,
+            plane,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateFromDX9MediaSurfaceKHR(
+        context,
+        flags,
+        adapter_type,
+        surface_info,
+        plane,
+        errcode_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    cl_dx9_media_adapter_type_khr adapter_type,
+    void* surface_info,
+    cl_uint plane,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateFromDX9MediaSurfaceKHR(
@@ -2341,8 +5937,56 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR(
         plane,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
+
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueAcquireDX9MediaSurfacesKHR(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueAcquireDX9MediaSurfacesKHR(
+        command_queue,
+        num_objects,
+        mem_objects,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR_disp(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueAcquireDX9MediaSurfacesKHR(
+        command_queue,
+        num_objects,
+        mem_objects,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+#endif // defined(CL_ENABLE_LAYERS)
 
-CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR(
+CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR(
     cl_command_queue command_queue,
     cl_uint num_objects,
     const cl_mem* mem_objects,
@@ -2350,8 +5994,18 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR(
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_2
 {
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueReleaseDX9MediaSurfacesKHR(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
-    return command_queue->dispatch->clEnqueueAcquireDX9MediaSurfacesKHR(
+    return command_queue->dispatch->clEnqueueReleaseDX9MediaSurfacesKHR(
         command_queue,
         num_objects,
         mem_objects,
@@ -2359,8 +6013,8 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR(
         event_wait_list,
         event);
 }
-
-CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR(
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR_disp(
     cl_command_queue command_queue,
     cl_uint num_objects,
     const cl_mem* mem_objects,
@@ -2377,6 +6031,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 #endif // defined(_WIN32)
 
@@ -2389,6 +6044,28 @@ CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromEGLSyncKHR(
     CLeglSyncKHR sync,
     CLeglDisplayKHR display,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateEventFromEGLSyncKHR(
+            context,
+            sync,
+            display,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateEventFromEGLSyncKHR(
+        context,
+        sync,
+        display,
+        errcode_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromEGLSyncKHR_disp(
+    cl_context context,
+    CLeglSyncKHR sync,
+    CLeglDisplayKHR display,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateEventFromEGLSyncKHR(
@@ -2397,6 +6074,7 @@ CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromEGLSyncKHR(
         display,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -2409,6 +6087,34 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromEGLImageKHR(
     cl_mem_flags flags,
     const cl_egl_image_properties_khr* properties,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateFromEGLImageKHR(
+            context,
+            egldisplay,
+            eglimage,
+            flags,
+            properties,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateFromEGLImageKHR(
+        context,
+        egldisplay,
+        eglimage,
+        flags,
+        properties,
+        errcode_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromEGLImageKHR_disp(
+    cl_context context,
+    CLeglDisplayKHR egldisplay,
+    CLeglImageKHR eglimage,
+    cl_mem_flags flags,
+    const cl_egl_image_properties_khr* properties,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateFromEGLImageKHR(
@@ -2419,6 +6125,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromEGLImageKHR(
         properties,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR(
     cl_command_queue command_queue,
@@ -2427,6 +6134,34 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueAcquireEGLObjectsKHR(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueAcquireEGLObjectsKHR(
+        command_queue,
+        num_objects,
+        mem_objects,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR_disp(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueAcquireEGLObjectsKHR(
@@ -2437,6 +6172,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR(
     cl_command_queue command_queue,
@@ -2445,6 +6181,34 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueReleaseEGLObjectsKHR(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueReleaseEGLObjectsKHR(
+        command_queue,
+        num_objects,
+        mem_objects,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR_disp(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueReleaseEGLObjectsKHR(
@@ -2455,6 +6219,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -2464,6 +6229,25 @@ CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR(
     cl_context context,
     cl_GLsync sync,
     cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateEventFromGLsyncKHR(
+            context,
+            sync,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateEventFromGLsyncKHR(
+        context,
+        sync,
+        errcode_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR_disp(
+    cl_context context,
+    cl_GLsync sync,
+    cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateEventFromGLsyncKHR(
@@ -2471,6 +6255,7 @@ CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR(
         sync,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -2482,9 +6267,35 @@ CL_API_ENTRY cl_int CL_API_CALL clGetGLContextInfoKHR(
     size_t param_value_size,
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetGLContextInfoKHR(
+            properties,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    cl_platform_id platform = NULL;
+    khrIcdContextPropertiesGetPlatform(properties, &platform);
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
+    return platform->dispatch->clGetGLContextInfoKHR(
+        properties,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetGLContextInfoKHR_disp(
+    const cl_context_properties* properties,
+    cl_gl_context_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
     cl_platform_id platform = NULL;
-    khrIcdInitialize();
     khrIcdContextPropertiesGetPlatform(properties, &platform);
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
     return platform->dispatch->clGetGLContextInfoKHR(
@@ -2494,12 +6305,35 @@ CL_API_ENTRY cl_int CL_API_CALL clGetGLContextInfoKHR(
         param_value,
         param_value_size_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer(
     cl_context context,
     cl_mem_flags flags,
     cl_GLuint bufobj,
     int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateFromGLBuffer(
+            context,
+            flags,
+            bufobj,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateFromGLBuffer(
+        context,
+        flags,
+        bufobj,
+        errcode_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    cl_GLuint bufobj,
+    int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateFromGLBuffer(
@@ -2508,6 +6342,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer(
         bufobj,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture(
     cl_context context,
@@ -2516,6 +6351,34 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture(
     cl_GLint miplevel,
     cl_GLuint texture,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateFromGLTexture(
+            context,
+            flags,
+            target,
+            miplevel,
+            texture,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateFromGLTexture(
+        context,
+        flags,
+        target,
+        miplevel,
+        texture,
+        errcode_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    cl_GLenum target,
+    cl_GLint miplevel,
+    cl_GLuint texture,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateFromGLTexture(
@@ -2526,6 +6389,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture(
         texture,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D(
     cl_context context,
@@ -2534,6 +6398,34 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D(
     cl_GLint miplevel,
     cl_GLuint texture,
     cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateFromGLTexture2D(
+            context,
+            flags,
+            target,
+            miplevel,
+            texture,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateFromGLTexture2D(
+        context,
+        flags,
+        target,
+        miplevel,
+        texture,
+        errcode_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    cl_GLenum target,
+    cl_GLint miplevel,
+    cl_GLuint texture,
+    cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateFromGLTexture2D(
@@ -2544,6 +6436,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D(
         texture,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D(
     cl_context context,
@@ -2552,6 +6445,34 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D(
     cl_GLint miplevel,
     cl_GLuint texture,
     cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateFromGLTexture3D(
+            context,
+            flags,
+            target,
+            miplevel,
+            texture,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateFromGLTexture3D(
+        context,
+        flags,
+        target,
+        miplevel,
+        texture,
+        errcode_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    cl_GLenum target,
+    cl_GLint miplevel,
+    cl_GLuint texture,
+    cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateFromGLTexture3D(
@@ -2562,12 +6483,35 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D(
         texture,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer(
     cl_context context,
     cl_mem_flags flags,
     cl_GLuint renderbuffer,
     cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clCreateFromGLRenderbuffer(
+            context,
+            flags,
+            renderbuffer,
+            errcode_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
+    return context->dispatch->clCreateFromGLRenderbuffer(
+        context,
+        flags,
+        renderbuffer,
+        errcode_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer_disp(
+    cl_context context,
+    cl_mem_flags flags,
+    cl_GLuint renderbuffer,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
     return context->dispatch->clCreateFromGLRenderbuffer(
@@ -2576,11 +6520,31 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer(
         renderbuffer,
         errcode_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo(
     cl_mem memobj,
     cl_gl_object_type* gl_object_type,
     cl_GLuint* gl_object_name) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetGLObjectInfo(
+            memobj,
+            gl_object_type,
+            gl_object_name);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
+    return memobj->dispatch->clGetGLObjectInfo(
+        memobj,
+        gl_object_type,
+        gl_object_name);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo_disp(
+    cl_mem memobj,
+    cl_gl_object_type* gl_object_type,
+    cl_GLuint* gl_object_name) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
     return memobj->dispatch->clGetGLObjectInfo(
@@ -2588,6 +6552,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo(
         gl_object_type,
         gl_object_name);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo(
     cl_mem memobj,
@@ -2595,6 +6560,31 @@ CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo(
     size_t param_value_size,
     void* param_value,
     size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetGLTextureInfo(
+            memobj,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
+    return memobj->dispatch->clGetGLTextureInfo(
+        memobj,
+        param_name,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo_disp(
+    cl_mem memobj,
+    cl_gl_texture_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
     return memobj->dispatch->clGetGLTextureInfo(
@@ -2604,6 +6594,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo(
         param_value,
         param_value_size_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects(
     cl_command_queue command_queue,
@@ -2612,6 +6603,34 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueAcquireGLObjects(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueAcquireGLObjects(
+        command_queue,
+        num_objects,
+        mem_objects,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects_disp(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueAcquireGLObjects(
@@ -2622,6 +6641,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects(
     cl_command_queue command_queue,
@@ -2630,6 +6650,34 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects(
     cl_uint num_events_in_wait_list,
     const cl_event* event_wait_list,
     cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clEnqueueReleaseGLObjects(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
+    return command_queue->dispatch->clEnqueueReleaseGLObjects(
+        command_queue,
+        num_objects,
+        mem_objects,
+        num_events_in_wait_list,
+        event_wait_list,
+        event);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects_disp(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
     return command_queue->dispatch->clEnqueueReleaseGLObjects(
@@ -2640,6 +6688,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects(
         event_wait_list,
         event);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -2654,6 +6703,40 @@ CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfoKHR(
     size_t param_value_size,
     void* param_value,
     size_t* param_value_size_ret) CL_EXT_SUFFIX__VERSION_2_0_DEPRECATED
+{
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.clGetKernelSubGroupInfoKHR(
+            in_kernel,
+            in_device,
+            param_name,
+            input_value_size,
+            input_value,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+#endif // defined(CL_ENABLE_LAYERS)
+    KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_kernel, CL_INVALID_KERNEL);
+    return in_kernel->dispatch->clGetKernelSubGroupInfoKHR(
+        in_kernel,
+        in_device,
+        param_name,
+        input_value_size,
+        input_value,
+        param_value_size,
+        param_value,
+        param_value_size_ret);
+}
+#if defined(CL_ENABLE_LAYERS)
+static CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfoKHR_disp(
+    cl_kernel in_kernel,
+    cl_device_id in_device,
+    cl_kernel_sub_group_info param_name,
+    size_t input_value_size,
+    const void* input_value,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_EXT_SUFFIX__VERSION_2_0_DEPRECATED
 {
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_kernel, CL_INVALID_KERNEL);
     return in_kernel->dispatch->clGetKernelSubGroupInfoKHR(
@@ -2666,9 +6749,216 @@ CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfoKHR(
         param_value,
         param_value_size_ret);
 }
+#endif // defined(CL_ENABLE_LAYERS)
 
 ///////////////////////////////////////////////////////////////////////////////
 
+#if defined(CL_ENABLE_LAYERS)
+struct _cl_icd_dispatch khrMasterDispatch = {
+    &clGetPlatformIDs_disp,
+    &clGetPlatformInfo_disp,
+    &clGetDeviceIDs_disp,
+    &clGetDeviceInfo_disp,
+    &clCreateContext_disp,
+    &clCreateContextFromType_disp,
+    &clRetainContext_disp,
+    &clReleaseContext_disp,
+    &clGetContextInfo_disp,
+    &clCreateCommandQueue_disp,
+    &clRetainCommandQueue_disp,
+    &clReleaseCommandQueue_disp,
+    &clGetCommandQueueInfo_disp,
+    &clSetCommandQueueProperty_disp,
+    &clCreateBuffer_disp,
+    &clCreateImage2D_disp,
+    &clCreateImage3D_disp,
+    &clRetainMemObject_disp,
+    &clReleaseMemObject_disp,
+    &clGetSupportedImageFormats_disp,
+    &clGetMemObjectInfo_disp,
+    &clGetImageInfo_disp,
+    &clCreateSampler_disp,
+    &clRetainSampler_disp,
+    &clReleaseSampler_disp,
+    &clGetSamplerInfo_disp,
+    &clCreateProgramWithSource_disp,
+    &clCreateProgramWithBinary_disp,
+    &clRetainProgram_disp,
+    &clReleaseProgram_disp,
+    &clBuildProgram_disp,
+    &clUnloadCompiler_disp,
+    &clGetProgramInfo_disp,
+    &clGetProgramBuildInfo_disp,
+    &clCreateKernel_disp,
+    &clCreateKernelsInProgram_disp,
+    &clRetainKernel_disp,
+    &clReleaseKernel_disp,
+    &clSetKernelArg_disp,
+    &clGetKernelInfo_disp,
+    &clGetKernelWorkGroupInfo_disp,
+    &clWaitForEvents_disp,
+    &clGetEventInfo_disp,
+    &clRetainEvent_disp,
+    &clReleaseEvent_disp,
+    &clGetEventProfilingInfo_disp,
+    &clFlush_disp,
+    &clFinish_disp,
+    &clEnqueueReadBuffer_disp,
+    &clEnqueueWriteBuffer_disp,
+    &clEnqueueCopyBuffer_disp,
+    &clEnqueueReadImage_disp,
+    &clEnqueueWriteImage_disp,
+    &clEnqueueCopyImage_disp,
+    &clEnqueueCopyImageToBuffer_disp,
+    &clEnqueueCopyBufferToImage_disp,
+    &clEnqueueMapBuffer_disp,
+    &clEnqueueMapImage_disp,
+    &clEnqueueUnmapMemObject_disp,
+    &clEnqueueNDRangeKernel_disp,
+    &clEnqueueTask_disp,
+    &clEnqueueNativeKernel_disp,
+    &clEnqueueMarker_disp,
+    &clEnqueueWaitForEvents_disp,
+    &clEnqueueBarrier_disp,
+    &clGetExtensionFunctionAddress_disp,
+    &clCreateFromGLBuffer_disp,
+    &clCreateFromGLTexture2D_disp,
+    &clCreateFromGLTexture3D_disp,
+    &clCreateFromGLRenderbuffer_disp,
+    &clGetGLObjectInfo_disp,
+    &clGetGLTextureInfo_disp,
+    &clEnqueueAcquireGLObjects_disp,
+    &clEnqueueReleaseGLObjects_disp,
+    &clGetGLContextInfoKHR_disp,
+
+  /* cl_khr_d3d10_sharing */
+#if defined(_WIN32)
+    &clGetDeviceIDsFromD3D10KHR_disp,
+    &clCreateFromD3D10BufferKHR_disp,
+    &clCreateFromD3D10Texture2DKHR_disp,
+    &clCreateFromD3D10Texture3DKHR_disp,
+    &clEnqueueAcquireD3D10ObjectsKHR_disp,
+    &clEnqueueReleaseD3D10ObjectsKHR_disp,
+#else
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+#endif
+
+  /* OpenCL 1.1 */
+    &clSetEventCallback_disp,
+    &clCreateSubBuffer_disp,
+    &clSetMemObjectDestructorCallback_disp,
+    &clCreateUserEvent_disp,
+    &clSetUserEventStatus_disp,
+    &clEnqueueReadBufferRect_disp,
+    &clEnqueueWriteBufferRect_disp,
+    &clEnqueueCopyBufferRect_disp,
+
+  /* cl_ext_device_fission */
+    &clCreateSubDevicesEXT_disp,
+    &clRetainDeviceEXT_disp,
+    &clReleaseDeviceEXT_disp,
+
+  /* cl_khr_gl_event */
+    &clCreateEventFromGLsyncKHR_disp,
+
+  /* OpenCL 1.2 */
+    &clCreateSubDevices_disp,
+    &clRetainDevice_disp,
+    &clReleaseDevice_disp,
+    &clCreateImage_disp,
+    &clCreateProgramWithBuiltInKernels_disp,
+    &clCompileProgram_disp,
+    &clLinkProgram_disp,
+    &clUnloadPlatformCompiler_disp,
+    &clGetKernelArgInfo_disp,
+    &clEnqueueFillBuffer_disp,
+    &clEnqueueFillImage_disp,
+    &clEnqueueMigrateMemObjects_disp,
+    &clEnqueueMarkerWithWaitList_disp,
+    &clEnqueueBarrierWithWaitList_disp,
+    &clGetExtensionFunctionAddressForPlatform_disp,
+    &clCreateFromGLTexture_disp,
+
+  /* cl_khr_d3d11_sharing */
+#if defined(_WIN32)
+    &clGetDeviceIDsFromD3D11KHR_disp,
+    &clCreateFromD3D11BufferKHR_disp,
+    &clCreateFromD3D11Texture2DKHR_disp,
+    &clCreateFromD3D11Texture3DKHR_disp,
+    &clCreateFromDX9MediaSurfaceKHR_disp,
+    &clEnqueueAcquireD3D11ObjectsKHR_disp,
+    &clEnqueueReleaseD3D11ObjectsKHR_disp,
+#else
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+#endif
+
+  /* cl_khr_dx9_media_sharing */
+#if defined(_WIN32)
+    &clGetDeviceIDsFromDX9MediaAdapterKHR_disp,
+    &clEnqueueAcquireDX9MediaSurfacesKHR_disp,
+    &clEnqueueReleaseDX9MediaSurfacesKHR_disp,
+#else
+    NULL,
+    NULL,
+    NULL,
+#endif
+
+  /* cl_khr_egl_image */
+    &clCreateFromEGLImageKHR_disp,
+    &clEnqueueAcquireEGLObjectsKHR_disp,
+    &clEnqueueReleaseEGLObjectsKHR_disp,
+
+  /* cl_khr_egl_event */
+    &clCreateEventFromEGLSyncKHR_disp,
+
+  /* OpenCL 2.0 */
+    &clCreateCommandQueueWithProperties_disp,
+    &clCreatePipe_disp,
+    &clGetPipeInfo_disp,
+    &clSVMAlloc_disp,
+    &clSVMFree_disp,
+    &clEnqueueSVMFree_disp,
+    &clEnqueueSVMMemcpy_disp,
+    &clEnqueueSVMMemFill_disp,
+    &clEnqueueSVMMap_disp,
+    &clEnqueueSVMUnmap_disp,
+    &clCreateSamplerWithProperties_disp,
+    &clSetKernelArgSVMPointer_disp,
+    &clSetKernelExecInfo_disp,
+
+  /* cl_khr_sub_groups */
+    &clGetKernelSubGroupInfoKHR_disp,
+
+  /* OpenCL 2.1 */
+    &clCloneKernel_disp,
+    &clCreateProgramWithIL_disp,
+    &clEnqueueSVMMigrateMem_disp,
+    &clGetDeviceAndHostTimer_disp,
+    &clGetHostTimer_disp,
+    &clGetKernelSubGroupInfo_disp,
+    &clSetDefaultDeviceCommandQueue_disp,
+
+  /* OpenCL 2.2 */
+    &clSetProgramReleaseCallback_disp,
+    &clSetProgramSpecializationConstant_disp,
+
+  /* OpenCL 3.0 */
+    &clCreateBufferWithProperties_disp,
+    &clCreateImageWithProperties_disp,
+    &clSetContextDestructorCallback_disp
+};
+#endif // defined(CL_ENABLE_LAYERS)
 #ifdef __cplusplus
 }
 #endif

diff --git a/loader/linux/icd_linux.c b/loader/linux/icd_linux.c
index bb21b2ab77212323e519d6abe4d6c010c379d584..4cc078b2d8b57bbe2a42a4ebf5b06a1f4fe4ee9f 100644 (file)
--- a/loader/linux/icd_linux.c
+++ b/loader/linux/icd_linux.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2019 The Khronos Group Inc.
+ * Copyright (c) 2016-2020 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.
@@ -141,6 +141,9 @@ void khrIcdOsVendorsEnumerate(void)
     {
         khrIcd_free_getenv(envPath);
     }
+#if defined(CL_ENABLE_LAYERS)
+    khrIcdLayersEnumerateEnv();
+#endif // defined(CL_ENABLE_LAYERS)
 }
 
 // go through the list of vendors only once

diff --git a/loader/windows/OpenCL.rc b/loader/windows/OpenCL.rc
index 2ebc875e01a486a1fdcad2f924dc34e87e5c19c5..86a5ba7e6d817b566425b5d56c3276ecea539136 100644 (file)
--- a/loader/windows/OpenCL.rc
+++ b/loader/windows/OpenCL.rc
@@ -20,7 +20,7 @@
 
 #define OPENCL_ICD_LOADER_VERSION_MAJOR 3
 #define OPENCL_ICD_LOADER_VERSION_MINOR 0
-#define OPENCL_ICD_LOADER_VERSION_REV   0
+#define OPENCL_ICD_LOADER_VERSION_REV   1
 
 #ifdef RC_INVOKED
 

diff --git a/loader/windows/icd_windows.c b/loader/windows/icd_windows.c
index 19a0e7aee9595bd4b88b54f1f7cccc2b9c5c3e5b..4df109af7c22228a92c1a6057b231805ec2d0554 100644 (file)
--- a/loader/windows/icd_windows.c
+++ b/loader/windows/icd_windows.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2019 The Khronos Group Inc.
+ * Copyright (c) 2016-2020 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.
@@ -239,6 +239,9 @@ BOOL CALLBACK khrIcdOsVendorsEnumerate(PINIT_ONCE InitOnce, PVOID Parameter, PVO
     {
         KHR_ICD_TRACE("Failed to close platforms key %s, ignoring\n", platformsName);
     }
+#if defined(CL_ENABLE_LAYERS)
+    khrIcdLayersEnumerateEnv();
+#endif // defined(CL_ENABLE_LAYERS)
     return status;
 }
 

diff --git a/scripts/.gitignore b/scripts/.gitignore
new file mode 100644 (file)
index 0000000..01f6e38
--- /dev/null
+++ b/scripts/.gitignore
@@ -0,0 +1,2 @@
+gen/__pycache__
+*.c

diff --git a/scripts/README.md b/scripts/README.md
index 1b7a371e86e169db5635b637f64eb9cb9dc5003d..7ed30a4c3340875ad17c14b2750e1e854eaef433 100644 (file)
--- a/scripts/README.md
+++ b/scripts/README.md
@@ -24,7 +24,7 @@ The Python script should only need to be modified if additional information need
 
 ## Generating Files
 
-Files for the OpenCL ICD loader may be generated by executing the `gen_loader.py` script.
+Files for the OpenCL ICD loader, or the test layer, may be generated by executing the scripts `gen_loader.py`, or `gen_print_layer.py`, respectively.
 
 The script requires the `cl.xml` machine readable grammar.
 By default, the script searches for `cl.xml` in the current directory.

diff --git a/scripts/gen/__init__.py b/scripts/gen/__init__.py
new file mode 100644 (file)
index 0000000..167a430
--- /dev/null
+++ b/scripts/gen/__init__.py
@@ -0,0 +1,124 @@
+# Copyright (c) 2020 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.
+
+from collections import OrderedDict
+from collections import namedtuple
+
+import argparse
+import sys
+import urllib
+import xml.etree.ElementTree as etree
+import urllib.request
+
+# parse_xml - Helper function to parse the XML file from a URL or local file.
+def parse_xml(path):
+    file = urllib.request.urlopen(path) if path.startswith("http") else open(path, 'r')
+    with file:
+        tree = etree.parse(file)
+        return tree
+
+# noneStr - returns string argument, or "" if argument is None.
+def noneStr(s):
+    if s:
+        return s
+    return ""
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+
+    # To pull the latest registry file from GitHub, pass:
+    # -registry "https://raw.githubusercontent.com/KhronosGroup/OpenCL-Registry/master/xml/cl.xml"
+
+    parser.add_argument('-registry', action='store',
+                        default='cl.xml',
+                        help='Use specified registry file instead of cl.xml')
+    parser.add_argument('-o', action='store', dest='directory',
+                        default='.',
+                        help='Create target and related files in specified directory')
+
+    args = parser.parse_args()
+    return args
+
+def load_spec(args):
+    specpath = args.registry
+
+    print('Parsing XML file from: ' + specpath)
+    spec = parse_xml(specpath)
+    return spec
+
+def get_apisigs(spec):
+    # Generate the API function signatures dictionary:
+    apisigs = OrderedDict()
+    ApiSignature = namedtuple('ApiSignature', 'Name RetType Params Suffix')
+    ApiParam = namedtuple('ApiParam', 'Type TypeEnd Name')
+    print('Generating API signatures dictionary...')
+    for command in spec.findall('commands/command'):
+        suffix = noneStr(command.get('suffix'))
+        proto = command.find('proto')
+        ret = noneStr(proto.text)
+        name = ""
+        params = ""
+        for elem in proto:
+            if elem.tag == 'name':
+                name = noneStr(elem.text) + noneStr(elem.tail)
+            else:
+                ret = ret + noneStr(elem.text) + noneStr(elem.tail)
+        ret = ret.strip()
+        name = name.strip()
+
+        plist = []
+        for param in command.findall('param'):
+            ptype = noneStr(param.text)
+            ptypeend = ""
+            pname = ""
+            for elem in param:
+                if elem.tag == 'name':
+                    pname = noneStr(elem.text)
+                    ptypeend = noneStr(elem.tail)
+                else:
+                    ptype = ptype + noneStr(elem.text) + noneStr(elem.tail)
+            ptype = ptype.strip()
+            ptypeend = ptypeend.strip()
+            pname = pname.strip()
+            plist.append(ApiParam(ptype, ptypeend, pname))
+        apisigs[name] = ApiSignature(name, ret, plist, suffix)
+    return apisigs
+
+def get_apis(spec, apisigs):
+    # Generate the core API dictionary:
+    coreapis = OrderedDict()
+    print('Generating core API dictionary...')
+    for feature in spec.findall('feature'):
+        version = noneStr(feature.get('name'))
+
+        alist = []
+        for function in feature.findall('require/command'):
+            name = function.get('name')
+            alist.append(apisigs[name])
+        coreapis[version] = alist
+
+    # Generate the extensions API dictionary:
+    extapis = OrderedDict()
+    print('Generating API extensions dictionary...')
+    for feature in spec.findall('extensions/extension'):
+        extension = noneStr(feature.get('name'))
+
+        alist = []
+        for function in feature.findall('require/command'):
+            name = function.get('name')
+            alist.append(apisigs[name])
+        extapis[extension] = alist
+    return (coreapis, extapis)
+
+

diff --git a/scripts/gen_loader.py b/scripts/gen_loader.py
index d939ac54e1cb76f2f1cdb886beee1c8aeee702bc..38f84f1ee3f77d0f22cd5c25bbb8d3f958eacaaa 100644 (file)
--- a/scripts/gen_loader.py
+++ b/scripts/gen_loader.py
@@ -14,109 +14,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import gen
 from mako.template import Template
-
-from collections import OrderedDict
-from collections import namedtuple
-
-import argparse
-import sys
-import urllib
-import xml.etree.ElementTree as etree
-import urllib.request
-
-# parse_xml - Helper function to parse the XML file from a URL or local file.
-def parse_xml(path):
-    file = urllib.request.urlopen(path) if path.startswith("http") else open(path, 'r')
-    with file:
-        tree = etree.parse(file)
-        return tree
-
-# noneStr - returns string argument, or "" if argument is None.
-def noneStr(s):
-    if s:
-        return s
-    return ""
+from mako.exceptions import RichTraceback
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    # To pull the latest registry file from GitHub, pass:
-    # -registry "https://raw.githubusercontent.com/KhronosGroup/OpenCL-Registry/master/xml/cl.xml"
-
-    parser.add_argument('-registry', action='store',
-                        default='cl.xml',
-                        help='Use specified registry file instead of cl.xml')
-    parser.add_argument('-o', action='store', dest='directory',
-                        default='.',
-                        help='Create target and related files in specified directory')
-
-    args = parser.parse_args()
-
-    specpath = args.registry
-
-    print('Parsing XML file from: ' + specpath)
-    spec = parse_xml(specpath)
-
-    # Generate the API function signatures dictionary:
-    apisigs = OrderedDict()
-    ApiSignature = namedtuple('ApiSignature', 'Name RetType Params Suffix')
-    ApiParam = namedtuple('ApiParam', 'Type TypeEnd Name')
-    print('Generating API signatures dictionary...')
-    for command in spec.findall('commands/command'):
-        suffix = noneStr(command.get('suffix'))
-        proto = command.find('proto')
-        ret = noneStr(proto.text)
-        name = ""
-        params = ""
-        for elem in proto:
-            if elem.tag == 'name':
-                name = noneStr(elem.text) + noneStr(elem.tail)
-            else:
-                ret = ret + noneStr(elem.text) + noneStr(elem.tail)
-        ret = ret.strip()
-        name = name.strip()
-
-        plist = []
-        for param in command.findall('param'):
-            ptype = noneStr(param.text)
-            ptypeend = ""
-            pname = ""
-            for elem in param:
-                if elem.tag == 'name':
-                    pname = noneStr(elem.text)
-                    ptypeend = noneStr(elem.tail)
-                else:
-                    ptype = ptype + noneStr(elem.text) + noneStr(elem.tail)
-            ptype = ptype.strip()
-            ptypeend = ptypeend.strip()
-            pname = pname.strip()
-            plist.append(ApiParam(ptype, ptypeend, pname))
-        apisigs[name] = ApiSignature(name, ret, plist, suffix)
-
-    # Generate the core API dictionary:
-    coreapis = OrderedDict()
-    print('Generating core API dictionary...')
-    for feature in spec.findall('feature'):
-        version = noneStr(feature.get('name'))
-
-        alist = []
-        for function in feature.findall('require/command'):
-            name = function.get('name')
-            alist.append(apisigs[name])
-        coreapis[version] = alist
-
-    # Generate the extensions API dictionary:
-    extapis = OrderedDict()
-    print('Generating API extensions dictionary...')
-    for feature in spec.findall('extensions/extension'):
-        extension = noneStr(feature.get('name'))
-
-        alist = []
-        for function in feature.findall('require/command'):
-            name = function.get('name')
-            alist.append(apisigs[name])
-        extapis[extension] = alist
+    args = gen.parse_args()
+    spec = gen.load_spec(args)
+    apisigs = gen.get_apisigs(spec)
+    (coreapis, extapis) = gen.get_apis(spec, apisigs)
 
     try:
         # Create the loader cpp file from the API dictionary:

diff --git a/scripts/gen_print_layer.py b/scripts/gen_print_layer.py
new file mode 100644 (file)
index 0000000..1a28883
--- /dev/null
+++ b/scripts/gen_print_layer.py
@@ -0,0 +1,43 @@
+#!/usr/bin/python3
+
+# Copyright (c) 2020 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.
+
+import gen
+from mako.template import Template
+from mako.exceptions import RichTraceback
+
+if __name__ == "__main__":
+    args = gen.parse_args()
+    spec = gen.load_spec(args)
+    apisigs = gen.get_apisigs(spec)
+    (coreapis, extapis) = gen.get_apis(spec, apisigs)
+
+    try:
+        # Create the layer cpp file from the API dictionary:
+        test = open(args.directory + '/icd_print_layer_generated.c', 'wb')
+        icd_layer_generated_template = Template(filename='icd_print_layer_generated.c.mako')
+        test.write(
+          icd_layer_generated_template.render_unicode(
+              spec=spec,
+              apisigs=apisigs,
+              coreapis=coreapis,
+              extapis=extapis).
+          encode('utf-8', 'replace'))
+    except:
+        traceback = RichTraceback()
+        for (filename, lineno, function, line) in traceback.traceback:
+            print('%s(%s) : error in %s' % (filename, lineno, function))
+            print('    ', line)
+        print('%s: %s' % (str(traceback.error.__class__.__name__), traceback.error))

diff --git a/scripts/icd_dispatch_generated.c.mako b/scripts/icd_dispatch_generated.c.mako
index cdc4b4ab3688491e1d87ceb09cc5d8de6a9be3e5..a05802b55952896692187ad4071b73e0859d3aef 100644 (file)
--- a/scripts/icd_dispatch_generated.c.mako
+++ b/scripts/icd_dispatch_generated.c.mako
@@ -6,6 +6,10 @@ apiskip = {
     'clGetExtensionFunctionAddressForPlatform', # to return ICD-aware extensions
     }
 
+apiinit = {
+    'clCreateContextFromType',
+    'clGetGLContextInfoKHR',
+    }
 # Handles, and mappings to errors when handles are invalid:
 apihandles = {
     'cl_command_queue'  : 'CL_INVALID_COMMAND_QUEUE',
@@ -55,7 +59,11 @@ extern "C" {
       else:
           invalid = 'NULL'
 %>
-CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name}(
+%for disp in [0, 1]:
+%  if disp == 1:
+#if defined(CL_ENABLE_LAYERS)
+%  endif
+${("", "static ")[disp]}CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name + ("", "_disp")[disp]}(
 %for i, param in enumerate(api.Params):
 %  if i < len(api.Params)-1:
     ${param.Type} ${param.Name}${param.TypeEnd},
@@ -64,6 +72,22 @@ CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name}(
 %  endif
 %endfor
 {
+%if api.Name in apiinit:
+    khrIcdInitialize();
+%endif
+%if disp == 0:
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.${api.Name}(
+%for i, param in enumerate(api.Params):
+%  if i < len(api.Params)-1:
+            ${param.Name},
+%  else:
+            ${param.Name});
+%  endif
+%endfor
+#endif // defined(CL_ENABLE_LAYERS)
+%endif
 %if api.RetType in apihandles or api.RetType == "void*":
 ## clCreateContext is a special case, since it calls through
 ## the dispatch table via the first "device":
@@ -76,7 +100,6 @@ CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name}(
 ## through a platform passed via properties:
 %  elif api.Name == "clCreateContextFromType":
     cl_platform_id platform = NULL;
-    khrIcdInitialize();
     khrIcdContextPropertiesGetPlatform(properties, &platform);
     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(platform, CL_INVALID_PLATFORM);
 ## These APIs are special cases because they return a void*, but
@@ -122,8 +145,24 @@ CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name}(
 %  endif
 %endfor
 }
+%  if disp == 1:
+#endif // defined(CL_ENABLE_LAYERS)
+%  endif
 
 ///////////////////////////////////////////////////////////////////////////////
+%endfor
+%else:
+#if defined(CL_ENABLE_LAYERS)
+extern CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name + "_disp"}(
+%for i, param in enumerate(api.Params):
+%  if i < len(api.Params)-1:
+    ${param.Type} ${param.Name}${param.TypeEnd},
+%  else:
+    ${param.Type} ${param.Name}${param.TypeEnd}) ${api.Suffix};
+%  endif
+%endfor
+#endif // defined(CL_ENABLE_LAYERS)
+
 %endif
 %endfor
 %endfor
@@ -161,7 +200,11 @@ win32extensions = {
       else:
           invalid = 'NULL'
 %>
-CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name}(
+%for disp in [0, 1]:
+%  if disp == 1:
+#if defined(CL_ENABLE_LAYERS)
+%  endif
+${("", "static ")[disp]}CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name + ("", "_disp")[disp]}(
 %for i, param in enumerate(api.Params):
 %  if i < len(api.Params)-1:
     ${param.Type} ${param.Name}${param.TypeEnd},
@@ -170,6 +213,19 @@ CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name}(
 %  endif
 %endfor
 {
+%if disp == 0:
+#if defined(CL_ENABLE_LAYERS)
+    if (khrFirstLayer)
+        return khrFirstLayer->dispatch.${api.Name}(
+%for i, param in enumerate(api.Params):
+%  if i < len(api.Params)-1:
+            ${param.Name},
+%  else:
+            ${param.Name});
+%  endif
+%endfor
+#endif // defined(CL_ENABLE_LAYERS)
+%endif
 %if api.RetType in apihandles or api.RetType == "void*":
 %  if False:
     // api.Name == "clXXX":  # There are currently no API special cases here.
@@ -179,7 +235,6 @@ CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name}(
 %else:
 %  if api.Name == "clGetGLContextInfoKHR":
     cl_platform_id platform = NULL;
-    khrIcdInitialize();
     khrIcdContextPropertiesGetPlatform(properties, &platform);
     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
 %  else:
@@ -199,6 +254,10 @@ CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name}(
 %  endif
 %endfor
 }
+%  if disp == 1:
+#endif // defined(CL_ENABLE_LAYERS)
+%  endif
+%endfor
 %endfor
 
 %if extension in win32extensions:
@@ -208,6 +267,212 @@ CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name}(
 ///////////////////////////////////////////////////////////////////////////////
 
 %endfor
+#if defined(CL_ENABLE_LAYERS)
+struct _cl_icd_dispatch khrMasterDispatch = {
+    &clGetPlatformIDs_disp,
+    &clGetPlatformInfo_disp,
+    &clGetDeviceIDs_disp,
+    &clGetDeviceInfo_disp,
+    &clCreateContext_disp,
+    &clCreateContextFromType_disp,
+    &clRetainContext_disp,
+    &clReleaseContext_disp,
+    &clGetContextInfo_disp,
+    &clCreateCommandQueue_disp,
+    &clRetainCommandQueue_disp,
+    &clReleaseCommandQueue_disp,
+    &clGetCommandQueueInfo_disp,
+    &clSetCommandQueueProperty_disp,
+    &clCreateBuffer_disp,
+    &clCreateImage2D_disp,
+    &clCreateImage3D_disp,
+    &clRetainMemObject_disp,
+    &clReleaseMemObject_disp,
+    &clGetSupportedImageFormats_disp,
+    &clGetMemObjectInfo_disp,
+    &clGetImageInfo_disp,
+    &clCreateSampler_disp,
+    &clRetainSampler_disp,
+    &clReleaseSampler_disp,
+    &clGetSamplerInfo_disp,
+    &clCreateProgramWithSource_disp,
+    &clCreateProgramWithBinary_disp,
+    &clRetainProgram_disp,
+    &clReleaseProgram_disp,
+    &clBuildProgram_disp,
+    &clUnloadCompiler_disp,
+    &clGetProgramInfo_disp,
+    &clGetProgramBuildInfo_disp,
+    &clCreateKernel_disp,
+    &clCreateKernelsInProgram_disp,
+    &clRetainKernel_disp,
+    &clReleaseKernel_disp,
+    &clSetKernelArg_disp,
+    &clGetKernelInfo_disp,
+    &clGetKernelWorkGroupInfo_disp,
+    &clWaitForEvents_disp,
+    &clGetEventInfo_disp,
+    &clRetainEvent_disp,
+    &clReleaseEvent_disp,
+    &clGetEventProfilingInfo_disp,
+    &clFlush_disp,
+    &clFinish_disp,
+    &clEnqueueReadBuffer_disp,
+    &clEnqueueWriteBuffer_disp,
+    &clEnqueueCopyBuffer_disp,
+    &clEnqueueReadImage_disp,
+    &clEnqueueWriteImage_disp,
+    &clEnqueueCopyImage_disp,
+    &clEnqueueCopyImageToBuffer_disp,
+    &clEnqueueCopyBufferToImage_disp,
+    &clEnqueueMapBuffer_disp,
+    &clEnqueueMapImage_disp,
+    &clEnqueueUnmapMemObject_disp,
+    &clEnqueueNDRangeKernel_disp,
+    &clEnqueueTask_disp,
+    &clEnqueueNativeKernel_disp,
+    &clEnqueueMarker_disp,
+    &clEnqueueWaitForEvents_disp,
+    &clEnqueueBarrier_disp,
+    &clGetExtensionFunctionAddress_disp,
+    &clCreateFromGLBuffer_disp,
+    &clCreateFromGLTexture2D_disp,
+    &clCreateFromGLTexture3D_disp,
+    &clCreateFromGLRenderbuffer_disp,
+    &clGetGLObjectInfo_disp,
+    &clGetGLTextureInfo_disp,
+    &clEnqueueAcquireGLObjects_disp,
+    &clEnqueueReleaseGLObjects_disp,
+    &clGetGLContextInfoKHR_disp,
+
+  /* cl_khr_d3d10_sharing */
+#if defined(_WIN32)
+    &clGetDeviceIDsFromD3D10KHR_disp,
+    &clCreateFromD3D10BufferKHR_disp,
+    &clCreateFromD3D10Texture2DKHR_disp,
+    &clCreateFromD3D10Texture3DKHR_disp,
+    &clEnqueueAcquireD3D10ObjectsKHR_disp,
+    &clEnqueueReleaseD3D10ObjectsKHR_disp,
+#else
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+#endif
+
+  /* OpenCL 1.1 */
+    &clSetEventCallback_disp,
+    &clCreateSubBuffer_disp,
+    &clSetMemObjectDestructorCallback_disp,
+    &clCreateUserEvent_disp,
+    &clSetUserEventStatus_disp,
+    &clEnqueueReadBufferRect_disp,
+    &clEnqueueWriteBufferRect_disp,
+    &clEnqueueCopyBufferRect_disp,
+
+  /* cl_ext_device_fission */
+    &clCreateSubDevicesEXT_disp,
+    &clRetainDeviceEXT_disp,
+    &clReleaseDeviceEXT_disp,
+
+  /* cl_khr_gl_event */
+    &clCreateEventFromGLsyncKHR_disp,
+
+  /* OpenCL 1.2 */
+    &clCreateSubDevices_disp,
+    &clRetainDevice_disp,
+    &clReleaseDevice_disp,
+    &clCreateImage_disp,
+    &clCreateProgramWithBuiltInKernels_disp,
+    &clCompileProgram_disp,
+    &clLinkProgram_disp,
+    &clUnloadPlatformCompiler_disp,
+    &clGetKernelArgInfo_disp,
+    &clEnqueueFillBuffer_disp,
+    &clEnqueueFillImage_disp,
+    &clEnqueueMigrateMemObjects_disp,
+    &clEnqueueMarkerWithWaitList_disp,
+    &clEnqueueBarrierWithWaitList_disp,
+    &clGetExtensionFunctionAddressForPlatform_disp,
+    &clCreateFromGLTexture_disp,
+
+  /* cl_khr_d3d11_sharing */
+#if defined(_WIN32)
+    &clGetDeviceIDsFromD3D11KHR_disp,
+    &clCreateFromD3D11BufferKHR_disp,
+    &clCreateFromD3D11Texture2DKHR_disp,
+    &clCreateFromD3D11Texture3DKHR_disp,
+    &clCreateFromDX9MediaSurfaceKHR_disp,
+    &clEnqueueAcquireD3D11ObjectsKHR_disp,
+    &clEnqueueReleaseD3D11ObjectsKHR_disp,
+#else
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+#endif
+
+  /* cl_khr_dx9_media_sharing */
+#if defined(_WIN32)
+    &clGetDeviceIDsFromDX9MediaAdapterKHR_disp,
+    &clEnqueueAcquireDX9MediaSurfacesKHR_disp,
+    &clEnqueueReleaseDX9MediaSurfacesKHR_disp,
+#else
+    NULL,
+    NULL,
+    NULL,
+#endif
+
+  /* cl_khr_egl_image */
+    &clCreateFromEGLImageKHR_disp,
+    &clEnqueueAcquireEGLObjectsKHR_disp,
+    &clEnqueueReleaseEGLObjectsKHR_disp,
+
+  /* cl_khr_egl_event */
+    &clCreateEventFromEGLSyncKHR_disp,
+
+  /* OpenCL 2.0 */
+    &clCreateCommandQueueWithProperties_disp,
+    &clCreatePipe_disp,
+    &clGetPipeInfo_disp,
+    &clSVMAlloc_disp,
+    &clSVMFree_disp,
+    &clEnqueueSVMFree_disp,
+    &clEnqueueSVMMemcpy_disp,
+    &clEnqueueSVMMemFill_disp,
+    &clEnqueueSVMMap_disp,
+    &clEnqueueSVMUnmap_disp,
+    &clCreateSamplerWithProperties_disp,
+    &clSetKernelArgSVMPointer_disp,
+    &clSetKernelExecInfo_disp,
+
+  /* cl_khr_sub_groups */
+    &clGetKernelSubGroupInfoKHR_disp,
+
+  /* OpenCL 2.1 */
+    &clCloneKernel_disp,
+    &clCreateProgramWithIL_disp,
+    &clEnqueueSVMMigrateMem_disp,
+    &clGetDeviceAndHostTimer_disp,
+    &clGetHostTimer_disp,
+    &clGetKernelSubGroupInfo_disp,
+    &clSetDefaultDeviceCommandQueue_disp,
+
+  /* OpenCL 2.2 */
+    &clSetProgramReleaseCallback_disp,
+    &clSetProgramSpecializationConstant_disp,
+
+  /* OpenCL 3.0 */
+    &clCreateBufferWithProperties_disp,
+    &clCreateImageWithProperties_disp,
+    &clSetContextDestructorCallback_disp
+};
+#endif // defined(CL_ENABLE_LAYERS)
 #ifdef __cplusplus
 }
 #endif

diff --git a/scripts/icd_print_layer_generated.c.mako b/scripts/icd_print_layer_generated.c.mako
new file mode 100644 (file)
index 0000000..f5260d5
--- /dev/null
+++ b/scripts/icd_print_layer_generated.c.mako
@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) 2020 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.
+ *
+ * OpenCL is a trademark of Apple Inc. used under license by Khronos.
+ */
+
+#include "icd_print_layer.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// Core APIs:
+%for apis in coreapis.values():
+%for api in apis:
+static CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name + "_wrap"}(
+%for i, param in enumerate(api.Params):
+%  if i < len(api.Params)-1:
+    ${param.Type} ${param.Name}${param.TypeEnd},
+%  else:
+    ${param.Type} ${param.Name}${param.TypeEnd}) ${api.Suffix}
+%  endif
+%endfor
+{
+printf("${api.Name}\n");
+return tdispatch->${api.Name}(
+%for i, param in enumerate(api.Params):
+%  if i < len(api.Params)-1:
+            ${param.Name},
+%  else:
+            ${param.Name});
+%  endif
+%endfor
+}
+
+///////////////////////////////////////////////////////////////////////////////
+%endfor
+%endfor
+<%
+icdextensions = [
+    'cl_ext_device_fission',
+    'cl_khr_d3d10_sharing',
+    'cl_khr_d3d11_sharing',
+    'cl_khr_dx9_media_sharing',
+    'cl_khr_egl_event',
+    'cl_khr_egl_image',
+    'cl_khr_gl_event',
+    'cl_khr_gl_sharing',
+    'cl_khr_subgroups'
+    ]
+win32extensions = {
+    'cl_khr_d3d10_sharing',
+    'cl_khr_d3d11_sharing',
+    'cl_khr_dx9_media_sharing',
+    }
+%>
+%for extension in icdextensions:
+<%
+    apis = extapis[extension]
+%>// ${extension}
+%if extension in win32extensions:
+
+#if defined(_WIN32)
+%endif
+%for api in apis:
+static CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name + "_wrap"}(
+%for i, param in enumerate(api.Params):
+%  if i < len(api.Params)-1:
+    ${param.Type} ${param.Name}${param.TypeEnd},
+%  else:
+    ${param.Type} ${param.Name}${param.TypeEnd}) ${api.Suffix}
+%  endif
+%endfor
+{
+printf("${api.Name}\n");
+return tdispatch->${api.Name}(
+%for i, param in enumerate(api.Params):
+%  if i < len(api.Params)-1:
+            ${param.Name},
+%  else:
+            ${param.Name});
+%  endif
+%endfor
+}
+%endfor
+
+%if extension in win32extensions:
+#endif // defined(_WIN32)
+
+%endif
+///////////////////////////////////////////////////////////////////////////////
+
+%endfor
+void _init_dispatch(void) {
+    dispatch.clGetPlatformIDs = &clGetPlatformIDs_wrap;
+    dispatch.clGetPlatformInfo = &clGetPlatformInfo_wrap;
+    dispatch.clGetDeviceIDs = &clGetDeviceIDs_wrap;
+    dispatch.clGetDeviceInfo = &clGetDeviceInfo_wrap;
+    dispatch.clCreateContext = &clCreateContext_wrap;
+    dispatch.clCreateContextFromType = &clCreateContextFromType_wrap;
+    dispatch.clRetainContext = &clRetainContext_wrap;
+    dispatch.clReleaseContext = &clReleaseContext_wrap;
+    dispatch.clGetContextInfo = &clGetContextInfo_wrap;
+    dispatch.clCreateCommandQueue = &clCreateCommandQueue_wrap;
+    dispatch.clRetainCommandQueue = &clRetainCommandQueue_wrap;
+    dispatch.clReleaseCommandQueue = &clReleaseCommandQueue_wrap;
+    dispatch.clGetCommandQueueInfo = &clGetCommandQueueInfo_wrap;
+    dispatch.clSetCommandQueueProperty = &clSetCommandQueueProperty_wrap;
+    dispatch.clCreateBuffer = &clCreateBuffer_wrap;
+    dispatch.clCreateImage2D = &clCreateImage2D_wrap;
+    dispatch.clCreateImage3D = &clCreateImage3D_wrap;
+    dispatch.clRetainMemObject = &clRetainMemObject_wrap;
+    dispatch.clReleaseMemObject = &clReleaseMemObject_wrap;
+    dispatch.clGetSupportedImageFormats = &clGetSupportedImageFormats_wrap;
+    dispatch.clGetMemObjectInfo = &clGetMemObjectInfo_wrap;
+    dispatch.clGetImageInfo = &clGetImageInfo_wrap;
+    dispatch.clCreateSampler = &clCreateSampler_wrap;
+    dispatch.clRetainSampler = &clRetainSampler_wrap;
+    dispatch.clReleaseSampler = &clReleaseSampler_wrap;
+    dispatch.clGetSamplerInfo = &clGetSamplerInfo_wrap;
+    dispatch.clCreateProgramWithSource = &clCreateProgramWithSource_wrap;
+    dispatch.clCreateProgramWithBinary = &clCreateProgramWithBinary_wrap;
+    dispatch.clRetainProgram = &clRetainProgram_wrap;
+    dispatch.clReleaseProgram = &clReleaseProgram_wrap;
+    dispatch.clBuildProgram = &clBuildProgram_wrap;
+    dispatch.clUnloadCompiler = &clUnloadCompiler_wrap;
+    dispatch.clGetProgramInfo = &clGetProgramInfo_wrap;
+    dispatch.clGetProgramBuildInfo = &clGetProgramBuildInfo_wrap;
+    dispatch.clCreateKernel = &clCreateKernel_wrap;
+    dispatch.clCreateKernelsInProgram = &clCreateKernelsInProgram_wrap;
+    dispatch.clRetainKernel = &clRetainKernel_wrap;
+    dispatch.clReleaseKernel = &clReleaseKernel_wrap;
+    dispatch.clSetKernelArg = &clSetKernelArg_wrap;
+    dispatch.clGetKernelInfo = &clGetKernelInfo_wrap;
+    dispatch.clGetKernelWorkGroupInfo = &clGetKernelWorkGroupInfo_wrap;
+    dispatch.clWaitForEvents = &clWaitForEvents_wrap;
+    dispatch.clGetEventInfo = &clGetEventInfo_wrap;
+    dispatch.clRetainEvent = &clRetainEvent_wrap;
+    dispatch.clReleaseEvent = &clReleaseEvent_wrap;
+    dispatch.clGetEventProfilingInfo = &clGetEventProfilingInfo_wrap;
+    dispatch.clFlush = &clFlush_wrap;
+    dispatch.clFinish = &clFinish_wrap;
+    dispatch.clEnqueueReadBuffer = &clEnqueueReadBuffer_wrap;
+    dispatch.clEnqueueWriteBuffer = &clEnqueueWriteBuffer_wrap;
+    dispatch.clEnqueueCopyBuffer = &clEnqueueCopyBuffer_wrap;
+    dispatch.clEnqueueReadImage = &clEnqueueReadImage_wrap;
+    dispatch.clEnqueueWriteImage = &clEnqueueWriteImage_wrap;
+    dispatch.clEnqueueCopyImage = &clEnqueueCopyImage_wrap;
+    dispatch.clEnqueueCopyImageToBuffer = &clEnqueueCopyImageToBuffer_wrap;
+    dispatch.clEnqueueCopyBufferToImage = &clEnqueueCopyBufferToImage_wrap;
+    dispatch.clEnqueueMapBuffer = &clEnqueueMapBuffer_wrap;
+    dispatch.clEnqueueMapImage = &clEnqueueMapImage_wrap;
+    dispatch.clEnqueueUnmapMemObject = &clEnqueueUnmapMemObject_wrap;
+    dispatch.clEnqueueNDRangeKernel = &clEnqueueNDRangeKernel_wrap;
+    dispatch.clEnqueueTask = &clEnqueueTask_wrap;
+    dispatch.clEnqueueNativeKernel = &clEnqueueNativeKernel_wrap;
+    dispatch.clEnqueueMarker = &clEnqueueMarker_wrap;
+    dispatch.clEnqueueWaitForEvents = &clEnqueueWaitForEvents_wrap;
+    dispatch.clEnqueueBarrier = &clEnqueueBarrier_wrap;
+    dispatch.clGetExtensionFunctionAddress = &clGetExtensionFunctionAddress_wrap;
+    dispatch.clCreateFromGLBuffer = &clCreateFromGLBuffer_wrap;
+    dispatch.clCreateFromGLTexture2D = &clCreateFromGLTexture2D_wrap;
+    dispatch.clCreateFromGLTexture3D = &clCreateFromGLTexture3D_wrap;
+    dispatch.clCreateFromGLRenderbuffer = &clCreateFromGLRenderbuffer_wrap;
+    dispatch.clGetGLObjectInfo = &clGetGLObjectInfo_wrap;
+    dispatch.clGetGLTextureInfo = &clGetGLTextureInfo_wrap;
+    dispatch.clEnqueueAcquireGLObjects = &clEnqueueAcquireGLObjects_wrap;
+    dispatch.clEnqueueReleaseGLObjects = &clEnqueueReleaseGLObjects_wrap;
+    dispatch.clGetGLContextInfoKHR = &clGetGLContextInfoKHR_wrap;
+
+  /* cl_khr_d3d10_sharing */
+#if defined(_WIN32)
+    dispatch.clGetDeviceIDsFromD3D10KHR = &clGetDeviceIDsFromD3D10KHR_wrap;
+    dispatch.clCreateFromD3D10BufferKHR = &clCreateFromD3D10BufferKHR_wrap;
+    dispatch.clCreateFromD3D10Texture2DKHR = &clCreateFromD3D10Texture2DKHR_wrap;
+    dispatch.clCreateFromD3D10Texture3DKHR = &clCreateFromD3D10Texture3DKHR_wrap;
+    dispatch.clEnqueueAcquireD3D10ObjectsKHR = &clEnqueueAcquireD3D10ObjectsKHR_wrap;
+    dispatch.clEnqueueReleaseD3D10ObjectsKHR = &clEnqueueReleaseD3D10ObjectsKHR_wrap;
+#else
+    dispatch.clGetDeviceIDsFromD3D10KHR = NULL;
+    dispatch.clCreateFromD3D10BufferKHR = NULL;
+    dispatch.clCreateFromD3D10Texture2DKHR = NULL;
+    dispatch.clCreateFromD3D10Texture3DKHR = NULL;
+    dispatch.clEnqueueAcquireD3D10ObjectsKHR = NULL;
+    dispatch.clEnqueueReleaseD3D10ObjectsKHR = NULL;
+#endif
+
+  /* OpenCL 1.1 */
+    dispatch.clSetEventCallback = &clSetEventCallback_wrap;
+    dispatch.clCreateSubBuffer = &clCreateSubBuffer_wrap;
+    dispatch.clSetMemObjectDestructorCallback = &clSetMemObjectDestructorCallback_wrap;
+    dispatch.clCreateUserEvent = &clCreateUserEvent_wrap;
+    dispatch.clSetUserEventStatus = &clSetUserEventStatus_wrap;
+    dispatch.clEnqueueReadBufferRect = &clEnqueueReadBufferRect_wrap;
+    dispatch.clEnqueueWriteBufferRect = &clEnqueueWriteBufferRect_wrap;
+    dispatch.clEnqueueCopyBufferRect = &clEnqueueCopyBufferRect_wrap;
+
+  /* cl_ext_device_fission */
+    dispatch.clCreateSubDevicesEXT = &clCreateSubDevicesEXT_wrap;
+    dispatch.clRetainDeviceEXT = &clRetainDeviceEXT_wrap;
+    dispatch.clReleaseDeviceEXT = &clReleaseDeviceEXT_wrap;
+
+  /* cl_khr_gl_event */
+    dispatch.clCreateEventFromGLsyncKHR = &clCreateEventFromGLsyncKHR_wrap;
+
+  /* OpenCL 1.2 */
+    dispatch.clCreateSubDevices = &clCreateSubDevices_wrap;
+    dispatch.clRetainDevice = &clRetainDevice_wrap;
+    dispatch.clReleaseDevice = &clReleaseDevice_wrap;
+    dispatch.clCreateImage = &clCreateImage_wrap;
+    dispatch.clCreateProgramWithBuiltInKernels = &clCreateProgramWithBuiltInKernels_wrap;
+    dispatch.clCompileProgram = &clCompileProgram_wrap;
+    dispatch.clLinkProgram = &clLinkProgram_wrap;
+    dispatch.clUnloadPlatformCompiler = &clUnloadPlatformCompiler_wrap;
+    dispatch.clGetKernelArgInfo = &clGetKernelArgInfo_wrap;
+    dispatch.clEnqueueFillBuffer = &clEnqueueFillBuffer_wrap;
+    dispatch.clEnqueueFillImage = &clEnqueueFillImage_wrap;
+    dispatch.clEnqueueMigrateMemObjects = &clEnqueueMigrateMemObjects_wrap;
+    dispatch.clEnqueueMarkerWithWaitList = &clEnqueueMarkerWithWaitList_wrap;
+    dispatch.clEnqueueBarrierWithWaitList = &clEnqueueBarrierWithWaitList_wrap;
+    dispatch.clGetExtensionFunctionAddressForPlatform = &clGetExtensionFunctionAddressForPlatform_wrap;
+    dispatch.clCreateFromGLTexture = &clCreateFromGLTexture_wrap;
+
+  /* cl_khr_d3d11_sharing */
+#if defined(_WIN32)
+    dispatch.clGetDeviceIDsFromD3D11KHR = &clGetDeviceIDsFromD3D11KHR_wrap;
+    dispatch.clCreateFromD3D11BufferKHR = &clCreateFromD3D11BufferKHR_wrap;
+    dispatch.clCreateFromD3D11Texture2DKHR = &clCreateFromD3D11Texture2DKHR_wrap;
+    dispatch.clCreateFromD3D11Texture3DKHR = &clCreateFromD3D11Texture3DKHR_wrap;
+    dispatch.clCreateFromDX9MediaSurfaceKHR = &clCreateFromDX9MediaSurfaceKHR_wrap;
+    dispatch.clEnqueueAcquireD3D11ObjectsKHR = &clEnqueueAcquireD3D11ObjectsKHR_wrap;
+    dispatch.clEnqueueReleaseD3D11ObjectsKHR = &clEnqueueReleaseD3D11ObjectsKHR_wrap;
+#else
+    dispatch.clGetDeviceIDsFromD3D11KHR = NULL;
+    dispatch.clCreateFromD3D11BufferKHR = NULL;
+    dispatch.clCreateFromD3D11Texture2DKHR = NULL;
+    dispatch.clCreateFromD3D11Texture3DKHR = NULL;
+    dispatch.clCreateFromDX9MediaSurfaceKHR = NULL;
+    dispatch.clEnqueueAcquireD3D11ObjectsKHR = NULL;
+    dispatch.clEnqueueReleaseD3D11ObjectsKHR = NULL;
+#endif
+
+  /* cl_khr_dx9_media_sharing */
+#if defined(_WIN32)
+    dispatch.clGetDeviceIDsFromDX9MediaAdapterKHR = &clGetDeviceIDsFromDX9MediaAdapterKHR_wrap;
+    dispatch.clEnqueueAcquireDX9MediaSurfacesKHR = &clEnqueueAcquireDX9MediaSurfacesKHR_wrap;
+    dispatch.clEnqueueReleaseDX9MediaSurfacesKHR = &clEnqueueReleaseDX9MediaSurfacesKHR_wrap;
+#else
+    dispatch.clGetDeviceIDsFromDX9MediaAdapterKHR = NULL;
+    dispatch.clEnqueueAcquireDX9MediaSurfacesKHR = NULL;
+    dispatch.clEnqueueReleaseDX9MediaSurfacesKHR = NULL;
+#endif
+
+  /* cl_khr_egl_image */
+    dispatch.clCreateFromEGLImageKHR = &clCreateFromEGLImageKHR_wrap;
+    dispatch.clEnqueueAcquireEGLObjectsKHR = &clEnqueueAcquireEGLObjectsKHR_wrap;
+    dispatch.clEnqueueReleaseEGLObjectsKHR = &clEnqueueReleaseEGLObjectsKHR_wrap;
+
+  /* cl_khr_egl_event */
+    dispatch.clCreateEventFromEGLSyncKHR = &clCreateEventFromEGLSyncKHR_wrap;
+
+  /* OpenCL 2.0 */
+    dispatch.clCreateCommandQueueWithProperties = &clCreateCommandQueueWithProperties_wrap;
+    dispatch.clCreatePipe = &clCreatePipe_wrap;
+    dispatch.clGetPipeInfo = &clGetPipeInfo_wrap;
+    dispatch.clSVMAlloc = &clSVMAlloc_wrap;
+    dispatch.clSVMFree = &clSVMFree_wrap;
+    dispatch.clEnqueueSVMFree = &clEnqueueSVMFree_wrap;
+    dispatch.clEnqueueSVMMemcpy = &clEnqueueSVMMemcpy_wrap;
+    dispatch.clEnqueueSVMMemFill = &clEnqueueSVMMemFill_wrap;
+    dispatch.clEnqueueSVMMap = &clEnqueueSVMMap_wrap;
+    dispatch.clEnqueueSVMUnmap = &clEnqueueSVMUnmap_wrap;
+    dispatch.clCreateSamplerWithProperties = &clCreateSamplerWithProperties_wrap;
+    dispatch.clSetKernelArgSVMPointer = &clSetKernelArgSVMPointer_wrap;
+    dispatch.clSetKernelExecInfo = &clSetKernelExecInfo_wrap;
+
+  /* cl_khr_sub_groups */
+    dispatch.clGetKernelSubGroupInfoKHR = &clGetKernelSubGroupInfoKHR_wrap;
+
+  /* OpenCL 2.1 */
+    dispatch.clCloneKernel = &clCloneKernel_wrap;
+    dispatch.clCreateProgramWithIL = &clCreateProgramWithIL_wrap;
+    dispatch.clEnqueueSVMMigrateMem = &clEnqueueSVMMigrateMem_wrap;
+    dispatch.clGetDeviceAndHostTimer = &clGetDeviceAndHostTimer_wrap;
+    dispatch.clGetHostTimer = &clGetHostTimer_wrap;
+    dispatch.clGetKernelSubGroupInfo = &clGetKernelSubGroupInfo_wrap;
+    dispatch.clSetDefaultDeviceCommandQueue = &clSetDefaultDeviceCommandQueue_wrap;
+
+  /* OpenCL 2.2 */
+    dispatch.clSetProgramReleaseCallback = &clSetProgramReleaseCallback_wrap;
+    dispatch.clSetProgramSpecializationConstant = &clSetProgramSpecializationConstant_wrap;
+
+  /* OpenCL 3.0 */
+    dispatch.clCreateBufferWithProperties = &clCreateBufferWithProperties_wrap;
+    dispatch.clCreateImageWithProperties = &clCreateImageWithProperties_wrap;
+    dispatch.clSetContextDestructorCallback = &clSetContextDestructorCallback_wrap;
+}

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index a15899588847e90466500373f6d3f172693b827b..702d87978101456376f929b94585193c59245ece 100644 (file)
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -3,5 +3,8 @@ include_directories (./inc)
 add_subdirectory (log)
 add_subdirectory (driver_stub)
 add_subdirectory (loader_test)
+if (ENABLE_OPENCL_LAYERS)
+    add_subdirectory (layer)
+endif ()
 
 add_test (NAME opencl_icd_loader_test COMMAND icd_loader_test)

diff --git a/test/layer/CMakeLists.txt b/test/layer/CMakeLists.txt
new file mode 100644 (file)
index 0000000..117a3bd
--- /dev/null
+++ b/test/layer/CMakeLists.txt
@@ -0,0 +1,21 @@
+get_filename_component(PARENT_DIR ../../ ABSOLUTE)
+set (OPENCL_PRINT_LAYER_SOURCES
+    icd_print_layer.c
+    icd_print_layer.h
+    icd_print_layer_generated.c
+    ${PARENT_DIR}/include/cl_icd_layer.h)
+
+if (WIN32)
+    list (APPEND OPENCL_PRINT_LAYER_SOURCES icd_print_layer.def)
+else ()
+    if (NOT APPLE)
+        list (APPEND OPENCL_PRINT_LAYER_SOURCES icd_print_layer.map)
+    endif ()
+endif ()
+
+add_library (PrintLayer ${OPENCL_PRINT_LAYER_SOURCES})
+target_include_directories(PrintLayer PRIVATE ${PARENT_DIR}/include)
+
+if (NOT WIN32 AND NOT APPLE)
+  set_target_properties (PrintLayer PROPERTIES LINK_FLAGS "-Wl,--version-script -Wl,${CMAKE_CURRENT_SOURCE_DIR}/icd_print_layer.map")
+endif ()

diff --git a/test/layer/icd_print_layer.c b/test/layer/icd_print_layer.c
new file mode 100644 (file)
index 0000000..dcc7ed7
--- /dev/null
+++ b/test/layer/icd_print_layer.c
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2020 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.
+ *
+ * OpenCL is a trademark of Apple Inc. used under license by Khronos.
+ */
+
+#include "icd_print_layer.h"
+
+struct _cl_icd_dispatch dispatch = {NULL};
+
+const struct _cl_icd_dispatch *tdispatch;
+
+CL_API_ENTRY cl_int CL_API_CALL
+clGetLayerInfo(
+    cl_layer_info  param_name,
+    size_t         param_value_size,
+    void          *param_value,
+    size_t        *param_value_size_ret) {
+  if (param_value_size && !param_value)
+    return CL_INVALID_VALUE;
+  if (!param_value && !param_value_size_ret)
+    return CL_INVALID_VALUE;
+  switch (param_name) {
+  case CL_LAYER_API_VERSION:
+    if (param_value_size < sizeof(cl_layer_api_version))
+      return CL_INVALID_VALUE;
+    if (param_value)
+      *((cl_layer_api_version *)param_value) = CL_LAYER_API_VERSION_100;
+    if (param_value_size_ret)
+      *param_value_size_ret = sizeof(cl_layer_api_version);
+    break;
+  default:
+    return CL_INVALID_VALUE;
+  }
+  return CL_SUCCESS;
+}
+
+CL_API_ENTRY cl_int CL_API_CALL
+clInitLayer(
+    cl_uint                         num_entries,
+    const struct _cl_icd_dispatch  *target_dispatch,
+    cl_uint                        *num_entries_out,
+    const struct _cl_icd_dispatch **layer_dispatch_ret) {
+  if (!target_dispatch || !layer_dispatch_ret ||!num_entries_out || num_entries < sizeof(dispatch)/sizeof(dispatch.clGetPlatformIDs))
+    return CL_INVALID_VALUE;
+
+  _init_dispatch();
+
+  tdispatch = target_dispatch;
+  *layer_dispatch_ret = &dispatch;
+  *num_entries_out = sizeof(dispatch)/sizeof(dispatch.clGetPlatformIDs);
+  return CL_SUCCESS;
+}
+
+

diff --git a/test/layer/icd_print_layer.def b/test/layer/icd_print_layer.def
new file mode 100644 (file)
index 0000000..c33a80b
--- /dev/null
+++ b/test/layer/icd_print_layer.def
@@ -0,0 +1,3 @@
+EXPORTS
+clGetLayerInfo
+clInitLayer

diff --git a/test/layer/icd_print_layer.h b/test/layer/icd_print_layer.h
new file mode 100644 (file)
index 0000000..02390e5
--- /dev/null
+++ b/test/layer/icd_print_layer.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2020 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.
+ *
+ * OpenCL is a trademark of Apple Inc. used under license by Khronos.
+ */
+
+#ifndef __ICD_PRINT_LAYER_H
+#define __ICD_PRINT_LAYER_H
+
+#ifndef CL_USE_DEPRECATED_OPENCL_1_0_APIS
+#define CL_USE_DEPRECATED_OPENCL_1_0_APIS
+#endif
+
+#ifndef CL_USE_DEPRECATED_OPENCL_1_1_APIS
+#define CL_USE_DEPRECATED_OPENCL_1_1_APIS
+#endif
+
+#ifndef CL_USE_DEPRECATED_OPENCL_1_2_APIS
+#define CL_USE_DEPRECATED_OPENCL_1_2_APIS
+#endif
+
+#ifndef CL_USE_DEPRECATED_OPENCL_2_0_APIS
+#define CL_USE_DEPRECATED_OPENCL_2_0_APIS
+#endif
+
+#ifndef CL_USE_DEPRECATED_OPENCL_2_1_APIS
+#define CL_USE_DEPRECATED_OPENCL_2_1_APIS
+#endif
+
+#ifndef CL_USE_DEPRECATED_OPENCL_2_2_APIS
+#define CL_USE_DEPRECATED_OPENCL_2_2_APIS
+#endif
+
+#include <stdio.h>
+#include "cl_icd_layer.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct _cl_icd_dispatch dispatch;
+
+extern const struct _cl_icd_dispatch *tdispatch;
+
+extern void _init_dispatch(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __ICD_PRINT_LAYER_H */

diff --git a/test/layer/icd_print_layer.map b/test/layer/icd_print_layer.map
new file mode 100644 (file)
index 0000000..b32d582
--- /dev/null
+++ b/test/layer/icd_print_layer.map
@@ -0,0 +1,8 @@
+{
+    global:
+clGetLayerInfo;
+clInitLayer;
+
+    local:
+        *;
+};

diff --git a/test/layer/icd_print_layer_generated.c b/test/layer/icd_print_layer_generated.c
new file mode 100644 (file)
index 0000000..2cbb3ee
--- /dev/null
+++ b/test/layer/icd_print_layer_generated.c
@@ -0,0 +1,2746 @@
+/*
+ * Copyright (c) 2020 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.
+ *
+ * OpenCL is a trademark of Apple Inc. used under license by Khronos.
+ */
+
+#include "icd_print_layer.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// Core APIs:
+static CL_API_ENTRY cl_int CL_API_CALL clGetPlatformIDs_wrap(
+    cl_uint num_entries,
+    cl_platform_id* platforms,
+    cl_uint* num_platforms) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetPlatformIDs\n");
+return tdispatch->clGetPlatformIDs(
+            num_entries,
+            platforms,
+            num_platforms);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetPlatformInfo_wrap(
+    cl_platform_id platform,
+    cl_platform_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetPlatformInfo\n");
+return tdispatch->clGetPlatformInfo(
+            platform,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDs_wrap(
+    cl_platform_id platform,
+    cl_device_type device_type,
+    cl_uint num_entries,
+    cl_device_id* devices,
+    cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetDeviceIDs\n");
+return tdispatch->clGetDeviceIDs(
+            platform,
+            device_type,
+            num_entries,
+            devices,
+            num_devices);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceInfo_wrap(
+    cl_device_id device,
+    cl_device_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetDeviceInfo\n");
+return tdispatch->clGetDeviceInfo(
+            device,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_context CL_API_CALL clCreateContext_wrap(
+    const cl_context_properties* properties,
+    cl_uint num_devices,
+    const cl_device_id* devices,
+    void (CL_CALLBACK* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data),
+    void* user_data,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clCreateContext\n");
+return tdispatch->clCreateContext(
+            properties,
+            num_devices,
+            devices,
+            pfn_notify,
+            user_data,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_context CL_API_CALL clCreateContextFromType_wrap(
+    const cl_context_properties* properties,
+    cl_device_type device_type,
+    void (CL_CALLBACK* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data),
+    void* user_data,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clCreateContextFromType\n");
+return tdispatch->clCreateContextFromType(
+            properties,
+            device_type,
+            pfn_notify,
+            user_data,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clRetainContext_wrap(
+    cl_context context) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clRetainContext\n");
+return tdispatch->clRetainContext(
+            context);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseContext_wrap(
+    cl_context context) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clReleaseContext\n");
+return tdispatch->clReleaseContext(
+            context);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetContextInfo_wrap(
+    cl_context context,
+    cl_context_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetContextInfo\n");
+return tdispatch->clGetContextInfo(
+            context,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clRetainCommandQueue_wrap(
+    cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clRetainCommandQueue\n");
+return tdispatch->clRetainCommandQueue(
+            command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseCommandQueue_wrap(
+    cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clReleaseCommandQueue\n");
+return tdispatch->clReleaseCommandQueue(
+            command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetCommandQueueInfo_wrap(
+    cl_command_queue command_queue,
+    cl_command_queue_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetCommandQueueInfo\n");
+return tdispatch->clGetCommandQueueInfo(
+            command_queue,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateBuffer_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    size_t size,
+    void* host_ptr,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clCreateBuffer\n");
+return tdispatch->clCreateBuffer(
+            context,
+            flags,
+            size,
+            host_ptr,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clRetainMemObject_wrap(
+    cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clRetainMemObject\n");
+return tdispatch->clRetainMemObject(
+            memobj);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseMemObject_wrap(
+    cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clReleaseMemObject\n");
+return tdispatch->clReleaseMemObject(
+            memobj);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetSupportedImageFormats_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    cl_mem_object_type image_type,
+    cl_uint num_entries,
+    cl_image_format* image_formats,
+    cl_uint* num_image_formats) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetSupportedImageFormats\n");
+return tdispatch->clGetSupportedImageFormats(
+            context,
+            flags,
+            image_type,
+            num_entries,
+            image_formats,
+            num_image_formats);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetMemObjectInfo_wrap(
+    cl_mem memobj,
+    cl_mem_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetMemObjectInfo\n");
+return tdispatch->clGetMemObjectInfo(
+            memobj,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetImageInfo_wrap(
+    cl_mem image,
+    cl_image_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetImageInfo\n");
+return tdispatch->clGetImageInfo(
+            image,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clRetainSampler_wrap(
+    cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clRetainSampler\n");
+return tdispatch->clRetainSampler(
+            sampler);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseSampler_wrap(
+    cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clReleaseSampler\n");
+return tdispatch->clReleaseSampler(
+            sampler);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetSamplerInfo_wrap(
+    cl_sampler sampler,
+    cl_sampler_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetSamplerInfo\n");
+return tdispatch->clGetSamplerInfo(
+            sampler,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithSource_wrap(
+    cl_context context,
+    cl_uint count,
+    const char** strings,
+    const size_t* lengths,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clCreateProgramWithSource\n");
+return tdispatch->clCreateProgramWithSource(
+            context,
+            count,
+            strings,
+            lengths,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBinary_wrap(
+    cl_context context,
+    cl_uint num_devices,
+    const cl_device_id* device_list,
+    const size_t* lengths,
+    const unsigned char** binaries,
+    cl_int* binary_status,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clCreateProgramWithBinary\n");
+return tdispatch->clCreateProgramWithBinary(
+            context,
+            num_devices,
+            device_list,
+            lengths,
+            binaries,
+            binary_status,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clRetainProgram_wrap(
+    cl_program program) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clRetainProgram\n");
+return tdispatch->clRetainProgram(
+            program);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseProgram_wrap(
+    cl_program program) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clReleaseProgram\n");
+return tdispatch->clReleaseProgram(
+            program);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clBuildProgram_wrap(
+    cl_program program,
+    cl_uint num_devices,
+    const cl_device_id* device_list,
+    const char* options,
+    void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
+    void* user_data) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clBuildProgram\n");
+return tdispatch->clBuildProgram(
+            program,
+            num_devices,
+            device_list,
+            options,
+            pfn_notify,
+            user_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetProgramInfo_wrap(
+    cl_program program,
+    cl_program_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetProgramInfo\n");
+return tdispatch->clGetProgramInfo(
+            program,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetProgramBuildInfo_wrap(
+    cl_program program,
+    cl_device_id device,
+    cl_program_build_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetProgramBuildInfo\n");
+return tdispatch->clGetProgramBuildInfo(
+            program,
+            device,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_kernel CL_API_CALL clCreateKernel_wrap(
+    cl_program program,
+    const char* kernel_name,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clCreateKernel\n");
+return tdispatch->clCreateKernel(
+            program,
+            kernel_name,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clCreateKernelsInProgram_wrap(
+    cl_program program,
+    cl_uint num_kernels,
+    cl_kernel* kernels,
+    cl_uint* num_kernels_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clCreateKernelsInProgram\n");
+return tdispatch->clCreateKernelsInProgram(
+            program,
+            num_kernels,
+            kernels,
+            num_kernels_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clRetainKernel_wrap(
+    cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clRetainKernel\n");
+return tdispatch->clRetainKernel(
+            kernel);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseKernel_wrap(
+    cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clReleaseKernel\n");
+return tdispatch->clReleaseKernel(
+            kernel);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clSetKernelArg_wrap(
+    cl_kernel kernel,
+    cl_uint arg_index,
+    size_t arg_size,
+    const void* arg_value) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clSetKernelArg\n");
+return tdispatch->clSetKernelArg(
+            kernel,
+            arg_index,
+            arg_size,
+            arg_value);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetKernelInfo_wrap(
+    cl_kernel kernel,
+    cl_kernel_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetKernelInfo\n");
+return tdispatch->clGetKernelInfo(
+            kernel,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetKernelWorkGroupInfo_wrap(
+    cl_kernel kernel,
+    cl_device_id device,
+    cl_kernel_work_group_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetKernelWorkGroupInfo\n");
+return tdispatch->clGetKernelWorkGroupInfo(
+            kernel,
+            device,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clWaitForEvents_wrap(
+    cl_uint num_events,
+    const cl_event* event_list) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clWaitForEvents\n");
+return tdispatch->clWaitForEvents(
+            num_events,
+            event_list);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetEventInfo_wrap(
+    cl_event event,
+    cl_event_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetEventInfo\n");
+return tdispatch->clGetEventInfo(
+            event,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clRetainEvent_wrap(
+    cl_event event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clRetainEvent\n");
+return tdispatch->clRetainEvent(
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseEvent_wrap(
+    cl_event event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clReleaseEvent\n");
+return tdispatch->clReleaseEvent(
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetEventProfilingInfo_wrap(
+    cl_event event,
+    cl_profiling_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetEventProfilingInfo\n");
+return tdispatch->clGetEventProfilingInfo(
+            event,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clFlush_wrap(
+    cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clFlush\n");
+return tdispatch->clFlush(
+            command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clFinish_wrap(
+    cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clFinish\n");
+return tdispatch->clFinish(
+            command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBuffer_wrap(
+    cl_command_queue command_queue,
+    cl_mem buffer,
+    cl_bool blocking_read,
+    size_t offset,
+    size_t size,
+    void* ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueReadBuffer\n");
+return tdispatch->clEnqueueReadBuffer(
+            command_queue,
+            buffer,
+            blocking_read,
+            offset,
+            size,
+            ptr,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBuffer_wrap(
+    cl_command_queue command_queue,
+    cl_mem buffer,
+    cl_bool blocking_write,
+    size_t offset,
+    size_t size,
+    const void* ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueWriteBuffer\n");
+return tdispatch->clEnqueueWriteBuffer(
+            command_queue,
+            buffer,
+            blocking_write,
+            offset,
+            size,
+            ptr,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBuffer_wrap(
+    cl_command_queue command_queue,
+    cl_mem src_buffer,
+    cl_mem dst_buffer,
+    size_t src_offset,
+    size_t dst_offset,
+    size_t size,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueCopyBuffer\n");
+return tdispatch->clEnqueueCopyBuffer(
+            command_queue,
+            src_buffer,
+            dst_buffer,
+            src_offset,
+            dst_offset,
+            size,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadImage_wrap(
+    cl_command_queue command_queue,
+    cl_mem image,
+    cl_bool blocking_read,
+    const size_t* origin,
+    const size_t* region,
+    size_t row_pitch,
+    size_t slice_pitch,
+    void* ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueReadImage\n");
+return tdispatch->clEnqueueReadImage(
+            command_queue,
+            image,
+            blocking_read,
+            origin,
+            region,
+            row_pitch,
+            slice_pitch,
+            ptr,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteImage_wrap(
+    cl_command_queue command_queue,
+    cl_mem image,
+    cl_bool blocking_write,
+    const size_t* origin,
+    const size_t* region,
+    size_t input_row_pitch,
+    size_t input_slice_pitch,
+    const void* ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueWriteImage\n");
+return tdispatch->clEnqueueWriteImage(
+            command_queue,
+            image,
+            blocking_write,
+            origin,
+            region,
+            input_row_pitch,
+            input_slice_pitch,
+            ptr,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImage_wrap(
+    cl_command_queue command_queue,
+    cl_mem src_image,
+    cl_mem dst_image,
+    const size_t* src_origin,
+    const size_t* dst_origin,
+    const size_t* region,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueCopyImage\n");
+return tdispatch->clEnqueueCopyImage(
+            command_queue,
+            src_image,
+            dst_image,
+            src_origin,
+            dst_origin,
+            region,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImageToBuffer_wrap(
+    cl_command_queue command_queue,
+    cl_mem src_image,
+    cl_mem dst_buffer,
+    const size_t* src_origin,
+    const size_t* region,
+    size_t dst_offset,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueCopyImageToBuffer\n");
+return tdispatch->clEnqueueCopyImageToBuffer(
+            command_queue,
+            src_image,
+            dst_buffer,
+            src_origin,
+            region,
+            dst_offset,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferToImage_wrap(
+    cl_command_queue command_queue,
+    cl_mem src_buffer,
+    cl_mem dst_image,
+    size_t src_offset,
+    const size_t* dst_origin,
+    const size_t* region,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueCopyBufferToImage\n");
+return tdispatch->clEnqueueCopyBufferToImage(
+            command_queue,
+            src_buffer,
+            dst_image,
+            src_offset,
+            dst_origin,
+            region,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY void* CL_API_CALL clEnqueueMapBuffer_wrap(
+    cl_command_queue command_queue,
+    cl_mem buffer,
+    cl_bool blocking_map,
+    cl_map_flags map_flags,
+    size_t offset,
+    size_t size,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueMapBuffer\n");
+return tdispatch->clEnqueueMapBuffer(
+            command_queue,
+            buffer,
+            blocking_map,
+            map_flags,
+            offset,
+            size,
+            num_events_in_wait_list,
+            event_wait_list,
+            event,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY void* CL_API_CALL clEnqueueMapImage_wrap(
+    cl_command_queue command_queue,
+    cl_mem image,
+    cl_bool blocking_map,
+    cl_map_flags map_flags,
+    const size_t* origin,
+    const size_t* region,
+    size_t* image_row_pitch,
+    size_t* image_slice_pitch,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueMapImage\n");
+return tdispatch->clEnqueueMapImage(
+            command_queue,
+            image,
+            blocking_map,
+            map_flags,
+            origin,
+            region,
+            image_row_pitch,
+            image_slice_pitch,
+            num_events_in_wait_list,
+            event_wait_list,
+            event,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueUnmapMemObject_wrap(
+    cl_command_queue command_queue,
+    cl_mem memobj,
+    void* mapped_ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueUnmapMemObject\n");
+return tdispatch->clEnqueueUnmapMemObject(
+            command_queue,
+            memobj,
+            mapped_ptr,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueNDRangeKernel_wrap(
+    cl_command_queue command_queue,
+    cl_kernel kernel,
+    cl_uint work_dim,
+    const size_t* global_work_offset,
+    const size_t* global_work_size,
+    const size_t* local_work_size,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueNDRangeKernel\n");
+return tdispatch->clEnqueueNDRangeKernel(
+            command_queue,
+            kernel,
+            work_dim,
+            global_work_offset,
+            global_work_size,
+            local_work_size,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueNativeKernel_wrap(
+    cl_command_queue command_queue,
+    void (CL_CALLBACK* user_func)(void*),
+    void* args,
+    size_t cb_args,
+    cl_uint num_mem_objects,
+    const cl_mem* mem_list,
+    const void** args_mem_loc,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueNativeKernel\n");
+return tdispatch->clEnqueueNativeKernel(
+            command_queue,
+            user_func,
+            args,
+            cb_args,
+            num_mem_objects,
+            mem_list,
+            args_mem_loc,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clSetCommandQueueProperty_wrap(
+    cl_command_queue command_queue,
+    cl_command_queue_properties properties,
+    cl_bool enable,
+    cl_command_queue_properties* old_properties) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED
+{
+printf("clSetCommandQueueProperty\n");
+return tdispatch->clSetCommandQueueProperty(
+            command_queue,
+            properties,
+            enable,
+            old_properties);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateImage2D_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    const cl_image_format* image_format,
+    size_t image_width,
+    size_t image_height,
+    size_t image_row_pitch,
+    void* host_ptr,
+    cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+printf("clCreateImage2D\n");
+return tdispatch->clCreateImage2D(
+            context,
+            flags,
+            image_format,
+            image_width,
+            image_height,
+            image_row_pitch,
+            host_ptr,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateImage3D_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    const cl_image_format* image_format,
+    size_t image_width,
+    size_t image_height,
+    size_t image_depth,
+    size_t image_row_pitch,
+    size_t image_slice_pitch,
+    void* host_ptr,
+    cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+printf("clCreateImage3D\n");
+return tdispatch->clCreateImage3D(
+            context,
+            flags,
+            image_format,
+            image_width,
+            image_height,
+            image_depth,
+            image_row_pitch,
+            image_slice_pitch,
+            host_ptr,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarker_wrap(
+    cl_command_queue command_queue,
+    cl_event* event) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+printf("clEnqueueMarker\n");
+return tdispatch->clEnqueueMarker(
+            command_queue,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWaitForEvents_wrap(
+    cl_command_queue command_queue,
+    cl_uint num_events,
+    const cl_event* event_list) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+printf("clEnqueueWaitForEvents\n");
+return tdispatch->clEnqueueWaitForEvents(
+            command_queue,
+            num_events,
+            event_list);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrier_wrap(
+    cl_command_queue command_queue) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+printf("clEnqueueBarrier\n");
+return tdispatch->clEnqueueBarrier(
+            command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clUnloadCompiler_wrap(
+    void ) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+printf("clUnloadCompiler\n");
+return tdispatch->clUnloadCompiler(
+            );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddress_wrap(
+    const char* func_name) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+printf("clGetExtensionFunctionAddress\n");
+return tdispatch->clGetExtensionFunctionAddress(
+            func_name);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueue_wrap(
+    cl_context context,
+    cl_device_id device,
+    cl_command_queue_properties properties,
+    cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_2_DEPRECATED
+{
+printf("clCreateCommandQueue\n");
+return tdispatch->clCreateCommandQueue(
+            context,
+            device,
+            properties,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_sampler CL_API_CALL clCreateSampler_wrap(
+    cl_context context,
+    cl_bool normalized_coords,
+    cl_addressing_mode addressing_mode,
+    cl_filter_mode filter_mode,
+    cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_2_DEPRECATED
+{
+printf("clCreateSampler\n");
+return tdispatch->clCreateSampler(
+            context,
+            normalized_coords,
+            addressing_mode,
+            filter_mode,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueTask_wrap(
+    cl_command_queue command_queue,
+    cl_kernel kernel,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_EXT_SUFFIX__VERSION_1_2_DEPRECATED
+{
+printf("clEnqueueTask\n");
+return tdispatch->clEnqueueTask(
+            command_queue,
+            kernel,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateSubBuffer_wrap(
+    cl_mem buffer,
+    cl_mem_flags flags,
+    cl_buffer_create_type buffer_create_type,
+    const void* buffer_create_info,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1
+{
+printf("clCreateSubBuffer\n");
+return tdispatch->clCreateSubBuffer(
+            buffer,
+            flags,
+            buffer_create_type,
+            buffer_create_info,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clSetMemObjectDestructorCallback_wrap(
+    cl_mem memobj,
+    void (CL_CALLBACK* pfn_notify)(cl_mem memobj, void* user_data),
+    void* user_data) CL_API_SUFFIX__VERSION_1_1
+{
+printf("clSetMemObjectDestructorCallback\n");
+return tdispatch->clSetMemObjectDestructorCallback(
+            memobj,
+            pfn_notify,
+            user_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_event CL_API_CALL clCreateUserEvent_wrap(
+    cl_context context,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1
+{
+printf("clCreateUserEvent\n");
+return tdispatch->clCreateUserEvent(
+            context,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clSetUserEventStatus_wrap(
+    cl_event event,
+    cl_int execution_status) CL_API_SUFFIX__VERSION_1_1
+{
+printf("clSetUserEventStatus\n");
+return tdispatch->clSetUserEventStatus(
+            event,
+            execution_status);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clSetEventCallback_wrap(
+    cl_event event,
+    cl_int command_exec_callback_type,
+    void (CL_CALLBACK* pfn_notify)(cl_event event, cl_int event_command_status, void *user_data),
+    void* user_data) CL_API_SUFFIX__VERSION_1_1
+{
+printf("clSetEventCallback\n");
+return tdispatch->clSetEventCallback(
+            event,
+            command_exec_callback_type,
+            pfn_notify,
+            user_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBufferRect_wrap(
+    cl_command_queue command_queue,
+    cl_mem buffer,
+    cl_bool blocking_read,
+    const size_t* buffer_offset,
+    const size_t* host_offset,
+    const size_t* region,
+    size_t buffer_row_pitch,
+    size_t buffer_slice_pitch,
+    size_t host_row_pitch,
+    size_t host_slice_pitch,
+    void* ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_1
+{
+printf("clEnqueueReadBufferRect\n");
+return tdispatch->clEnqueueReadBufferRect(
+            command_queue,
+            buffer,
+            blocking_read,
+            buffer_offset,
+            host_offset,
+            region,
+            buffer_row_pitch,
+            buffer_slice_pitch,
+            host_row_pitch,
+            host_slice_pitch,
+            ptr,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBufferRect_wrap(
+    cl_command_queue command_queue,
+    cl_mem buffer,
+    cl_bool blocking_write,
+    const size_t* buffer_offset,
+    const size_t* host_offset,
+    const size_t* region,
+    size_t buffer_row_pitch,
+    size_t buffer_slice_pitch,
+    size_t host_row_pitch,
+    size_t host_slice_pitch,
+    const void* ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_1
+{
+printf("clEnqueueWriteBufferRect\n");
+return tdispatch->clEnqueueWriteBufferRect(
+            command_queue,
+            buffer,
+            blocking_write,
+            buffer_offset,
+            host_offset,
+            region,
+            buffer_row_pitch,
+            buffer_slice_pitch,
+            host_row_pitch,
+            host_slice_pitch,
+            ptr,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferRect_wrap(
+    cl_command_queue command_queue,
+    cl_mem src_buffer,
+    cl_mem dst_buffer,
+    const size_t* src_origin,
+    const size_t* dst_origin,
+    const size_t* region,
+    size_t src_row_pitch,
+    size_t src_slice_pitch,
+    size_t dst_row_pitch,
+    size_t dst_slice_pitch,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_1
+{
+printf("clEnqueueCopyBufferRect\n");
+return tdispatch->clEnqueueCopyBufferRect(
+            command_queue,
+            src_buffer,
+            dst_buffer,
+            src_origin,
+            dst_origin,
+            region,
+            src_row_pitch,
+            src_slice_pitch,
+            dst_row_pitch,
+            dst_slice_pitch,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevices_wrap(
+    cl_device_id in_device,
+    const cl_device_partition_property* properties,
+    cl_uint num_devices,
+    cl_device_id* out_devices,
+    cl_uint* num_devices_ret) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clCreateSubDevices\n");
+return tdispatch->clCreateSubDevices(
+            in_device,
+            properties,
+            num_devices,
+            out_devices,
+            num_devices_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clRetainDevice_wrap(
+    cl_device_id device) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clRetainDevice\n");
+return tdispatch->clRetainDevice(
+            device);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseDevice_wrap(
+    cl_device_id device) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clReleaseDevice\n");
+return tdispatch->clReleaseDevice(
+            device);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateImage_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    const cl_image_format* image_format,
+    const cl_image_desc* image_desc,
+    void* host_ptr,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clCreateImage\n");
+return tdispatch->clCreateImage(
+            context,
+            flags,
+            image_format,
+            image_desc,
+            host_ptr,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBuiltInKernels_wrap(
+    cl_context context,
+    cl_uint num_devices,
+    const cl_device_id* device_list,
+    const char* kernel_names,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clCreateProgramWithBuiltInKernels\n");
+return tdispatch->clCreateProgramWithBuiltInKernels(
+            context,
+            num_devices,
+            device_list,
+            kernel_names,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clCompileProgram_wrap(
+    cl_program program,
+    cl_uint num_devices,
+    const cl_device_id* device_list,
+    const char* options,
+    cl_uint num_input_headers,
+    const cl_program* input_headers,
+    const char** header_include_names,
+    void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
+    void* user_data) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clCompileProgram\n");
+return tdispatch->clCompileProgram(
+            program,
+            num_devices,
+            device_list,
+            options,
+            num_input_headers,
+            input_headers,
+            header_include_names,
+            pfn_notify,
+            user_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_program CL_API_CALL clLinkProgram_wrap(
+    cl_context context,
+    cl_uint num_devices,
+    const cl_device_id* device_list,
+    const char* options,
+    cl_uint num_input_programs,
+    const cl_program* input_programs,
+    void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
+    void* user_data,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clLinkProgram\n");
+return tdispatch->clLinkProgram(
+            context,
+            num_devices,
+            device_list,
+            options,
+            num_input_programs,
+            input_programs,
+            pfn_notify,
+            user_data,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clUnloadPlatformCompiler_wrap(
+    cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clUnloadPlatformCompiler\n");
+return tdispatch->clUnloadPlatformCompiler(
+            platform);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetKernelArgInfo_wrap(
+    cl_kernel kernel,
+    cl_uint arg_index,
+    cl_kernel_arg_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clGetKernelArgInfo\n");
+return tdispatch->clGetKernelArgInfo(
+            kernel,
+            arg_index,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillBuffer_wrap(
+    cl_command_queue command_queue,
+    cl_mem buffer,
+    const void* pattern,
+    size_t pattern_size,
+    size_t offset,
+    size_t size,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clEnqueueFillBuffer\n");
+return tdispatch->clEnqueueFillBuffer(
+            command_queue,
+            buffer,
+            pattern,
+            pattern_size,
+            offset,
+            size,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillImage_wrap(
+    cl_command_queue command_queue,
+    cl_mem image,
+    const void* fill_color,
+    const size_t* origin,
+    const size_t* region,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clEnqueueFillImage\n");
+return tdispatch->clEnqueueFillImage(
+            command_queue,
+            image,
+            fill_color,
+            origin,
+            region,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemObjects_wrap(
+    cl_command_queue command_queue,
+    cl_uint num_mem_objects,
+    const cl_mem* mem_objects,
+    cl_mem_migration_flags flags,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clEnqueueMigrateMemObjects\n");
+return tdispatch->clEnqueueMigrateMemObjects(
+            command_queue,
+            num_mem_objects,
+            mem_objects,
+            flags,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarkerWithWaitList_wrap(
+    cl_command_queue command_queue,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clEnqueueMarkerWithWaitList\n");
+return tdispatch->clEnqueueMarkerWithWaitList(
+            command_queue,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrierWithWaitList_wrap(
+    cl_command_queue command_queue,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clEnqueueBarrierWithWaitList\n");
+return tdispatch->clEnqueueBarrierWithWaitList(
+            command_queue,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddressForPlatform_wrap(
+    cl_platform_id platform,
+    const char* func_name) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clGetExtensionFunctionAddressForPlatform\n");
+return tdispatch->clGetExtensionFunctionAddressForPlatform(
+            platform,
+            func_name);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties_wrap(
+    cl_context context,
+    cl_device_id device,
+    const cl_queue_properties* properties,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0
+{
+printf("clCreateCommandQueueWithProperties\n");
+return tdispatch->clCreateCommandQueueWithProperties(
+            context,
+            device,
+            properties,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_mem CL_API_CALL clCreatePipe_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    cl_uint pipe_packet_size,
+    cl_uint pipe_max_packets,
+    const cl_pipe_properties* properties,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0
+{
+printf("clCreatePipe\n");
+return tdispatch->clCreatePipe(
+            context,
+            flags,
+            pipe_packet_size,
+            pipe_max_packets,
+            properties,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetPipeInfo_wrap(
+    cl_mem pipe,
+    cl_pipe_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_2_0
+{
+printf("clGetPipeInfo\n");
+return tdispatch->clGetPipeInfo(
+            pipe,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY void* CL_API_CALL clSVMAlloc_wrap(
+    cl_context context,
+    cl_svm_mem_flags flags,
+    size_t size,
+    cl_uint alignment) CL_API_SUFFIX__VERSION_2_0
+{
+printf("clSVMAlloc\n");
+return tdispatch->clSVMAlloc(
+            context,
+            flags,
+            size,
+            alignment);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY void CL_API_CALL clSVMFree_wrap(
+    cl_context context,
+    void* svm_pointer) CL_API_SUFFIX__VERSION_2_0
+{
+printf("clSVMFree\n");
+return tdispatch->clSVMFree(
+            context,
+            svm_pointer);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_sampler CL_API_CALL clCreateSamplerWithProperties_wrap(
+    cl_context context,
+    const cl_sampler_properties* sampler_properties,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0
+{
+printf("clCreateSamplerWithProperties\n");
+return tdispatch->clCreateSamplerWithProperties(
+            context,
+            sampler_properties,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgSVMPointer_wrap(
+    cl_kernel kernel,
+    cl_uint arg_index,
+    const void* arg_value) CL_API_SUFFIX__VERSION_2_0
+{
+printf("clSetKernelArgSVMPointer\n");
+return tdispatch->clSetKernelArgSVMPointer(
+            kernel,
+            arg_index,
+            arg_value);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clSetKernelExecInfo_wrap(
+    cl_kernel kernel,
+    cl_kernel_exec_info param_name,
+    size_t param_value_size,
+    const void* param_value) CL_API_SUFFIX__VERSION_2_0
+{
+printf("clSetKernelExecInfo\n");
+return tdispatch->clSetKernelExecInfo(
+            kernel,
+            param_name,
+            param_value_size,
+            param_value);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMFree_wrap(
+    cl_command_queue command_queue,
+    cl_uint num_svm_pointers,
+    void* svm_pointers[],
+    void (CL_CALLBACK* pfn_free_func)(cl_command_queue queue, cl_uint num_svm_pointers, void* svm_pointers[], void* user_data),
+    void* user_data,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_2_0
+{
+printf("clEnqueueSVMFree\n");
+return tdispatch->clEnqueueSVMFree(
+            command_queue,
+            num_svm_pointers,
+            svm_pointers,
+            pfn_free_func,
+            user_data,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemcpy_wrap(
+    cl_command_queue command_queue,
+    cl_bool blocking_copy,
+    void* dst_ptr,
+    const void* src_ptr,
+    size_t size,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_2_0
+{
+printf("clEnqueueSVMMemcpy\n");
+return tdispatch->clEnqueueSVMMemcpy(
+            command_queue,
+            blocking_copy,
+            dst_ptr,
+            src_ptr,
+            size,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemFill_wrap(
+    cl_command_queue command_queue,
+    void* svm_ptr,
+    const void* pattern,
+    size_t pattern_size,
+    size_t size,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_2_0
+{
+printf("clEnqueueSVMMemFill\n");
+return tdispatch->clEnqueueSVMMemFill(
+            command_queue,
+            svm_ptr,
+            pattern,
+            pattern_size,
+            size,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMap_wrap(
+    cl_command_queue command_queue,
+    cl_bool blocking_map,
+    cl_map_flags flags,
+    void* svm_ptr,
+    size_t size,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_2_0
+{
+printf("clEnqueueSVMMap\n");
+return tdispatch->clEnqueueSVMMap(
+            command_queue,
+            blocking_map,
+            flags,
+            svm_ptr,
+            size,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMUnmap_wrap(
+    cl_command_queue command_queue,
+    void* svm_ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_2_0
+{
+printf("clEnqueueSVMUnmap\n");
+return tdispatch->clEnqueueSVMUnmap(
+            command_queue,
+            svm_ptr,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clSetDefaultDeviceCommandQueue_wrap(
+    cl_context context,
+    cl_device_id device,
+    cl_command_queue command_queue) CL_API_SUFFIX__VERSION_2_1
+{
+printf("clSetDefaultDeviceCommandQueue\n");
+return tdispatch->clSetDefaultDeviceCommandQueue(
+            context,
+            device,
+            command_queue);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceAndHostTimer_wrap(
+    cl_device_id device,
+    cl_ulong* device_timestamp,
+    cl_ulong* host_timestamp) CL_API_SUFFIX__VERSION_2_1
+{
+printf("clGetDeviceAndHostTimer\n");
+return tdispatch->clGetDeviceAndHostTimer(
+            device,
+            device_timestamp,
+            host_timestamp);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetHostTimer_wrap(
+    cl_device_id device,
+    cl_ulong* host_timestamp) CL_API_SUFFIX__VERSION_2_1
+{
+printf("clGetHostTimer\n");
+return tdispatch->clGetHostTimer(
+            device,
+            host_timestamp);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithIL_wrap(
+    cl_context context,
+    const void* il,
+    size_t length,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1
+{
+printf("clCreateProgramWithIL\n");
+return tdispatch->clCreateProgramWithIL(
+            context,
+            il,
+            length,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_kernel CL_API_CALL clCloneKernel_wrap(
+    cl_kernel source_kernel,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1
+{
+printf("clCloneKernel\n");
+return tdispatch->clCloneKernel(
+            source_kernel,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfo_wrap(
+    cl_kernel kernel,
+    cl_device_id device,
+    cl_kernel_sub_group_info param_name,
+    size_t input_value_size,
+    const void* input_value,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_2_1
+{
+printf("clGetKernelSubGroupInfo\n");
+return tdispatch->clGetKernelSubGroupInfo(
+            kernel,
+            device,
+            param_name,
+            input_value_size,
+            input_value,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMigrateMem_wrap(
+    cl_command_queue command_queue,
+    cl_uint num_svm_pointers,
+    const void** svm_pointers,
+    const size_t* sizes,
+    cl_mem_migration_flags flags,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_2_1
+{
+printf("clEnqueueSVMMigrateMem\n");
+return tdispatch->clEnqueueSVMMigrateMem(
+            command_queue,
+            num_svm_pointers,
+            svm_pointers,
+            sizes,
+            flags,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clSetProgramSpecializationConstant_wrap(
+    cl_program program,
+    cl_uint spec_id,
+    size_t spec_size,
+    const void* spec_value) CL_API_SUFFIX__VERSION_2_2
+{
+printf("clSetProgramSpecializationConstant\n");
+return tdispatch->clSetProgramSpecializationConstant(
+            program,
+            spec_id,
+            spec_size,
+            spec_value);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clSetProgramReleaseCallback_wrap(
+    cl_program program,
+    void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
+    void* user_data) CL_EXT_SUFFIX__VERSION_2_2_DEPRECATED
+{
+printf("clSetProgramReleaseCallback\n");
+return tdispatch->clSetProgramReleaseCallback(
+            program,
+            pfn_notify,
+            user_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_int CL_API_CALL clSetContextDestructorCallback_wrap(
+    cl_context context,
+    void (CL_CALLBACK* pfn_notify)(cl_context context, void* user_data),
+    void* user_data) CL_API_SUFFIX__VERSION_3_0
+{
+printf("clSetContextDestructorCallback\n");
+return tdispatch->clSetContextDestructorCallback(
+            context,
+            pfn_notify,
+            user_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateBufferWithProperties_wrap(
+    cl_context context,
+    const cl_mem_properties* properties,
+    cl_mem_flags flags,
+    size_t size,
+    void* host_ptr,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_3_0
+{
+printf("clCreateBufferWithProperties\n");
+return tdispatch->clCreateBufferWithProperties(
+            context,
+            properties,
+            flags,
+            size,
+            host_ptr,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateImageWithProperties_wrap(
+    cl_context context,
+    const cl_mem_properties* properties,
+    cl_mem_flags flags,
+    const cl_image_format* image_format,
+    const cl_image_desc* image_desc,
+    void* host_ptr,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_3_0
+{
+printf("clCreateImageWithProperties\n");
+return tdispatch->clCreateImageWithProperties(
+            context,
+            properties,
+            flags,
+            image_format,
+            image_desc,
+            host_ptr,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_ext_device_fission
+static CL_API_ENTRY cl_int CL_API_CALL clReleaseDeviceEXT_wrap(
+    cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1
+{
+printf("clReleaseDeviceEXT\n");
+return tdispatch->clReleaseDeviceEXT(
+            device);
+}
+static CL_API_ENTRY cl_int CL_API_CALL clRetainDeviceEXT_wrap(
+    cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1
+{
+printf("clRetainDeviceEXT\n");
+return tdispatch->clRetainDeviceEXT(
+            device);
+}
+static CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevicesEXT_wrap(
+    cl_device_id in_device,
+    const cl_device_partition_property_ext* properties,
+    cl_uint num_entries,
+    cl_device_id* out_devices,
+    cl_uint* num_devices) CL_EXT_SUFFIX__VERSION_1_1
+{
+printf("clCreateSubDevicesEXT\n");
+return tdispatch->clCreateSubDevicesEXT(
+            in_device,
+            properties,
+            num_entries,
+            out_devices,
+            num_devices);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_khr_d3d10_sharing
+
+#if defined(_WIN32)
+static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR_wrap(
+    cl_platform_id platform,
+    cl_d3d10_device_source_khr d3d_device_source,
+    void* d3d_object,
+    cl_d3d10_device_set_khr d3d_device_set,
+    cl_uint num_entries,
+    cl_device_id* devices,
+    cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetDeviceIDsFromD3D10KHR\n");
+return tdispatch->clGetDeviceIDsFromD3D10KHR(
+            platform,
+            d3d_device_source,
+            d3d_object,
+            d3d_device_set,
+            num_entries,
+            devices,
+            num_devices);
+}
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10BufferKHR_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    ID3D10Buffer* resource,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clCreateFromD3D10BufferKHR\n");
+return tdispatch->clCreateFromD3D10BufferKHR(
+            context,
+            flags,
+            resource,
+            errcode_ret);
+}
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    ID3D10Texture2D* resource,
+    UINT subresource,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clCreateFromD3D10Texture2DKHR\n");
+return tdispatch->clCreateFromD3D10Texture2DKHR(
+            context,
+            flags,
+            resource,
+            subresource,
+            errcode_ret);
+}
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    ID3D10Texture3D* resource,
+    UINT subresource,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clCreateFromD3D10Texture3DKHR\n");
+return tdispatch->clCreateFromD3D10Texture3DKHR(
+            context,
+            flags,
+            resource,
+            subresource,
+            errcode_ret);
+}
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR_wrap(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueAcquireD3D10ObjectsKHR\n");
+return tdispatch->clEnqueueAcquireD3D10ObjectsKHR(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR_wrap(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueReleaseD3D10ObjectsKHR\n");
+return tdispatch->clEnqueueReleaseD3D10ObjectsKHR(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+#endif // defined(_WIN32)
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_khr_d3d11_sharing
+
+#if defined(_WIN32)
+static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR_wrap(
+    cl_platform_id platform,
+    cl_d3d11_device_source_khr d3d_device_source,
+    void* d3d_object,
+    cl_d3d11_device_set_khr d3d_device_set,
+    cl_uint num_entries,
+    cl_device_id* devices,
+    cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clGetDeviceIDsFromD3D11KHR\n");
+return tdispatch->clGetDeviceIDsFromD3D11KHR(
+            platform,
+            d3d_device_source,
+            d3d_object,
+            d3d_device_set,
+            num_entries,
+            devices,
+            num_devices);
+}
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11BufferKHR_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    ID3D11Buffer* resource,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clCreateFromD3D11BufferKHR\n");
+return tdispatch->clCreateFromD3D11BufferKHR(
+            context,
+            flags,
+            resource,
+            errcode_ret);
+}
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    ID3D11Texture2D* resource,
+    UINT subresource,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clCreateFromD3D11Texture2DKHR\n");
+return tdispatch->clCreateFromD3D11Texture2DKHR(
+            context,
+            flags,
+            resource,
+            subresource,
+            errcode_ret);
+}
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    ID3D11Texture3D* resource,
+    UINT subresource,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clCreateFromD3D11Texture3DKHR\n");
+return tdispatch->clCreateFromD3D11Texture3DKHR(
+            context,
+            flags,
+            resource,
+            subresource,
+            errcode_ret);
+}
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR_wrap(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clEnqueueAcquireD3D11ObjectsKHR\n");
+return tdispatch->clEnqueueAcquireD3D11ObjectsKHR(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR_wrap(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clEnqueueReleaseD3D11ObjectsKHR\n");
+return tdispatch->clEnqueueReleaseD3D11ObjectsKHR(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+#endif // defined(_WIN32)
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_khr_dx9_media_sharing
+
+#if defined(_WIN32)
+static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR_wrap(
+    cl_platform_id platform,
+    cl_uint num_media_adapters,
+    cl_dx9_media_adapter_type_khr* media_adapter_type,
+    void* media_adapters,
+    cl_dx9_media_adapter_set_khr media_adapter_set,
+    cl_uint num_entries,
+    cl_device_id* devices,
+    cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clGetDeviceIDsFromDX9MediaAdapterKHR\n");
+return tdispatch->clGetDeviceIDsFromDX9MediaAdapterKHR(
+            platform,
+            num_media_adapters,
+            media_adapter_type,
+            media_adapters,
+            media_adapter_set,
+            num_entries,
+            devices,
+            num_devices);
+}
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    cl_dx9_media_adapter_type_khr adapter_type,
+    void* surface_info,
+    cl_uint plane,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clCreateFromDX9MediaSurfaceKHR\n");
+return tdispatch->clCreateFromDX9MediaSurfaceKHR(
+            context,
+            flags,
+            adapter_type,
+            surface_info,
+            plane,
+            errcode_ret);
+}
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR_wrap(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clEnqueueAcquireDX9MediaSurfacesKHR\n");
+return tdispatch->clEnqueueAcquireDX9MediaSurfacesKHR(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR_wrap(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clEnqueueReleaseDX9MediaSurfacesKHR\n");
+return tdispatch->clEnqueueReleaseDX9MediaSurfacesKHR(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+#endif // defined(_WIN32)
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_khr_egl_event
+static CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromEGLSyncKHR_wrap(
+    cl_context context,
+    CLeglSyncKHR sync,
+    CLeglDisplayKHR display,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clCreateEventFromEGLSyncKHR\n");
+return tdispatch->clCreateEventFromEGLSyncKHR(
+            context,
+            sync,
+            display,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_khr_egl_image
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromEGLImageKHR_wrap(
+    cl_context context,
+    CLeglDisplayKHR egldisplay,
+    CLeglImageKHR eglimage,
+    cl_mem_flags flags,
+    const cl_egl_image_properties_khr* properties,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clCreateFromEGLImageKHR\n");
+return tdispatch->clCreateFromEGLImageKHR(
+            context,
+            egldisplay,
+            eglimage,
+            flags,
+            properties,
+            errcode_ret);
+}
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR_wrap(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueAcquireEGLObjectsKHR\n");
+return tdispatch->clEnqueueAcquireEGLObjectsKHR(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR_wrap(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueReleaseEGLObjectsKHR\n");
+return tdispatch->clEnqueueReleaseEGLObjectsKHR(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_khr_gl_event
+static CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR_wrap(
+    cl_context context,
+    cl_GLsync sync,
+    cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1
+{
+printf("clCreateEventFromGLsyncKHR\n");
+return tdispatch->clCreateEventFromGLsyncKHR(
+            context,
+            sync,
+            errcode_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_khr_gl_sharing
+static CL_API_ENTRY cl_int CL_API_CALL clGetGLContextInfoKHR_wrap(
+    const cl_context_properties* properties,
+    cl_gl_context_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetGLContextInfoKHR\n");
+return tdispatch->clGetGLContextInfoKHR(
+            properties,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    cl_GLuint bufobj,
+    int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clCreateFromGLBuffer\n");
+return tdispatch->clCreateFromGLBuffer(
+            context,
+            flags,
+            bufobj,
+            errcode_ret);
+}
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    cl_GLenum target,
+    cl_GLint miplevel,
+    cl_GLuint texture,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2
+{
+printf("clCreateFromGLTexture\n");
+return tdispatch->clCreateFromGLTexture(
+            context,
+            flags,
+            target,
+            miplevel,
+            texture,
+            errcode_ret);
+}
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    cl_GLenum target,
+    cl_GLint miplevel,
+    cl_GLuint texture,
+    cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+printf("clCreateFromGLTexture2D\n");
+return tdispatch->clCreateFromGLTexture2D(
+            context,
+            flags,
+            target,
+            miplevel,
+            texture,
+            errcode_ret);
+}
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    cl_GLenum target,
+    cl_GLint miplevel,
+    cl_GLuint texture,
+    cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
+{
+printf("clCreateFromGLTexture3D\n");
+return tdispatch->clCreateFromGLTexture3D(
+            context,
+            flags,
+            target,
+            miplevel,
+            texture,
+            errcode_ret);
+}
+static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer_wrap(
+    cl_context context,
+    cl_mem_flags flags,
+    cl_GLuint renderbuffer,
+    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clCreateFromGLRenderbuffer\n");
+return tdispatch->clCreateFromGLRenderbuffer(
+            context,
+            flags,
+            renderbuffer,
+            errcode_ret);
+}
+static CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo_wrap(
+    cl_mem memobj,
+    cl_gl_object_type* gl_object_type,
+    cl_GLuint* gl_object_name) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetGLObjectInfo\n");
+return tdispatch->clGetGLObjectInfo(
+            memobj,
+            gl_object_type,
+            gl_object_name);
+}
+static CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo_wrap(
+    cl_mem memobj,
+    cl_gl_texture_info param_name,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clGetGLTextureInfo\n");
+return tdispatch->clGetGLTextureInfo(
+            memobj,
+            param_name,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects_wrap(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueAcquireGLObjects\n");
+return tdispatch->clEnqueueAcquireGLObjects(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects_wrap(
+    cl_command_queue command_queue,
+    cl_uint num_objects,
+    const cl_mem* mem_objects,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0
+{
+printf("clEnqueueReleaseGLObjects\n");
+return tdispatch->clEnqueueReleaseGLObjects(
+            command_queue,
+            num_objects,
+            mem_objects,
+            num_events_in_wait_list,
+            event_wait_list,
+            event);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// cl_khr_subgroups
+static CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfoKHR_wrap(
+    cl_kernel in_kernel,
+    cl_device_id in_device,
+    cl_kernel_sub_group_info param_name,
+    size_t input_value_size,
+    const void* input_value,
+    size_t param_value_size,
+    void* param_value,
+    size_t* param_value_size_ret) CL_EXT_SUFFIX__VERSION_2_0_DEPRECATED
+{
+printf("clGetKernelSubGroupInfoKHR\n");
+return tdispatch->clGetKernelSubGroupInfoKHR(
+            in_kernel,
+            in_device,
+            param_name,
+            input_value_size,
+            input_value,
+            param_value_size,
+            param_value,
+            param_value_size_ret);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void _init_dispatch(void) {
+    dispatch.clGetPlatformIDs = &clGetPlatformIDs_wrap;
+    dispatch.clGetPlatformInfo = &clGetPlatformInfo_wrap;
+    dispatch.clGetDeviceIDs = &clGetDeviceIDs_wrap;
+    dispatch.clGetDeviceInfo = &clGetDeviceInfo_wrap;
+    dispatch.clCreateContext = &clCreateContext_wrap;
+    dispatch.clCreateContextFromType = &clCreateContextFromType_wrap;
+    dispatch.clRetainContext = &clRetainContext_wrap;
+    dispatch.clReleaseContext = &clReleaseContext_wrap;
+    dispatch.clGetContextInfo = &clGetContextInfo_wrap;
+    dispatch.clCreateCommandQueue = &clCreateCommandQueue_wrap;
+    dispatch.clRetainCommandQueue = &clRetainCommandQueue_wrap;
+    dispatch.clReleaseCommandQueue = &clReleaseCommandQueue_wrap;
+    dispatch.clGetCommandQueueInfo = &clGetCommandQueueInfo_wrap;
+    dispatch.clSetCommandQueueProperty = &clSetCommandQueueProperty_wrap;
+    dispatch.clCreateBuffer = &clCreateBuffer_wrap;
+    dispatch.clCreateImage2D = &clCreateImage2D_wrap;
+    dispatch.clCreateImage3D = &clCreateImage3D_wrap;
+    dispatch.clRetainMemObject = &clRetainMemObject_wrap;
+    dispatch.clReleaseMemObject = &clReleaseMemObject_wrap;
+    dispatch.clGetSupportedImageFormats = &clGetSupportedImageFormats_wrap;
+    dispatch.clGetMemObjectInfo = &clGetMemObjectInfo_wrap;
+    dispatch.clGetImageInfo = &clGetImageInfo_wrap;
+    dispatch.clCreateSampler = &clCreateSampler_wrap;
+    dispatch.clRetainSampler = &clRetainSampler_wrap;
+    dispatch.clReleaseSampler = &clReleaseSampler_wrap;
+    dispatch.clGetSamplerInfo = &clGetSamplerInfo_wrap;
+    dispatch.clCreateProgramWithSource = &clCreateProgramWithSource_wrap;
+    dispatch.clCreateProgramWithBinary = &clCreateProgramWithBinary_wrap;
+    dispatch.clRetainProgram = &clRetainProgram_wrap;
+    dispatch.clReleaseProgram = &clReleaseProgram_wrap;
+    dispatch.clBuildProgram = &clBuildProgram_wrap;
+    dispatch.clUnloadCompiler = &clUnloadCompiler_wrap;
+    dispatch.clGetProgramInfo = &clGetProgramInfo_wrap;
+    dispatch.clGetProgramBuildInfo = &clGetProgramBuildInfo_wrap;
+    dispatch.clCreateKernel = &clCreateKernel_wrap;
+    dispatch.clCreateKernelsInProgram = &clCreateKernelsInProgram_wrap;
+    dispatch.clRetainKernel = &clRetainKernel_wrap;
+    dispatch.clReleaseKernel = &clReleaseKernel_wrap;
+    dispatch.clSetKernelArg = &clSetKernelArg_wrap;
+    dispatch.clGetKernelInfo = &clGetKernelInfo_wrap;
+    dispatch.clGetKernelWorkGroupInfo = &clGetKernelWorkGroupInfo_wrap;
+    dispatch.clWaitForEvents = &clWaitForEvents_wrap;
+    dispatch.clGetEventInfo = &clGetEventInfo_wrap;
+    dispatch.clRetainEvent = &clRetainEvent_wrap;
+    dispatch.clReleaseEvent = &clReleaseEvent_wrap;
+    dispatch.clGetEventProfilingInfo = &clGetEventProfilingInfo_wrap;
+    dispatch.clFlush = &clFlush_wrap;
+    dispatch.clFinish = &clFinish_wrap;
+    dispatch.clEnqueueReadBuffer = &clEnqueueReadBuffer_wrap;
+    dispatch.clEnqueueWriteBuffer = &clEnqueueWriteBuffer_wrap;
+    dispatch.clEnqueueCopyBuffer = &clEnqueueCopyBuffer_wrap;
+    dispatch.clEnqueueReadImage = &clEnqueueReadImage_wrap;
+    dispatch.clEnqueueWriteImage = &clEnqueueWriteImage_wrap;
+    dispatch.clEnqueueCopyImage = &clEnqueueCopyImage_wrap;
+    dispatch.clEnqueueCopyImageToBuffer = &clEnqueueCopyImageToBuffer_wrap;
+    dispatch.clEnqueueCopyBufferToImage = &clEnqueueCopyBufferToImage_wrap;
+    dispatch.clEnqueueMapBuffer = &clEnqueueMapBuffer_wrap;
+    dispatch.clEnqueueMapImage = &clEnqueueMapImage_wrap;
+    dispatch.clEnqueueUnmapMemObject = &clEnqueueUnmapMemObject_wrap;
+    dispatch.clEnqueueNDRangeKernel = &clEnqueueNDRangeKernel_wrap;
+    dispatch.clEnqueueTask = &clEnqueueTask_wrap;
+    dispatch.clEnqueueNativeKernel = &clEnqueueNativeKernel_wrap;
+    dispatch.clEnqueueMarker = &clEnqueueMarker_wrap;
+    dispatch.clEnqueueWaitForEvents = &clEnqueueWaitForEvents_wrap;
+    dispatch.clEnqueueBarrier = &clEnqueueBarrier_wrap;
+    dispatch.clGetExtensionFunctionAddress = &clGetExtensionFunctionAddress_wrap;
+    dispatch.clCreateFromGLBuffer = &clCreateFromGLBuffer_wrap;
+    dispatch.clCreateFromGLTexture2D = &clCreateFromGLTexture2D_wrap;
+    dispatch.clCreateFromGLTexture3D = &clCreateFromGLTexture3D_wrap;
+    dispatch.clCreateFromGLRenderbuffer = &clCreateFromGLRenderbuffer_wrap;
+    dispatch.clGetGLObjectInfo = &clGetGLObjectInfo_wrap;
+    dispatch.clGetGLTextureInfo = &clGetGLTextureInfo_wrap;
+    dispatch.clEnqueueAcquireGLObjects = &clEnqueueAcquireGLObjects_wrap;
+    dispatch.clEnqueueReleaseGLObjects = &clEnqueueReleaseGLObjects_wrap;
+    dispatch.clGetGLContextInfoKHR = &clGetGLContextInfoKHR_wrap;
+
+  /* cl_khr_d3d10_sharing */
+#if defined(_WIN32)
+    dispatch.clGetDeviceIDsFromD3D10KHR = &clGetDeviceIDsFromD3D10KHR_wrap;
+    dispatch.clCreateFromD3D10BufferKHR = &clCreateFromD3D10BufferKHR_wrap;
+    dispatch.clCreateFromD3D10Texture2DKHR = &clCreateFromD3D10Texture2DKHR_wrap;
+    dispatch.clCreateFromD3D10Texture3DKHR = &clCreateFromD3D10Texture3DKHR_wrap;
+    dispatch.clEnqueueAcquireD3D10ObjectsKHR = &clEnqueueAcquireD3D10ObjectsKHR_wrap;
+    dispatch.clEnqueueReleaseD3D10ObjectsKHR = &clEnqueueReleaseD3D10ObjectsKHR_wrap;
+#else
+    dispatch.clGetDeviceIDsFromD3D10KHR = NULL;
+    dispatch.clCreateFromD3D10BufferKHR = NULL;
+    dispatch.clCreateFromD3D10Texture2DKHR = NULL;
+    dispatch.clCreateFromD3D10Texture3DKHR = NULL;
+    dispatch.clEnqueueAcquireD3D10ObjectsKHR = NULL;
+    dispatch.clEnqueueReleaseD3D10ObjectsKHR = NULL;
+#endif
+
+  /* OpenCL 1.1 */
+    dispatch.clSetEventCallback = &clSetEventCallback_wrap;
+    dispatch.clCreateSubBuffer = &clCreateSubBuffer_wrap;
+    dispatch.clSetMemObjectDestructorCallback = &clSetMemObjectDestructorCallback_wrap;
+    dispatch.clCreateUserEvent = &clCreateUserEvent_wrap;
+    dispatch.clSetUserEventStatus = &clSetUserEventStatus_wrap;
+    dispatch.clEnqueueReadBufferRect = &clEnqueueReadBufferRect_wrap;
+    dispatch.clEnqueueWriteBufferRect = &clEnqueueWriteBufferRect_wrap;
+    dispatch.clEnqueueCopyBufferRect = &clEnqueueCopyBufferRect_wrap;
+
+  /* cl_ext_device_fission */
+    dispatch.clCreateSubDevicesEXT = &clCreateSubDevicesEXT_wrap;
+    dispatch.clRetainDeviceEXT = &clRetainDeviceEXT_wrap;
+    dispatch.clReleaseDeviceEXT = &clReleaseDeviceEXT_wrap;
+
+  /* cl_khr_gl_event */
+    dispatch.clCreateEventFromGLsyncKHR = &clCreateEventFromGLsyncKHR_wrap;
+
+  /* OpenCL 1.2 */
+    dispatch.clCreateSubDevices = &clCreateSubDevices_wrap;
+    dispatch.clRetainDevice = &clRetainDevice_wrap;
+    dispatch.clReleaseDevice = &clReleaseDevice_wrap;
+    dispatch.clCreateImage = &clCreateImage_wrap;
+    dispatch.clCreateProgramWithBuiltInKernels = &clCreateProgramWithBuiltInKernels_wrap;
+    dispatch.clCompileProgram = &clCompileProgram_wrap;
+    dispatch.clLinkProgram = &clLinkProgram_wrap;
+    dispatch.clUnloadPlatformCompiler = &clUnloadPlatformCompiler_wrap;
+    dispatch.clGetKernelArgInfo = &clGetKernelArgInfo_wrap;
+    dispatch.clEnqueueFillBuffer = &clEnqueueFillBuffer_wrap;
+    dispatch.clEnqueueFillImage = &clEnqueueFillImage_wrap;
+    dispatch.clEnqueueMigrateMemObjects = &clEnqueueMigrateMemObjects_wrap;
+    dispatch.clEnqueueMarkerWithWaitList = &clEnqueueMarkerWithWaitList_wrap;
+    dispatch.clEnqueueBarrierWithWaitList = &clEnqueueBarrierWithWaitList_wrap;
+    dispatch.clGetExtensionFunctionAddressForPlatform = &clGetExtensionFunctionAddressForPlatform_wrap;
+    dispatch.clCreateFromGLTexture = &clCreateFromGLTexture_wrap;
+
+  /* cl_khr_d3d11_sharing */
+#if defined(_WIN32)
+    dispatch.clGetDeviceIDsFromD3D11KHR = &clGetDeviceIDsFromD3D11KHR_wrap;
+    dispatch.clCreateFromD3D11BufferKHR = &clCreateFromD3D11BufferKHR_wrap;
+    dispatch.clCreateFromD3D11Texture2DKHR = &clCreateFromD3D11Texture2DKHR_wrap;
+    dispatch.clCreateFromD3D11Texture3DKHR = &clCreateFromD3D11Texture3DKHR_wrap;
+    dispatch.clCreateFromDX9MediaSurfaceKHR = &clCreateFromDX9MediaSurfaceKHR_wrap;
+    dispatch.clEnqueueAcquireD3D11ObjectsKHR = &clEnqueueAcquireD3D11ObjectsKHR_wrap;
+    dispatch.clEnqueueReleaseD3D11ObjectsKHR = &clEnqueueReleaseD3D11ObjectsKHR_wrap;
+#else
+    dispatch.clGetDeviceIDsFromD3D11KHR = NULL;
+    dispatch.clCreateFromD3D11BufferKHR = NULL;
+    dispatch.clCreateFromD3D11Texture2DKHR = NULL;
+    dispatch.clCreateFromD3D11Texture3DKHR = NULL;
+    dispatch.clCreateFromDX9MediaSurfaceKHR = NULL;
+    dispatch.clEnqueueAcquireD3D11ObjectsKHR = NULL;
+    dispatch.clEnqueueReleaseD3D11ObjectsKHR = NULL;
+#endif
+
+  /* cl_khr_dx9_media_sharing */
+#if defined(_WIN32)
+    dispatch.clGetDeviceIDsFromDX9MediaAdapterKHR = &clGetDeviceIDsFromDX9MediaAdapterKHR_wrap;
+    dispatch.clEnqueueAcquireDX9MediaSurfacesKHR = &clEnqueueAcquireDX9MediaSurfacesKHR_wrap;
+    dispatch.clEnqueueReleaseDX9MediaSurfacesKHR = &clEnqueueReleaseDX9MediaSurfacesKHR_wrap;
+#else
+    dispatch.clGetDeviceIDsFromDX9MediaAdapterKHR = NULL;
+    dispatch.clEnqueueAcquireDX9MediaSurfacesKHR = NULL;
+    dispatch.clEnqueueReleaseDX9MediaSurfacesKHR = NULL;
+#endif
+
+  /* cl_khr_egl_image */
+    dispatch.clCreateFromEGLImageKHR = &clCreateFromEGLImageKHR_wrap;
+    dispatch.clEnqueueAcquireEGLObjectsKHR = &clEnqueueAcquireEGLObjectsKHR_wrap;
+    dispatch.clEnqueueReleaseEGLObjectsKHR = &clEnqueueReleaseEGLObjectsKHR_wrap;
+
+  /* cl_khr_egl_event */
+    dispatch.clCreateEventFromEGLSyncKHR = &clCreateEventFromEGLSyncKHR_wrap;
+
+  /* OpenCL 2.0 */
+    dispatch.clCreateCommandQueueWithProperties = &clCreateCommandQueueWithProperties_wrap;
+    dispatch.clCreatePipe = &clCreatePipe_wrap;
+    dispatch.clGetPipeInfo = &clGetPipeInfo_wrap;
+    dispatch.clSVMAlloc = &clSVMAlloc_wrap;
+    dispatch.clSVMFree = &clSVMFree_wrap;
+    dispatch.clEnqueueSVMFree = &clEnqueueSVMFree_wrap;
+    dispatch.clEnqueueSVMMemcpy = &clEnqueueSVMMemcpy_wrap;
+    dispatch.clEnqueueSVMMemFill = &clEnqueueSVMMemFill_wrap;
+    dispatch.clEnqueueSVMMap = &clEnqueueSVMMap_wrap;
+    dispatch.clEnqueueSVMUnmap = &clEnqueueSVMUnmap_wrap;
+    dispatch.clCreateSamplerWithProperties = &clCreateSamplerWithProperties_wrap;
+    dispatch.clSetKernelArgSVMPointer = &clSetKernelArgSVMPointer_wrap;
+    dispatch.clSetKernelExecInfo = &clSetKernelExecInfo_wrap;
+
+  /* cl_khr_sub_groups */
+    dispatch.clGetKernelSubGroupInfoKHR = &clGetKernelSubGroupInfoKHR_wrap;
+
+  /* OpenCL 2.1 */
+    dispatch.clCloneKernel = &clCloneKernel_wrap;
+    dispatch.clCreateProgramWithIL = &clCreateProgramWithIL_wrap;
+    dispatch.clEnqueueSVMMigrateMem = &clEnqueueSVMMigrateMem_wrap;
+    dispatch.clGetDeviceAndHostTimer = &clGetDeviceAndHostTimer_wrap;
+    dispatch.clGetHostTimer = &clGetHostTimer_wrap;
+    dispatch.clGetKernelSubGroupInfo = &clGetKernelSubGroupInfo_wrap;
+    dispatch.clSetDefaultDeviceCommandQueue = &clSetDefaultDeviceCommandQueue_wrap;
+
+  /* OpenCL 2.2 */
+    dispatch.clSetProgramReleaseCallback = &clSetProgramReleaseCallback_wrap;
+    dispatch.clSetProgramSpecializationConstant = &clSetProgramSpecializationConstant_wrap;
+
+  /* OpenCL 3.0 */
+    dispatch.clCreateBufferWithProperties = &clCreateBufferWithProperties_wrap;
+    dispatch.clCreateImageWithProperties = &clCreateImageWithProperties_wrap;
+    dispatch.clSetContextDestructorCallback = &clSetContextDestructorCallback_wrap;
+}