[PATCH 1/4] opencl: Do not return an NTSTATUS from DllMain.

[Zebediah Figura]

Signed-off-by: Zebediah Figura 
---
 dlls/opencl/pe_wrappers.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/dlls/opencl/pe_wrappers.c b/dlls/opencl/pe_wrappers.c
index 35c78181580..56ff204c900 100644
--- a/dlls/opencl/pe_wrappers.c
+++ b/dlls/opencl/pe_wrappers.c
@@ -132,7 +132,8 @@ BOOL WINAPI DllMain( HINSTANCE instance, DWORD reason, void *reserved )
     if (reason == DLL_PROCESS_ATTACH)
     {
         DisableThreadLibraryCalls( instance );
-        return __wine_init_unix_lib( instance, reason, NULL, &opencl_funcs );
+        if (__wine_init_unix_lib( instance, reason, NULL, &opencl_funcs ))
+            ERR( "failed to load libOpenCL\n" );
     }
     return TRUE;
 }

[PATCH 2/4] opencl: Expose extensions that don't use new commands.

[Zebediah Figura]

Signed-off-by: Zebediah Figura 
---
 dlls/opencl/make_opencl      |  61 ++++++++++++++++
 dlls/opencl/opencl_private.h |   3 +
 dlls/opencl/pe_thunks.c      |  47 ++++++++++++
 dlls/opencl/pe_wrappers.c    | 136 +++++++++++++++++++++++++----------
 dlls/opencl/unix_private.h   |  11 ++-
 5 files changed, 218 insertions(+), 40 deletions(-)

diff --git a/dlls/opencl/make_opencl b/dlls/opencl/make_opencl
index f30967ff384..ce9660866ec 100755
--- a/dlls/opencl/make_opencl
+++ b/dlls/opencl/make_opencl
@@ -52,6 +52,27 @@ my %arg_types =
         "unsigned int"   => [ "long",   "%u" ],
     );

+my %unsupported_extensions =
+    (
+        # Needs wined3d integration.
+        "cl_intel_d3d11_nv12_media_sharing" => 1,
+        "cl_intel_dx9_media_sharing" => 1,
+        "cl_khr_d3d10_sharing" => 1,
+        "cl_khr_d3d11_sharing" => 1,
+        "cl_khr_dx9_media_sharing" => 1,
+        "cl_nv_d3d9_sharing" => 1,
+        "cl_nv_d3d10_sharing" => 1,
+        "cl_nv_d3d11_sharing" => 1,
+
+        # Needs a loader/ICD split.
+        "cl_khr_icd" => 1,
+        "cl_loader_layers" => 1,
+
+        # Needs callback conversion.
+        "cl_apple_setmemobjectdestructor" => 1,
+        "cl_arm_shared_virtual_memory" => 1,
+    );
+
 sub generate_pe_thunk($$)
 {
     my ($name, $func_ref) = @_;
@@ -348,6 +369,16 @@ sub parse_file($)
             $cl_types{$type->{name}} = $types{$type->{name}};
         }
     }
+
+    # generate extension list
+    foreach my $ext ($xml->findnodes("/registry/extensions/extension"))
+    {
+        # we currently don't support clGetExtensionFunctionAddress, and
+        # implementing clGetExtensionFunctionAddressForPlatform is nontrivial;
+        # we need to generate a table of thunks per platform and retrieve the
+        # platform from the called object
+        $unsupported_extensions{lc($ext->{name})} = 1 if $ext->findnodes("./require/command");
+    }
 }

parse_file( "cl-$commit.xml" );
@@ -362,6 +393,7 @@ foreach (sort keys %core_functions)

close(SPEC);

+
 # generate the PE thunks
 open(PE, ">$pe_file") or die "cannot create $pe_file";

@@ -379,6 +411,35 @@ foreach (sort keys %core_functions)
     print PE "\n", generate_pe_thunk( $_, $core_functions{$_} );
 }

+print PE <<EOF
+
+BOOL extension_is_supported( const char *name, size_t len )
+{
+    unsigned int i;
+
+    static const char *const unsupported[] =
+    {
+EOF
+;
+
+foreach (sort keys %unsupported_extensions)
+{
+    print PE "        "$_",\n";
+}
+
+print PE <<EOF
+    };
+
+    for (i = 0; i < ARRAY_SIZE(unsupported); ++i)
+    {
+        if (!strncasecmp( name, unsupported[i], len ))
+            return FALSE;
+    }
+    return TRUE;
+}
+EOF
+;
+
 close(PE);

# generate the unix library thunks
diff --git a/dlls/opencl/opencl_private.h b/dlls/opencl/opencl_private.h
index d88f6b2b8b6..78277a42a3b 100644
--- a/dlls/opencl/opencl_private.h
+++ b/dlls/opencl/opencl_private.h
@@ -21,6 +21,7 @@

#include <stdarg.h>
 #include <stdint.h>
+#include <stdlib.h>

#include "ntstatus.h"
 #define WIN32_NO_STATUS
@@ -30,4 +31,6 @@

#include "wine/debug.h"

+BOOL extension_is_supported( const char *name, size_t len ) DECLSPEC_HIDDEN;
+
 #endif
diff --git a/dlls/opencl/pe_thunks.c b/dlls/opencl/pe_thunks.c
index eb0466b6286..dc32146fcb4 100644
--- a/dlls/opencl/pe_thunks.c
+++ b/dlls/opencl/pe_thunks.c
@@ -377,3 +377,50 @@ cl_int WINAPI clWaitForEvents( cl_uint num_events, const cl_event* event_list )
     TRACE( "(%u, %p)\n", num_events, event_list );
     return opencl_funcs->pclWaitForEvents( num_events, event_list );
 }
+
+BOOL extension_is_supported( const char *name, size_t len )
+{
+    unsigned int i;
+
+    static const char *const unsupported[] =
+    {
+        "cl_apple_contextloggingfunctions",
+        "cl_apple_setmemobjectdestructor",
+        "cl_arm_import_memory",
+        "cl_arm_shared_virtual_memory",
+        "cl_ext_device_fission",
+        "cl_ext_migrate_memobject",
+        "cl_img_generate_mipmap",
+        "cl_img_use_gralloc_ptr",
+        "cl_intel_accelerator",
+        "cl_intel_create_buffer_with_properties",
+        "cl_intel_d3d11_nv12_media_sharing",
+        "cl_intel_dx9_media_sharing",
+        "cl_intel_unified_shared_memory",
+        "cl_intel_va_api_media_sharing",
+        "cl_khr_create_command_queue",
+        "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_icd",
+        "cl_khr_il_program",
+        "cl_khr_subgroups",
+        "cl_khr_terminate_context",
+        "cl_loader_layers",
+        "cl_nv_d3d10_sharing",
+        "cl_nv_d3d11_sharing",
+        "cl_nv_d3d9_sharing",
+        "cl_qcom_ext_host_ptr",
+    };
+
+    for (i = 0; i < ARRAY_SIZE(unsupported); ++i)
+    {
+        if (!strncasecmp( name, unsupported[i], len ))
+            return FALSE;
+    }
+    return TRUE;
+}
diff --git a/dlls/opencl/pe_wrappers.c b/dlls/opencl/pe_wrappers.c
index 56ff204c900..a91797e8ac0 100644
--- a/dlls/opencl/pe_wrappers.c
+++ b/dlls/opencl/pe_wrappers.c
@@ -26,81 +26,139 @@ WINE_DEFAULT_DEBUG_CHANNEL(opencl);

const struct opencl_funcs *opencl_funcs = NULL;

-cl_int WINAPI clGetPlatformInfo( cl_platform_id platform, cl_platform_info param_name,
-        SIZE_T param_value_size, void * param_value, size_t * param_value_size_ret )
+static cl_int filter_extensions( const char *unix_exts, SIZE_T size, char *win_exts, size_t *ret_size )
 {
-    cl_int ret;
-    TRACE("(%p, 0x%x, %ld, %p, %p)\n", platform, param_name, param_value_size, param_value, param_value_size_ret);
+    char *p = win_exts;
+    const char *ext;
+    SIZE_T win_size;
+
+    TRACE( "got host extension string %s\n", debugstr_a( unix_exts ) );

-    /* Hide all extensions.
-     * TODO: Add individual extension support as needed.
-     */
-    if (param_name == CL_PLATFORM_EXTENSIONS)
+    ext = unix_exts;
+    win_size = 0;
+    while (*ext)
     {
-        ret = CL_INVALID_VALUE;
+        const char *end = strchr( ext, ' ' );
+
+        if (!end) end = ext + strlen( ext );
+
+        if (extension_is_supported( ext, end - ext ))
+            win_size += strlen( ext ) + 1;

-        if (param_value && param_value_size > 0)
+        if (*end == ' ') ++end;
+        ext = end;
+    }
+
+    if (ret_size) *ret_size = win_size;
+    if (!win_exts) return CL_SUCCESS;
+    if (size < win_size) return CL_INVALID_VALUE;
+
+    win_exts[0] = 0;
+    ext = unix_exts;
+    while (*ext)
+    {
+        const char *end = strchr( ext, ' ' );
+        size_t len;
+
+        if (!end) end = ext + strlen( ext );
+        len = end - ext;
+
+        if (extension_is_supported( ext, len ))
         {
-            char *exts = (char *) param_value;
-            exts[0] = '\0';
-            ret = CL_SUCCESS;
+            if (p != win_exts) *p++ = ' ';
+            memcpy( p, ext, len );
+            p += len;
         }

-        if (param_value_size_ret)
+        if (*end == ' ') ++end;
+        ext = end;
+    }
+    *p = 0;
+
+    TRACE( "returning extension string %s\n", debugstr_a(win_exts) );
+
+    return CL_SUCCESS;
+}
+
+cl_int WINAPI clGetPlatformInfo( cl_platform_id platform, cl_platform_info name,
+                                 SIZE_T size, void *value, size_t *ret_size )
+{
+    cl_int ret;
+
+    TRACE( "(%p, %#x, %ld, %p, %p)\n", platform, name, size, value, ret_size );
+
+    if (name == CL_PLATFORM_EXTENSIONS)
+    {
+        size_t unix_size;
+        char *unix_exts;
+
+        ret = opencl_funcs->pclGetPlatformInfo( platform, name, 0, NULL, &unix_size );
+        if (ret != CL_SUCCESS)
+            return ret;
+
+        if (!(unix_exts = malloc( unix_size )))
+            return CL_OUT_OF_HOST_MEMORY;
+        ret = opencl_funcs->pclGetPlatformInfo( platform, name, unix_size, unix_exts, NULL );
+        if (ret != CL_SUCCESS)
         {
-            *param_value_size_ret = 1;
-            ret = CL_SUCCESS;
+            free( unix_exts );
+            return ret;
         }
+
+        ret = filter_extensions( unix_exts, size, value, ret_size );
+
+        free( unix_exts );
     }
     else
     {
-        ret = opencl_funcs->pclGetPlatformInfo(platform, param_name, param_value_size, param_value, param_value_size_ret);
+        ret = opencl_funcs->pclGetPlatformInfo( platform, name, size, value, ret_size );
     }

-    TRACE("(%p, 0x%x, %ld, %p, %p)=%d\n", platform, param_name, param_value_size, param_value, param_value_size_ret, ret);
     return ret;
 }

-cl_int WINAPI clGetDeviceInfo( cl_device_id device, cl_device_info param_name,
-        SIZE_T param_value_size, void * param_value, size_t * param_value_size_ret )
+cl_int WINAPI clGetDeviceInfo( cl_device_id device, cl_device_info name,
+                               SIZE_T size, void *value, size_t *ret_size )
 {
     cl_int ret;
-    TRACE("(%p, 0x%x, %ld, %p, %p)\n",device, param_name, param_value_size, param_value, param_value_size_ret);

-    /* Hide all extensions.
-     * TODO: Add individual extension support as needed.
-     */
-    if (param_name == CL_DEVICE_EXTENSIONS)
+    TRACE( "(%p, %#x, %ld, %p, %p)\n", device, name, size, value, ret_size );
+
+    if (name == CL_DEVICE_EXTENSIONS)
     {
-        ret = CL_INVALID_VALUE;
+        size_t unix_size;
+        char *unix_exts;

-        if (param_value && param_value_size > 0)
-        {
-            char *exts = (char *) param_value;
-            exts[0] = '\0';
-            ret = CL_SUCCESS;
-        }
+        ret = opencl_funcs->pclGetDeviceInfo( device, name, 0, NULL, &unix_size );
+        if (ret != CL_SUCCESS)
+            return ret;

-        if (param_value_size_ret)
+        if (!(unix_exts = malloc( unix_size )))
+            return CL_OUT_OF_HOST_MEMORY;
+        ret = opencl_funcs->pclGetDeviceInfo( device, name, unix_size, unix_exts, NULL );
+        if (ret != CL_SUCCESS)
         {
-            *param_value_size_ret = 1;
-            ret = CL_SUCCESS;
+            free( unix_exts );
+            return ret;
         }
+
+        ret = filter_extensions( unix_exts, size, value, ret_size );
+
+        free( unix_exts );
     }
     else
     {
-        ret = opencl_funcs->pclGetDeviceInfo(device, param_name, param_value_size, param_value, param_value_size_ret);
+        ret = opencl_funcs->pclGetDeviceInfo( device, name, size, value, ret_size );
     }

/* Filter out the CL_EXEC_NATIVE_KERNEL flag */
-    if (param_name == CL_DEVICE_EXECUTION_CAPABILITIES)
+    if (name == CL_DEVICE_EXECUTION_CAPABILITIES)
     {
-        cl_device_exec_capabilities *caps = (cl_device_exec_capabilities *) param_value;
+        cl_device_exec_capabilities *caps = value;
         *caps &= ~CL_EXEC_NATIVE_KERNEL;
     }

-    TRACE("(%p, 0x%x, %ld, %p, %p)=%d\n",device, param_name, param_value_size, param_value, param_value_size_ret, ret);
     return ret;
 }

diff --git a/dlls/opencl/unix_private.h b/dlls/opencl/unix_private.h
index 82fb83bd491..d051ade01cc 100644
--- a/dlls/opencl/unix_private.h
+++ b/dlls/opencl/unix_private.h
@@ -19,7 +19,16 @@
 #ifndef __WINE_UNIX_PRIVATE_H
 #define __WINE_UNIX_PRIVATE_H

-#include "opencl_private.h"
+#include <stdarg.h>
+#include <stdint.h>
+
+#include "ntstatus.h"
+#define WIN32_NO_STATUS
+#include "windef.h"
+#include "winbase.h"
+#include "winternl.h"
+
+#include "wine/debug.h"

#define CL_SILENCE_DEPRECATION
 #if defined(HAVE_CL_CL_H)

[PATCH 3/4] opencl: Update to OpenCL 1.1.

[Zebediah Figura]

This requires OpenCL 1.1 support from the loader, but not the platform or
driver.

Signed-off-by: Zebediah Figura 
---

dlls/opencl/make_opencl     |  9 ++++++-
 dlls/opencl/opencl.spec     |  8 +++++++
 dlls/opencl/opencl_types.h  | 28 ++++++++++++++++++++++
 dlls/opencl/pe_thunks.c     | 48 +++++++++++++++++++++++++++++++++++++
 dlls/opencl/unix_private.h  |  8 +++++++
 dlls/opencl/unix_thunks.c   | 38 +++++++++++++++++++++++++++++
 dlls/opencl/unix_wrappers.c | 16 +++++++++++++
 dlls/opencl/unixlib.h       |  8 +++++++
 8 files changed, 162 insertions(+), 1 deletion(-)

diff --git a/dlls/opencl/make_opencl b/dlls/opencl/make_opencl
index ce9660866ec..3274d6aa8ca 100755
--- a/dlls/opencl/make_opencl
+++ b/dlls/opencl/make_opencl
@@ -30,6 +30,7 @@ my $gen_traces = 1;

# List of categories to put in the 'opengl_core.c' file
 my %cat_1_0 = ( "CL_VERSION_1_0" => 1 );
+my %cat_1_1 = ( %cat_1_0, "CL_VERSION_1_1" => 1 );

my %core_categories = ();

@@ -183,11 +184,15 @@ if (@ARGV > 1)
     $name0 =~ s%^.*/%%;
     die "Usage: $name0 [version]\n";
 }
-my $version = $ARGV[0] || "1.0";
+my $version = $ARGV[0] || "1.1";
 if ($version eq "1.0")
 {
     %core_categories = %cat_1_0;
 }
+elsif ($version eq "1.1")
+{
+    %core_categories = %cat_1_1;
+}
 else
 {
     die "Incorrect OpenCL version.\n";
@@ -256,6 +261,8 @@ sub needs_unix_wrapper($)
             "clCreateContext" => 1,
             "clCreateContextFromType" => 1,
             "clEnqueueNativeKernel" => 1,
+            "clSetEventCallback" => 1,
+            "clSetMemObjectDestructorCallback" => 1,
         );
     my $name = shift;

diff --git a/dlls/opencl/opencl.spec b/dlls/opencl/opencl.spec
index 61a83fae8cd..099b9617cd0 100644
--- a/dlls/opencl/opencl.spec
+++ b/dlls/opencl/opencl.spec
@@ -10,8 +10,11 @@
 @ stdcall clCreateProgramWithBinary(ptr long ptr ptr ptr ptr ptr)
 @ stdcall clCreateProgramWithSource(ptr long ptr ptr ptr)
 @ stdcall clCreateSampler(ptr long long long ptr)
+@ stdcall clCreateSubBuffer(ptr int64 long ptr ptr)
+@ stdcall clCreateUserEvent(ptr ptr)
 @ stdcall clEnqueueBarrier(ptr)
 @ stdcall clEnqueueCopyBuffer(ptr ptr ptr long long long long ptr ptr)
+@ stdcall clEnqueueCopyBufferRect(ptr ptr ptr ptr ptr ptr long long long long long ptr ptr)
 @ stdcall clEnqueueCopyBufferToImage(ptr ptr ptr long ptr ptr long ptr ptr)
 @ stdcall clEnqueueCopyImage(ptr ptr ptr ptr ptr ptr long ptr ptr)
 @ stdcall clEnqueueCopyImageToBuffer(ptr ptr ptr ptr ptr long long ptr ptr)
@@ -21,11 +24,13 @@
 @ stdcall clEnqueueNDRangeKernel(ptr ptr long ptr ptr ptr long ptr ptr)
 @ stdcall clEnqueueNativeKernel(ptr ptr ptr long long ptr ptr long ptr ptr)
 @ stdcall clEnqueueReadBuffer(ptr ptr long long long ptr long ptr ptr)
+@ stdcall clEnqueueReadBufferRect(ptr ptr long ptr ptr ptr long long long long ptr long ptr ptr)
 @ stdcall clEnqueueReadImage(ptr ptr long ptr ptr long long ptr long ptr ptr)
 @ stdcall clEnqueueTask(ptr ptr long ptr ptr)
 @ stdcall clEnqueueUnmapMemObject(ptr ptr ptr long ptr ptr)
 @ stdcall clEnqueueWaitForEvents(ptr long ptr)
 @ stdcall clEnqueueWriteBuffer(ptr ptr long long long ptr long ptr ptr)
+@ stdcall clEnqueueWriteBufferRect(ptr ptr long ptr ptr ptr long long long long ptr long ptr ptr)
 @ stdcall clEnqueueWriteImage(ptr ptr long ptr ptr long long ptr long ptr ptr)
 @ stdcall clFinish(ptr)
 @ stdcall clFlush(ptr)
@@ -61,6 +66,9 @@
 @ stdcall clRetainProgram(ptr)
 @ stdcall clRetainSampler(ptr)
 @ stdcall clSetCommandQueueProperty(ptr int64 long ptr)
+@ stdcall clSetEventCallback(ptr long ptr ptr)
 @ stdcall clSetKernelArg(ptr long long ptr)
+@ stdcall clSetMemObjectDestructorCallback(ptr ptr ptr)
+@ stdcall clSetUserEventStatus(ptr long)
 @ stdcall clUnloadCompiler()
 @ stdcall clWaitForEvents(long ptr)
diff --git a/dlls/opencl/opencl_types.h b/dlls/opencl/opencl_types.h
index eb5530d0a8d..5d10b2c9ee1 100644
--- a/dlls/opencl/opencl_types.h
+++ b/dlls/opencl/opencl_types.h
@@ -54,14 +54,17 @@ typedef struct _cl_buffer_region
     size_t origin;
     size_t size;
 } cl_buffer_region;
+typedef cl_uint          cl_buffer_create_type;

#define CL_A 0x10B1
 #define CL_ADDRESS_CLAMP 0x1132
 #define CL_ADDRESS_CLAMP_TO_EDGE 0x1131
+#define CL_ADDRESS_MIRRORED_REPEAT 0x1134
 #define CL_ADDRESS_NONE 0x1130
 #define CL_ADDRESS_REPEAT 0x1133
 #define CL_ARGB 0x10B7
 #define CL_BGRA 0x10B6
+#define CL_BUFFER_CREATE_TYPE_REGION 0x1220
 #define CL_BUILD_ERROR -2
 #define CL_BUILD_IN_PROGRESS -3
 #define CL_BUILD_NONE -1
@@ -72,6 +75,7 @@ typedef struct _cl_buffer_region
 #define CL_CHAR_MIN CL_SCHAR_MIN
 #define CL_COMMAND_ACQUIRE_GL_OBJECTS 0x11FF
 #define CL_COMMAND_COPY_BUFFER 0x11F5
+#define CL_COMMAND_COPY_BUFFER_RECT 0x1203
 #define CL_COMMAND_COPY_BUFFER_TO_IMAGE 0x11FA
 #define CL_COMMAND_COPY_IMAGE 0x11F8
 #define CL_COMMAND_COPY_IMAGE_TO_BUFFER 0x11F9
@@ -81,15 +85,19 @@ typedef struct _cl_buffer_region
 #define CL_COMMAND_NATIVE_KERNEL 0x11F2
 #define CL_COMMAND_NDRANGE_KERNEL 0x11F0
 #define CL_COMMAND_READ_BUFFER 0x11F3
+#define CL_COMMAND_READ_BUFFER_RECT 0x1201
 #define CL_COMMAND_READ_IMAGE 0x11F6
 #define CL_COMMAND_RELEASE_GL_OBJECTS 0x1200
 #define CL_COMMAND_TASK 0x11F1
 #define CL_COMMAND_UNMAP_MEM_OBJECT 0x11FD
+#define CL_COMMAND_USER 0x1204
 #define CL_COMMAND_WRITE_BUFFER 0x11F4
+#define CL_COMMAND_WRITE_BUFFER_RECT 0x1202
 #define CL_COMMAND_WRITE_IMAGE 0x11F7
 #define CL_COMPILER_NOT_AVAILABLE -3
 #define CL_COMPLETE 0x0
 #define CL_CONTEXT_DEVICES 0x1081
+#define CL_CONTEXT_NUM_DEVICES 0x1083
 #define CL_CONTEXT_PLATFORM 0x1084
 #define CL_CONTEXT_PROPERTIES 0x1082
 #define CL_CONTEXT_REFERENCE_COUNT 0x1080
@@ -114,6 +122,7 @@ typedef struct _cl_buffer_region
 #define CL_DEVICE_GLOBAL_MEM_CACHE_SIZE 0x101E
 #define CL_DEVICE_GLOBAL_MEM_CACHE_TYPE 0x101C
 #define CL_DEVICE_GLOBAL_MEM_SIZE 0x101F
+#define CL_DEVICE_HOST_UNIFIED_MEMORY 0x1035
 #define CL_DEVICE_IMAGE2D_MAX_HEIGHT 0x1012
 #define CL_DEVICE_IMAGE2D_MAX_WIDTH 0x1011
 #define CL_DEVICE_IMAGE3D_MAX_DEPTH 0x1015
@@ -137,12 +146,21 @@ typedef struct _cl_buffer_region
 #define CL_DEVICE_MEM_BASE_ADDR_ALIGN 0x1019
 #define CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE 0x101A
 #define CL_DEVICE_NAME 0x102B
+#define CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR 0x1036
+#define CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE 0x103B
+#define CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT 0x103A
+#define CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF 0x103C
+#define CL_DEVICE_NATIVE_VECTOR_WIDTH_INT 0x1038
+#define CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG 0x1039
+#define CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT 0x1037
 #define CL_DEVICE_NOT_AVAILABLE -2
 #define CL_DEVICE_NOT_FOUND -1
+#define CL_DEVICE_OPENCL_C_VERSION 0x103D
 #define CL_DEVICE_PLATFORM 0x1031
 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR 0x1006
 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE 0x100B
 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT 0x100A
+#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF 0x1034
 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT 0x1008
 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG 0x1009
 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT 0x1007
@@ -163,9 +181,11 @@ typedef struct _cl_buffer_region
 #define CL_EVENT_COMMAND_EXECUTION_STATUS 0x11D3
 #define CL_EVENT_COMMAND_QUEUE 0x11D0
 #define CL_EVENT_COMMAND_TYPE 0x11D1
+#define CL_EVENT_CONTEXT 0x11D4
 #define CL_EVENT_REFERENCE_COUNT 0x11D2
 #define CL_EXEC_KERNEL (1 << 0)
 #define CL_EXEC_NATIVE_KERNEL (1 << 1)
+#define CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST -14
 #define CL_FALSE 0
 #define CL_FILTER_LINEAR 0x1141
 #define CL_FILTER_NEAREST 0x1140
@@ -186,6 +206,7 @@ typedef struct _cl_buffer_region
 #define CL_FP_ROUND_TO_INF (1 << 4)
 #define CL_FP_ROUND_TO_NEAREST (1 << 2)
 #define CL_FP_ROUND_TO_ZERO (1 << 3)
+#define CL_FP_SOFT_FLOAT (1 << 6)
 #define CL_GLOBAL 0x2
 #define CL_HALF_FLOAT 0x10DD
 #define CL_HUGE_VAL ((cl_double) 1e500)
@@ -231,6 +252,7 @@ typedef struct _cl_buffer_region
 #define CL_INVALID_PLATFORM -32
 #define CL_INVALID_PROGRAM -44
 #define CL_INVALID_PROGRAM_EXECUTABLE -45
+#define CL_INVALID_PROPERTY -64
 #define CL_INVALID_QUEUE_PROPERTIES -35
 #define CL_INVALID_SAMPLER -41
 #define CL_INVALID_VALUE -30
@@ -256,6 +278,7 @@ typedef struct _cl_buffer_region
 #define CL_MAP_WRITE (1 << 1)
 #define CL_MAXFLOAT CL_FLT_MAX
 #define CL_MEM_ALLOC_HOST_PTR (1 << 4)
+#define CL_MEM_ASSOCIATED_MEMOBJECT 0x1107
 #define CL_MEM_CONTEXT 0x1106
 #define CL_MEM_COPY_HOST_PTR (1 << 5)
 #define CL_MEM_COPY_OVERLAP -8
@@ -266,6 +289,7 @@ typedef struct _cl_buffer_region
 #define CL_MEM_OBJECT_BUFFER 0x10F0
 #define CL_MEM_OBJECT_IMAGE2D 0x10F1
 #define CL_MEM_OBJECT_IMAGE3D 0x10F2
+#define CL_MEM_OFFSET 0x1108
 #define CL_MEM_READ_ONLY (1 << 2)
 #define CL_MEM_READ_WRITE (1 << 0)
 #define CL_MEM_REFERENCE_COUNT 0x1105
@@ -273,6 +297,7 @@ typedef struct _cl_buffer_region
 #define CL_MEM_TYPE 0x1100
 #define CL_MEM_USE_HOST_PTR (1 << 3)
 #define CL_MEM_WRITE_ONLY (1 << 1)
+#define CL_MISALIGNED_SUB_BUFFER_OFFSET -13
 #define CL_NAN (CL_INFINITY - CL_INFINITY)
 #define CL_NONE 0x0
 #define CL_OUT_OF_HOST_MEMORY -6
@@ -311,7 +336,10 @@ typedef struct _cl_buffer_region
 #define CL_RG 0x10B2
 #define CL_RGB 0x10B4
 #define CL_RGBA 0x10B5
+#define CL_RGBx 0x10BC
+#define CL_RGx 0x10BB
 #define CL_RUNNING 0x1
+#define CL_Rx 0x10BA
 #define CL_SAMPLER_ADDRESSING_MODE 0x1153
 #define CL_SAMPLER_CONTEXT 0x1151
 #define CL_SAMPLER_FILTER_MODE 0x1154
diff --git a/dlls/opencl/pe_thunks.c b/dlls/opencl/pe_thunks.c
index dc32146fcb4..74204aeb95c 100644
--- a/dlls/opencl/pe_thunks.c
+++ b/dlls/opencl/pe_thunks.c
@@ -78,6 +78,18 @@ cl_sampler WINAPI clCreateSampler( cl_context context, cl_bool normalized_coords
     return opencl_funcs->pclCreateSampler( context, normalized_coords, addressing_mode, filter_mode, errcode_ret );
 }

+cl_mem WINAPI clCreateSubBuffer( cl_mem buffer, cl_mem_flags flags, cl_buffer_create_type buffer_create_type, const void* buffer_create_info, cl_int* errcode_ret )
+{
+    TRACE( "(%p, %s, %u, %p, %p)\n", buffer, wine_dbgstr_longlong(flags), buffer_create_type, buffer_create_info, errcode_ret );
+    return opencl_funcs->pclCreateSubBuffer( buffer, flags, buffer_create_type, buffer_create_info, errcode_ret );
+}
+
+cl_event WINAPI clCreateUserEvent( cl_context context, cl_int* errcode_ret )
+{
+    TRACE( "(%p, %p)\n", context, errcode_ret );
+    return opencl_funcs->pclCreateUserEvent( context, errcode_ret );
+}
+
 cl_int WINAPI clEnqueueBarrier( cl_command_queue command_queue )
 {
     TRACE( "(%p)\n", command_queue );
@@ -90,6 +102,12 @@ cl_int WINAPI clEnqueueCopyBuffer( cl_command_queue command_queue, cl_mem src_bu
     return opencl_funcs->pclEnqueueCopyBuffer( command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, event );
 }

+cl_int WINAPI clEnqueueCopyBufferRect( 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 )
+{
+    TRACE( "(%p, %p, %p, %p, %p, %p, %Iu, %Iu, %Iu, %Iu, %u, %p, %p)\n", 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 );
+    return opencl_funcs->pclEnqueueCopyBufferRect( 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 );
+}
+
 cl_int WINAPI clEnqueueCopyBufferToImage( 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 )
 {
     TRACE( "(%p, %p, %p, %Iu, %p, %p, %u, %p, %p)\n", command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
@@ -144,6 +162,12 @@ cl_int WINAPI clEnqueueReadBuffer( cl_command_queue command_queue, cl_mem buffer
     return opencl_funcs->pclEnqueueReadBuffer( command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
 }

+cl_int WINAPI clEnqueueReadBufferRect( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, const size_t* buffer_origin, const size_t* host_origin, 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 )
+{
+    TRACE( "(%p, %p, %u, %p, %p, %p, %Iu, %Iu, %Iu, %Iu, %p, %u, %p, %p)\n", command_queue, buffer, blocking_read, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
+    return opencl_funcs->pclEnqueueReadBufferRect( command_queue, buffer, blocking_read, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
+}
+
 cl_int WINAPI clEnqueueReadImage( 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 )
 {
     TRACE( "(%p, %p, %u, %p, %p, %Iu, %Iu, %p, %u, %p, %p)\n", command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
@@ -174,6 +198,12 @@ cl_int WINAPI clEnqueueWriteBuffer( cl_command_queue command_queue, cl_mem buffe
     return opencl_funcs->pclEnqueueWriteBuffer( command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
 }

+cl_int WINAPI clEnqueueWriteBufferRect( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, const size_t* buffer_origin, const size_t* host_origin, 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 )
+{
+    TRACE( "(%p, %p, %u, %p, %p, %p, %Iu, %Iu, %Iu, %Iu, %p, %u, %p, %p)\n", command_queue, buffer, blocking_write, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
+    return opencl_funcs->pclEnqueueWriteBufferRect( command_queue, buffer, blocking_write, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
+}
+
 cl_int WINAPI clEnqueueWriteImage( 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 )
 {
     TRACE( "(%p, %p, %u, %p, %p, %Iu, %Iu, %p, %u, %p, %p)\n", command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
@@ -360,12 +390,30 @@ cl_int WINAPI clRetainSampler( cl_sampler sampler )
     return opencl_funcs->pclRetainSampler( sampler );
 }

+cl_int WINAPI clSetEventCallback( cl_event event, cl_int command_exec_callback_type, void (WINAPI* pfn_notify)(cl_event event, cl_int event_command_status, void *user_data), void* user_data )
+{
+    TRACE( "(%p, %d, %p, %p)\n", event, command_exec_callback_type, pfn_notify, user_data );
+    return opencl_funcs->pclSetEventCallback( event, command_exec_callback_type, pfn_notify, user_data );
+}
+
 cl_int WINAPI clSetKernelArg( cl_kernel kernel, cl_uint arg_index, size_t arg_size, const void* arg_value )
 {
     TRACE( "(%p, %u, %Iu, %p)\n", kernel, arg_index, arg_size, arg_value );
     return opencl_funcs->pclSetKernelArg( kernel, arg_index, arg_size, arg_value );
 }

+cl_int WINAPI clSetMemObjectDestructorCallback( cl_mem memobj, void (WINAPI* pfn_notify)(cl_mem memobj, void* user_data), void* user_data )
+{
+    TRACE( "(%p, %p, %p)\n", memobj, pfn_notify, user_data );
+    return opencl_funcs->pclSetMemObjectDestructorCallback( memobj, pfn_notify, user_data );
+}
+
+cl_int WINAPI clSetUserEventStatus( cl_event event, cl_int execution_status )
+{
+    TRACE( "(%p, %d)\n", event, execution_status );
+    return opencl_funcs->pclSetUserEventStatus( event, execution_status );
+}
+
 cl_int WINAPI clUnloadCompiler( void  )
 {
     TRACE( "()\n" );
diff --git a/dlls/opencl/unix_private.h b/dlls/opencl/unix_private.h
index d051ade01cc..324df387169 100644
--- a/dlls/opencl/unix_private.h
+++ b/dlls/opencl/unix_private.h
@@ -63,6 +63,14 @@ cl_int WINAPI wrap_clEnqueueNativeKernel( cl_command_queue command_queue,
         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 ) DECLSPEC_HIDDEN;

+cl_int WINAPI wrap_clSetEventCallback( cl_event event, cl_int type,
+        void (WINAPI *pfn_notify)(cl_event, cl_int, void *),
+        void *user_data) DECLSPEC_HIDDEN;
+
+cl_int WINAPI wrap_clSetMemObjectDestructorCallback(cl_mem memobj,
+        void (WINAPI *pfn_notify)(cl_mem, void *),
+        void *user_data) DECLSPEC_HIDDEN;
+
 extern const struct opencl_funcs funcs;

#endif
diff --git a/dlls/opencl/unix_thunks.c b/dlls/opencl/unix_thunks.c
index 579c12eed79..656d4787fb2 100644
--- a/dlls/opencl/unix_thunks.c
+++ b/dlls/opencl/unix_thunks.c
@@ -52,6 +52,16 @@ static cl_sampler WINAPI wrap_clCreateSampler( cl_context context, cl_bool norma
     return clCreateSampler( context, normalized_coords, addressing_mode, filter_mode, errcode_ret );
 }

+static cl_mem WINAPI wrap_clCreateSubBuffer( cl_mem buffer, cl_mem_flags flags, cl_buffer_create_type buffer_create_type, const void* buffer_create_info, cl_int* errcode_ret )
+{
+    return clCreateSubBuffer( buffer, flags, buffer_create_type, buffer_create_info, errcode_ret );
+}
+
+static cl_event WINAPI wrap_clCreateUserEvent( cl_context context, cl_int* errcode_ret )
+{
+    return clCreateUserEvent( context, errcode_ret );
+}
+
 static cl_int WINAPI wrap_clEnqueueBarrier( cl_command_queue command_queue )
 {
     return clEnqueueBarrier( command_queue );
@@ -62,6 +72,11 @@ static cl_int WINAPI wrap_clEnqueueCopyBuffer( cl_command_queue command_queue, c
     return clEnqueueCopyBuffer( command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, event );
 }

+static cl_int WINAPI wrap_clEnqueueCopyBufferRect( 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 )
+{
+    return 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_int WINAPI wrap_clEnqueueCopyBufferToImage( 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 )
 {
     return clEnqueueCopyBufferToImage( command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
@@ -102,6 +117,11 @@ static cl_int WINAPI wrap_clEnqueueReadBuffer( cl_command_queue command_queue, c
     return clEnqueueReadBuffer( command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
 }

+static cl_int WINAPI wrap_clEnqueueReadBufferRect( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, const size_t* buffer_origin, const size_t* host_origin, 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 )
+{
+    return clEnqueueReadBufferRect( command_queue, buffer, blocking_read, buffer_origin, host_origin, 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_int WINAPI wrap_clEnqueueReadImage( 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 )
 {
     return clEnqueueReadImage( command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
@@ -127,6 +147,11 @@ static cl_int WINAPI wrap_clEnqueueWriteBuffer( cl_command_queue command_queue,
     return clEnqueueWriteBuffer( command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
 }

+static cl_int WINAPI wrap_clEnqueueWriteBufferRect( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, const size_t* buffer_origin, const size_t* host_origin, 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 )
+{
+    return clEnqueueWriteBufferRect( command_queue, buffer, blocking_write, buffer_origin, host_origin, 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_int WINAPI wrap_clEnqueueWriteImage( 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 )
 {
     return clEnqueueWriteImage( command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
@@ -297,6 +322,11 @@ static cl_int WINAPI wrap_clSetKernelArg( cl_kernel kernel, cl_uint arg_index, s
     return clSetKernelArg( kernel, arg_index, arg_size, arg_value );
 }

+static cl_int WINAPI wrap_clSetUserEventStatus( cl_event event, cl_int execution_status )
+{
+    return clSetUserEventStatus( event, execution_status );
+}
+
 static cl_int WINAPI wrap_clUnloadCompiler( void  )
 {
     return clUnloadCompiler();
@@ -321,8 +351,11 @@ const struct opencl_funcs funcs =
     wrap_clCreateProgramWithBinary,
     wrap_clCreateProgramWithSource,
     wrap_clCreateSampler,
+    wrap_clCreateSubBuffer,
+    wrap_clCreateUserEvent,
     wrap_clEnqueueBarrier,
     wrap_clEnqueueCopyBuffer,
+    wrap_clEnqueueCopyBufferRect,
     wrap_clEnqueueCopyBufferToImage,
     wrap_clEnqueueCopyImage,
     wrap_clEnqueueCopyImageToBuffer,
@@ -332,11 +365,13 @@ const struct opencl_funcs funcs =
     wrap_clEnqueueNDRangeKernel,
     wrap_clEnqueueNativeKernel,
     wrap_clEnqueueReadBuffer,
+    wrap_clEnqueueReadBufferRect,
     wrap_clEnqueueReadImage,
     wrap_clEnqueueTask,
     wrap_clEnqueueUnmapMemObject,
     wrap_clEnqueueWaitForEvents,
     wrap_clEnqueueWriteBuffer,
+    wrap_clEnqueueWriteBufferRect,
     wrap_clEnqueueWriteImage,
     wrap_clFinish,
     wrap_clFlush,
@@ -370,7 +405,10 @@ const struct opencl_funcs funcs =
     wrap_clRetainMemObject,
     wrap_clRetainProgram,
     wrap_clRetainSampler,
+    wrap_clSetEventCallback,
     wrap_clSetKernelArg,
+    wrap_clSetMemObjectDestructorCallback,
+    wrap_clSetUserEventStatus,
     wrap_clUnloadCompiler,
     wrap_clWaitForEvents,
 };
diff --git a/dlls/opencl/unix_wrappers.c b/dlls/opencl/unix_wrappers.c
index 248fe80541c..fb4e611f3f0 100644
--- a/dlls/opencl/unix_wrappers.c
+++ b/dlls/opencl/unix_wrappers.c
@@ -138,6 +138,22 @@ cl_int WINAPI wrap_clEnqueueNativeKernel( cl_command_queue command_queue,
     return CL_INVALID_OPERATION;
 }

+cl_int WINAPI wrap_clSetEventCallback( cl_event event, cl_int type,
+        void (WINAPI *pfn_notify)(cl_event, cl_int, void *),
+        void *user_data)
+{
+    FIXME( "not yet implemented\n" );
+    return CL_INVALID_OPERATION;
+}
+
+cl_int WINAPI wrap_clSetMemObjectDestructorCallback(cl_mem memobj,
+        void (WINAPI *pfn_notify)(cl_mem, void *),
+        void *user_data)
+{
+    FIXME( "not yet implemented\n" );
+    return CL_INVALID_OPERATION;
+}
+
 NTSTATUS CDECL __wine_init_unix_lib( HMODULE module, DWORD reason, const void *ptr_in, void *ptr_out )
 {
     if (reason != DLL_PROCESS_ATTACH) return STATUS_SUCCESS;
diff --git a/dlls/opencl/unixlib.h b/dlls/opencl/unixlib.h
index d5b1da1b99e..617d590acc3 100644
--- a/dlls/opencl/unixlib.h
+++ b/dlls/opencl/unixlib.h
@@ -14,8 +14,11 @@ struct opencl_funcs
     cl_program (WINAPI *pclCreateProgramWithBinary)( 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_program (WINAPI *pclCreateProgramWithSource)( cl_context context, cl_uint count, const char** strings, const size_t* lengths, cl_int* errcode_ret );
     cl_sampler (WINAPI *pclCreateSampler)( cl_context context, cl_bool normalized_coords, cl_addressing_mode addressing_mode, cl_filter_mode filter_mode, cl_int* errcode_ret );
+    cl_mem (WINAPI *pclCreateSubBuffer)( cl_mem buffer, cl_mem_flags flags, cl_buffer_create_type buffer_create_type, const void* buffer_create_info, cl_int* errcode_ret );
+    cl_event (WINAPI *pclCreateUserEvent)( cl_context context, cl_int* errcode_ret );
     cl_int (WINAPI *pclEnqueueBarrier)( cl_command_queue command_queue );
     cl_int (WINAPI *pclEnqueueCopyBuffer)( 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_int (WINAPI *pclEnqueueCopyBufferRect)( 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_int (WINAPI *pclEnqueueCopyBufferToImage)( 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_int (WINAPI *pclEnqueueCopyImage)( 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_int (WINAPI *pclEnqueueCopyImageToBuffer)( 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 );
@@ -25,11 +28,13 @@ struct opencl_funcs
     cl_int (WINAPI *pclEnqueueNDRangeKernel)( 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_int (WINAPI *pclEnqueueNativeKernel)( cl_command_queue command_queue, void (WINAPI* 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_int (WINAPI *pclEnqueueReadBuffer)( 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_int (WINAPI *pclEnqueueReadBufferRect)( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, const size_t* buffer_origin, const size_t* host_origin, 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_int (WINAPI *pclEnqueueReadImage)( 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_int (WINAPI *pclEnqueueTask)( 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_int (WINAPI *pclEnqueueUnmapMemObject)( 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_int (WINAPI *pclEnqueueWaitForEvents)( cl_command_queue command_queue, cl_uint num_events, const cl_event* event_list );
     cl_int (WINAPI *pclEnqueueWriteBuffer)( 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_int (WINAPI *pclEnqueueWriteBufferRect)( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, const size_t* buffer_origin, const size_t* host_origin, 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_int (WINAPI *pclEnqueueWriteImage)( 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_int (WINAPI *pclFinish)( cl_command_queue command_queue );
     cl_int (WINAPI *pclFlush)( cl_command_queue command_queue );
@@ -63,7 +68,10 @@ struct opencl_funcs
     cl_int (WINAPI *pclRetainMemObject)( cl_mem memobj );
     cl_int (WINAPI *pclRetainProgram)( cl_program program );
     cl_int (WINAPI *pclRetainSampler)( cl_sampler sampler );
+    cl_int (WINAPI *pclSetEventCallback)( cl_event event, cl_int command_exec_callback_type, void (WINAPI* pfn_notify)(cl_event event, cl_int event_command_status, void *user_data), void* user_data );
     cl_int (WINAPI *pclSetKernelArg)( cl_kernel kernel, cl_uint arg_index, size_t arg_size, const void* arg_value );
+    cl_int (WINAPI *pclSetMemObjectDestructorCallback)( cl_mem memobj, void (WINAPI* pfn_notify)(cl_mem memobj, void* user_data), void* user_data );
+    cl_int (WINAPI *pclSetUserEventStatus)( cl_event event, cl_int execution_status );
     cl_int (WINAPI *pclUnloadCompiler)( void  );
     cl_int (WINAPI *pclWaitForEvents)( cl_uint num_events, const cl_event* event_list );
 };

[PATCH 4/4] opencl: Update to OpenCL 1.2.

[Zebediah Figura]

Signed-off-by: Zebediah Figura 
---
 dlls/opencl/make_opencl     |  11 +++-
 dlls/opencl/opencl.spec     |  15 ++++++
 dlls/opencl/opencl_types.h  | 105 ++++++++++++++++++++++++++++++++++++
 dlls/opencl/pe_thunks.c     |  84 +++++++++++++++++++++++++++++
 dlls/opencl/pe_wrappers.c   |   7 +++
 dlls/opencl/unix_private.h  |  11 ++++
 dlls/opencl/unix_thunks.c   |  74 +++++++++++++++++++++++++
 dlls/opencl/unix_wrappers.c |  20 +++++++
 dlls/opencl/unixlib.h       |  14 +++++
 9 files changed, 340 insertions(+), 1 deletion(-)

diff --git a/dlls/opencl/make_opencl b/dlls/opencl/make_opencl
index 3274d6aa8ca..09eba09914e 100755
--- a/dlls/opencl/make_opencl
+++ b/dlls/opencl/make_opencl
@@ -31,6 +31,7 @@ my $gen_traces = 1;
 # List of categories to put in the 'opengl_core.c' file
 my %cat_1_0 = ( "CL_VERSION_1_0" => 1 );
 my %cat_1_1 = ( %cat_1_0, "CL_VERSION_1_1" => 1 );
+my %cat_1_2 = ( %cat_1_1, "CL_VERSION_1_2" => 1 );

my %core_categories = ();

@@ -184,7 +185,7 @@ if (@ARGV > 1)
     $name0 =~ s%^.*/%%;
     die "Usage: $name0 [version]\n";
 }
-my $version = $ARGV[0] || "1.1";
+my $version = $ARGV[0] || "1.2";
 if ($version eq "1.0")
 {
     %core_categories = %cat_1_0;
@@ -193,6 +194,10 @@ elsif ($version eq "1.1")
 {
     %core_categories = %cat_1_1;
 }
+elsif ($version eq "1.2")
+{
+    %core_categories = %cat_1_2;
+}
 else
 {
     die "Incorrect OpenCL version.\n";
@@ -242,6 +247,7 @@ sub needs_pe_wrapper($)

# needs function pointer conversion
             "clGetExtensionFunctionAddress" => 1,
+            "clGetExtensionFunctionAddressForPlatform" => 1,

# deprecated and absent from headers
             "clSetCommandQueueProperty" => 1,
@@ -258,9 +264,11 @@ sub needs_unix_wrapper($)
         (
             # need callback conversion
             "clBuildProgram" => 1,
+            "clCompileProgram" => 1,
             "clCreateContext" => 1,
             "clCreateContextFromType" => 1,
             "clEnqueueNativeKernel" => 1,
+            "clLinkProgram" => 1,
             "clSetEventCallback" => 1,
             "clSetMemObjectDestructorCallback" => 1,
         );
@@ -275,6 +283,7 @@ sub needs_unix_function($)
     my %funcs =
         (
             "clGetExtensionFunctionAddress" => 1,
+            "clGetExtensionFunctionAddressForPlatform" => 1,
             "clSetCommandQueueProperty" => 1,
         );
     my $name = shift;
diff --git a/dlls/opencl/opencl.spec b/dlls/opencl/opencl.spec
index 099b9617cd0..2560e82ad5e 100644
--- a/dlls/opencl/opencl.spec
+++ b/dlls/opencl/opencl.spec
@@ -1,26 +1,35 @@
 @ stdcall clBuildProgram(ptr long ptr ptr ptr ptr)
+@ stdcall clCompileProgram(ptr long ptr ptr long ptr ptr ptr ptr)
 @ stdcall clCreateBuffer(ptr int64 long ptr ptr)
 @ stdcall clCreateCommandQueue(ptr ptr int64 ptr)
 @ stdcall clCreateContext(ptr long ptr ptr ptr ptr)
 @ stdcall clCreateContextFromType(ptr int64 ptr ptr ptr)
+@ stdcall clCreateImage(ptr int64 ptr ptr ptr ptr)
 @ stdcall clCreateImage2D(ptr int64 ptr long long long ptr ptr)
 @ stdcall clCreateImage3D(ptr int64 ptr long long long long long ptr ptr)
 @ stdcall clCreateKernel(ptr ptr ptr)
 @ stdcall clCreateKernelsInProgram(ptr long ptr ptr)
 @ stdcall clCreateProgramWithBinary(ptr long ptr ptr ptr ptr ptr)
+@ stdcall clCreateProgramWithBuiltInKernels(ptr long ptr ptr ptr)
 @ stdcall clCreateProgramWithSource(ptr long ptr ptr ptr)
 @ stdcall clCreateSampler(ptr long long long ptr)
 @ stdcall clCreateSubBuffer(ptr int64 long ptr ptr)
+@ stdcall clCreateSubDevices(ptr ptr long ptr ptr)
 @ stdcall clCreateUserEvent(ptr ptr)
 @ stdcall clEnqueueBarrier(ptr)
+@ stdcall clEnqueueBarrierWithWaitList(ptr long ptr ptr)
 @ stdcall clEnqueueCopyBuffer(ptr ptr ptr long long long long ptr ptr)
 @ stdcall clEnqueueCopyBufferRect(ptr ptr ptr ptr ptr ptr long long long long long ptr ptr)
 @ stdcall clEnqueueCopyBufferToImage(ptr ptr ptr long ptr ptr long ptr ptr)
 @ stdcall clEnqueueCopyImage(ptr ptr ptr ptr ptr ptr long ptr ptr)
 @ stdcall clEnqueueCopyImageToBuffer(ptr ptr ptr ptr ptr long long ptr ptr)
+@ stdcall clEnqueueFillBuffer(ptr ptr ptr long long long long ptr ptr)
+@ stdcall clEnqueueFillImage(ptr ptr ptr ptr ptr long ptr ptr)
 @ stdcall clEnqueueMapBuffer(ptr ptr long int64 long long long ptr ptr ptr)
 @ stdcall clEnqueueMapImage(ptr ptr long int64 ptr ptr ptr ptr long ptr ptr ptr)
 @ stdcall clEnqueueMarker(ptr ptr)
+@ stdcall clEnqueueMarkerWithWaitList(ptr long ptr ptr)
+@ stdcall clEnqueueMigrateMemObjects(ptr long ptr int64 long ptr ptr)
 @ stdcall clEnqueueNDRangeKernel(ptr ptr long ptr ptr ptr long ptr ptr)
 @ stdcall clEnqueueNativeKernel(ptr ptr ptr long long ptr ptr long ptr ptr)
 @ stdcall clEnqueueReadBuffer(ptr ptr long long long ptr long ptr ptr)
@@ -41,7 +50,9 @@
 @ stdcall clGetEventInfo(ptr long long ptr ptr)
 @ stdcall clGetEventProfilingInfo(ptr long long ptr ptr)
 @ stdcall clGetExtensionFunctionAddress(ptr)
+@ stdcall clGetExtensionFunctionAddressForPlatform(ptr ptr)
 @ stdcall clGetImageInfo(ptr long long ptr ptr)
+@ stdcall clGetKernelArgInfo(ptr long long long ptr ptr)
 @ stdcall clGetKernelInfo(ptr long long ptr ptr)
 @ stdcall clGetKernelWorkGroupInfo(ptr ptr long long ptr ptr)
 @ stdcall clGetMemObjectInfo(ptr long long ptr ptr)
@@ -51,8 +62,10 @@
 @ stdcall clGetProgramInfo(ptr long long ptr ptr)
 @ stdcall clGetSamplerInfo(ptr long long ptr ptr)
 @ stdcall clGetSupportedImageFormats(ptr int64 long long ptr ptr)
+@ stdcall clLinkProgram(ptr long ptr ptr long ptr ptr ptr ptr)
 @ stdcall clReleaseCommandQueue(ptr)
 @ stdcall clReleaseContext(ptr)
+@ stdcall clReleaseDevice(ptr)
 @ stdcall clReleaseEvent(ptr)
 @ stdcall clReleaseKernel(ptr)
 @ stdcall clReleaseMemObject(ptr)
@@ -60,6 +73,7 @@
 @ stdcall clReleaseSampler(ptr)
 @ stdcall clRetainCommandQueue(ptr)
 @ stdcall clRetainContext(ptr)
+@ stdcall clRetainDevice(ptr)
 @ stdcall clRetainEvent(ptr)
 @ stdcall clRetainKernel(ptr)
 @ stdcall clRetainMemObject(ptr)
@@ -71,4 +85,5 @@
 @ stdcall clSetMemObjectDestructorCallback(ptr ptr ptr)
 @ stdcall clSetUserEventStatus(ptr long)
 @ stdcall clUnloadCompiler()
+@ stdcall clUnloadPlatformCompiler(ptr)
 @ stdcall clWaitForEvents(long ptr)
diff --git a/dlls/opencl/opencl_types.h b/dlls/opencl/opencl_types.h
index 5d10b2c9ee1..6d6dc0d870c 100644
--- a/dlls/opencl/opencl_types.h
+++ b/dlls/opencl/opencl_types.h
@@ -55,6 +55,30 @@ typedef struct _cl_buffer_region
     size_t size;
 } cl_buffer_region;
 typedef cl_uint          cl_buffer_create_type;
+typedef intptr_t         cl_device_partition_property;
+typedef cl_bitfield      cl_device_affinity_domain;
+typedef cl_bitfield      cl_mem_migration_flags;
+typedef cl_uint          cl_program_binary_type;
+typedef cl_uint          cl_kernel_arg_info;
+typedef cl_uint          cl_kernel_arg_address_qualifier;
+typedef cl_uint          cl_kernel_arg_access_qualifier;
+typedef cl_bitfield      cl_kernel_arg_type_qualifier;
+typedef struct _cl_image_desc
+{
+    cl_mem_object_type image_type;
+    size_t image_width;
+    size_t image_height;
+    size_t image_depth;
+    size_t image_array_size;
+    size_t image_row_pitch;
+    size_t image_slice_pitch;
+    cl_uint num_mip_levels;
+    cl_uint num_samples;
+    union {
+ cl_mem buffer;
+ cl_mem mem_object;
+ };
+} cl_image_desc;

#define CL_A 0x10B1
 #define CL_ADDRESS_CLAMP 0x1132
@@ -64,6 +88,7 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_ADDRESS_REPEAT 0x1133
 #define CL_ARGB 0x10B7
 #define CL_BGRA 0x10B6
+#define CL_BLOCKING CL_TRUE
 #define CL_BUFFER_CREATE_TYPE_REGION 0x1220
 #define CL_BUILD_ERROR -2
 #define CL_BUILD_IN_PROGRESS -3
@@ -74,14 +99,18 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_CHAR_MAX CL_SCHAR_MAX
 #define CL_CHAR_MIN CL_SCHAR_MIN
 #define CL_COMMAND_ACQUIRE_GL_OBJECTS 0x11FF
+#define CL_COMMAND_BARRIER 0x1205
 #define CL_COMMAND_COPY_BUFFER 0x11F5
 #define CL_COMMAND_COPY_BUFFER_RECT 0x1203
 #define CL_COMMAND_COPY_BUFFER_TO_IMAGE 0x11FA
 #define CL_COMMAND_COPY_IMAGE 0x11F8
 #define CL_COMMAND_COPY_IMAGE_TO_BUFFER 0x11F9
+#define CL_COMMAND_FILL_BUFFER 0x1207
+#define CL_COMMAND_FILL_IMAGE 0x1208
 #define CL_COMMAND_MAP_BUFFER 0x11FB
 #define CL_COMMAND_MAP_IMAGE 0x11FC
 #define CL_COMMAND_MARKER 0x11FE
+#define CL_COMMAND_MIGRATE_MEM_OBJECTS 0x1206
 #define CL_COMMAND_NATIVE_KERNEL 0x11F2
 #define CL_COMMAND_NDRANGE_KERNEL 0x11F0
 #define CL_COMMAND_READ_BUFFER 0x11F3
@@ -95,8 +124,10 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_COMMAND_WRITE_BUFFER_RECT 0x1202
 #define CL_COMMAND_WRITE_IMAGE 0x11F7
 #define CL_COMPILER_NOT_AVAILABLE -3
+#define CL_COMPILE_PROGRAM_FAILURE -15
 #define CL_COMPLETE 0x0
 #define CL_CONTEXT_DEVICES 0x1081
+#define CL_CONTEXT_INTEROP_USER_SYNC 0x1085
 #define CL_CONTEXT_NUM_DEVICES 0x1083
 #define CL_CONTEXT_PLATFORM 0x1084
 #define CL_CONTEXT_PROPERTIES 0x1082
@@ -112,8 +143,16 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_DBL_MIN_EXP -1021
 #define CL_DBL_RADIX 2
 #define CL_DEVICE_ADDRESS_BITS 0x100D
+#define CL_DEVICE_AFFINITY_DOMAIN_L1_CACHE (1 << 4)
+#define CL_DEVICE_AFFINITY_DOMAIN_L2_CACHE (1 << 3)
+#define CL_DEVICE_AFFINITY_DOMAIN_L3_CACHE (1 << 2)
+#define CL_DEVICE_AFFINITY_DOMAIN_L4_CACHE (1 << 1)
+#define CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE (1 << 5)
+#define CL_DEVICE_AFFINITY_DOMAIN_NUMA (1 << 0)
 #define CL_DEVICE_AVAILABLE 0x1027
+#define CL_DEVICE_BUILT_IN_KERNELS 0x103F
 #define CL_DEVICE_COMPILER_AVAILABLE 0x1028
+#define CL_DEVICE_DOUBLE_FP_CONFIG 0x1032
 #define CL_DEVICE_ENDIAN_LITTLE 0x1026
 #define CL_DEVICE_ERROR_CORRECTION_SUPPORT 0x1024
 #define CL_DEVICE_EXECUTION_CAPABILITIES 0x1029
@@ -128,7 +167,10 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_DEVICE_IMAGE3D_MAX_DEPTH 0x1015
 #define CL_DEVICE_IMAGE3D_MAX_HEIGHT 0x1014
 #define CL_DEVICE_IMAGE3D_MAX_WIDTH 0x1013
+#define CL_DEVICE_IMAGE_MAX_ARRAY_SIZE 0x1041
+#define CL_DEVICE_IMAGE_MAX_BUFFER_SIZE 0x1040
 #define CL_DEVICE_IMAGE_SUPPORT 0x1016
+#define CL_DEVICE_LINKER_AVAILABLE 0x103E
 #define CL_DEVICE_LOCAL_MEM_SIZE 0x1023
 #define CL_DEVICE_LOCAL_MEM_TYPE 0x1022
 #define CL_DEVICE_MAX_CLOCK_FREQUENCY 0x100C
@@ -156,7 +198,18 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_DEVICE_NOT_AVAILABLE -2
 #define CL_DEVICE_NOT_FOUND -1
 #define CL_DEVICE_OPENCL_C_VERSION 0x103D
+#define CL_DEVICE_PARENT_DEVICE 0x1042
+#define CL_DEVICE_PARTITION_AFFINITY_DOMAIN 0x1045
+#define CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN 0x1088
+#define CL_DEVICE_PARTITION_BY_COUNTS 0x1087
+#define CL_DEVICE_PARTITION_BY_COUNTS_LIST_END 0x0
+#define CL_DEVICE_PARTITION_EQUALLY 0x1086
+#define CL_DEVICE_PARTITION_FAILED -18
+#define CL_DEVICE_PARTITION_MAX_SUB_DEVICES 0x1043
+#define CL_DEVICE_PARTITION_PROPERTIES 0x1044
+#define CL_DEVICE_PARTITION_TYPE 0x1046
 #define CL_DEVICE_PLATFORM 0x1031
+#define CL_DEVICE_PREFERRED_INTEROP_USER_SYNC 0x1048
 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR 0x1006
 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE 0x100B
 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT 0x100A
@@ -164,14 +217,17 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT 0x1008
 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG 0x1009
 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT 0x1007
+#define CL_DEVICE_PRINTF_BUFFER_SIZE 0x1049
 #define CL_DEVICE_PROFILE 0x102E
 #define CL_DEVICE_PROFILING_TIMER_RESOLUTION 0x1025
 #define CL_DEVICE_QUEUE_PROPERTIES 0x102A
+#define CL_DEVICE_REFERENCE_COUNT 0x1047
 #define CL_DEVICE_SINGLE_FP_CONFIG 0x101B
 #define CL_DEVICE_TYPE 0x1000
 #define CL_DEVICE_TYPE_ACCELERATOR (1 << 3)
 #define CL_DEVICE_TYPE_ALL 0xFFFFFFFF
 #define CL_DEVICE_TYPE_CPU (1 << 1)
+#define CL_DEVICE_TYPE_CUSTOM (1 << 4)
 #define CL_DEVICE_TYPE_DEFAULT (1 << 0)
 #define CL_DEVICE_TYPE_GPU (1 << 2)
 #define CL_DEVICE_VENDOR 0x102C
@@ -200,6 +256,7 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_FLT_MIN_10_EXP -37
 #define CL_FLT_MIN_EXP -125
 #define CL_FLT_RADIX 2
+#define CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT (1 << 7)
 #define CL_FP_DENORM (1 << 0)
 #define CL_FP_FMA (1 << 5)
 #define CL_FP_INF_NAN (1 << 1)
@@ -211,12 +268,16 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_HALF_FLOAT 0x10DD
 #define CL_HUGE_VAL ((cl_double) 1e500)
 #define CL_HUGE_VALF ((cl_float) 1e50)
+#define CL_IMAGE_ARRAY_SIZE 0x1117
+#define CL_IMAGE_BUFFER 0x1118
 #define CL_IMAGE_DEPTH 0x1116
 #define CL_IMAGE_ELEMENT_SIZE 0x1111
 #define CL_IMAGE_FORMAT 0x1110
 #define CL_IMAGE_FORMAT_MISMATCH -9
 #define CL_IMAGE_FORMAT_NOT_SUPPORTED -10
 #define CL_IMAGE_HEIGHT 0x1115
+#define CL_IMAGE_NUM_MIP_LEVELS 0x1119
+#define CL_IMAGE_NUM_SAMPLES 0x111A
 #define CL_IMAGE_ROW_PITCH 0x1112
 #define CL_IMAGE_SLICE_PITCH 0x1113
 #define CL_IMAGE_WIDTH 0x1114
@@ -231,8 +292,10 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_INVALID_BUFFER_SIZE -61
 #define CL_INVALID_BUILD_OPTIONS -43
 #define CL_INVALID_COMMAND_QUEUE -36
+#define CL_INVALID_COMPILER_OPTIONS -66
 #define CL_INVALID_CONTEXT -34
 #define CL_INVALID_DEVICE -33
+#define CL_INVALID_DEVICE_PARTITION_COUNT -68
 #define CL_INVALID_DEVICE_TYPE -31
 #define CL_INVALID_EVENT -58
 #define CL_INVALID_EVENT_WAIT_LIST -57
@@ -240,12 +303,14 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_INVALID_GLOBAL_WORK_SIZE -63
 #define CL_INVALID_GL_OBJECT -60
 #define CL_INVALID_HOST_PTR -37
+#define CL_INVALID_IMAGE_DESCRIPTOR -65
 #define CL_INVALID_IMAGE_FORMAT_DESCRIPTOR -39
 #define CL_INVALID_IMAGE_SIZE -40
 #define CL_INVALID_KERNEL -48
 #define CL_INVALID_KERNEL_ARGS -52
 #define CL_INVALID_KERNEL_DEFINITION -47
 #define CL_INVALID_KERNEL_NAME -46
+#define CL_INVALID_LINKER_OPTIONS -67
 #define CL_INVALID_MEM_OBJECT -38
 #define CL_INVALID_MIP_LEVEL -62
 #define CL_INVALID_OPERATION -59
@@ -259,9 +324,29 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_INVALID_WORK_DIMENSION -53
 #define CL_INVALID_WORK_GROUP_SIZE -54
 #define CL_INVALID_WORK_ITEM_SIZE -55
+#define CL_KERNEL_ARG_ACCESS_NONE 0x11A3
+#define CL_KERNEL_ARG_ACCESS_QUALIFIER 0x1197
+#define CL_KERNEL_ARG_ACCESS_READ_ONLY 0x11A0
+#define CL_KERNEL_ARG_ACCESS_READ_WRITE 0x11A2
+#define CL_KERNEL_ARG_ACCESS_WRITE_ONLY 0x11A1
+#define CL_KERNEL_ARG_ADDRESS_CONSTANT 0x119D
+#define CL_KERNEL_ARG_ADDRESS_GLOBAL 0x119B
+#define CL_KERNEL_ARG_ADDRESS_LOCAL 0x119C
+#define CL_KERNEL_ARG_ADDRESS_PRIVATE 0x119E
+#define CL_KERNEL_ARG_ADDRESS_QUALIFIER 0x1196
+#define CL_KERNEL_ARG_INFO_NOT_AVAILABLE -19
+#define CL_KERNEL_ARG_NAME 0x119A
+#define CL_KERNEL_ARG_TYPE_CONST (1 << 0)
+#define CL_KERNEL_ARG_TYPE_NAME 0x1198
+#define CL_KERNEL_ARG_TYPE_NONE 0
+#define CL_KERNEL_ARG_TYPE_QUALIFIER 0x1199
+#define CL_KERNEL_ARG_TYPE_RESTRICT (1 << 1)
+#define CL_KERNEL_ARG_TYPE_VOLATILE (1 << 2)
+#define CL_KERNEL_ATTRIBUTES 0x1195
 #define CL_KERNEL_COMPILE_WORK_GROUP_SIZE 0x11B1
 #define CL_KERNEL_CONTEXT 0x1193
 #define CL_KERNEL_FUNCTION_NAME 0x1190
+#define CL_KERNEL_GLOBAL_WORK_SIZE 0x11B5
 #define CL_KERNEL_LOCAL_MEM_SIZE 0x11B2
 #define CL_KERNEL_NUM_ARGS 0x1191
 #define CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE 0x11B3
@@ -269,6 +354,8 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_KERNEL_PROGRAM 0x1194
 #define CL_KERNEL_REFERENCE_COUNT 0x1192
 #define CL_KERNEL_WORK_GROUP_SIZE 0x11B0
+#define CL_LINKER_NOT_AVAILABLE -16
+#define CL_LINK_PROGRAM_FAILURE -17
 #define CL_LOCAL 0x1
 #define CL_LONG_MAX ((cl_long) 0x7FFFFFFFFFFFFFFFLL)
 #define CL_LONG_MIN ((cl_long) -0x7FFFFFFFFFFFFFFFLL - 1LL)
@@ -276,6 +363,7 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_MAP_FAILURE -12
 #define CL_MAP_READ (1 << 0)
 #define CL_MAP_WRITE (1 << 1)
+#define CL_MAP_WRITE_INVALIDATE_REGION (1 << 2)
 #define CL_MAXFLOAT CL_FLT_MAX
 #define CL_MEM_ALLOC_HOST_PTR (1 << 4)
 #define CL_MEM_ASSOCIATED_MEMOBJECT 0x1107
@@ -283,11 +371,18 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_MEM_COPY_HOST_PTR (1 << 5)
 #define CL_MEM_COPY_OVERLAP -8
 #define CL_MEM_FLAGS 0x1101
+#define CL_MEM_HOST_NO_ACCESS (1 << 9)
 #define CL_MEM_HOST_PTR 0x1103
+#define CL_MEM_HOST_READ_ONLY (1 << 8)
+#define CL_MEM_HOST_WRITE_ONLY (1 << 7)
 #define CL_MEM_MAP_COUNT 0x1104
 #define CL_MEM_OBJECT_ALLOCATION_FAILURE -4
 #define CL_MEM_OBJECT_BUFFER 0x10F0
+#define CL_MEM_OBJECT_IMAGE1D 0x10F4
+#define CL_MEM_OBJECT_IMAGE1D_ARRAY 0x10F5
+#define CL_MEM_OBJECT_IMAGE1D_BUFFER 0x10F6
 #define CL_MEM_OBJECT_IMAGE2D 0x10F1
+#define CL_MEM_OBJECT_IMAGE2D_ARRAY 0x10F3
 #define CL_MEM_OBJECT_IMAGE3D 0x10F2
 #define CL_MEM_OFFSET 0x1108
 #define CL_MEM_READ_ONLY (1 << 2)
@@ -297,9 +392,12 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_MEM_TYPE 0x1100
 #define CL_MEM_USE_HOST_PTR (1 << 3)
 #define CL_MEM_WRITE_ONLY (1 << 1)
+#define CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED (1 << 1)
+#define CL_MIGRATE_MEM_OBJECT_HOST (1 << 0)
 #define CL_MISALIGNED_SUB_BUFFER_OFFSET -13
 #define CL_NAN (CL_INFINITY - CL_INFINITY)
 #define CL_NONE 0x0
+#define CL_NON_BLOCKING CL_FALSE
 #define CL_OUT_OF_HOST_MEMORY -6
 #define CL_OUT_OF_RESOURCES -5
 #define CL_PLATFORM_EXTENSIONS 0x0904
@@ -314,12 +412,19 @@ typedef cl_uint          cl_buffer_create_type;
 #define CL_PROFILING_INFO_NOT_AVAILABLE -7
 #define CL_PROGRAM_BINARIES 0x1166
 #define CL_PROGRAM_BINARY_SIZES 0x1165
+#define CL_PROGRAM_BINARY_TYPE 0x1184
+#define CL_PROGRAM_BINARY_TYPE_COMPILED_OBJECT 0x1
+#define CL_PROGRAM_BINARY_TYPE_EXECUTABLE 0x4
+#define CL_PROGRAM_BINARY_TYPE_LIBRARY 0x2
+#define CL_PROGRAM_BINARY_TYPE_NONE 0x0
 #define CL_PROGRAM_BUILD_LOG 0x1183
 #define CL_PROGRAM_BUILD_OPTIONS 0x1182
 #define CL_PROGRAM_BUILD_STATUS 0x1181
 #define CL_PROGRAM_CONTEXT 0x1161
 #define CL_PROGRAM_DEVICES 0x1163
+#define CL_PROGRAM_KERNEL_NAMES 0x1168
 #define CL_PROGRAM_NUM_DEVICES 0x1162
+#define CL_PROGRAM_NUM_KERNELS 0x1167
 #define CL_PROGRAM_REFERENCE_COUNT 0x1160
 #define CL_PROGRAM_SOURCE 0x1164
 #define CL_QUEUED 0x3
diff --git a/dlls/opencl/pe_thunks.c b/dlls/opencl/pe_thunks.c
index 74204aeb95c..4edc379cbe7 100644
--- a/dlls/opencl/pe_thunks.c
+++ b/dlls/opencl/pe_thunks.c
@@ -12,6 +12,12 @@ cl_int WINAPI clBuildProgram( cl_program program, cl_uint num_devices, const cl_
     return opencl_funcs->pclBuildProgram( program, num_devices, device_list, options, pfn_notify, user_data );
 }

+cl_int WINAPI clCompileProgram( 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 (WINAPI* pfn_notify)(cl_program program, void* user_data), void* user_data )
+{
+    TRACE( "(%p, %u, %p, %p, %u, %p, %p, %p, %p)\n", program, num_devices, device_list, options, num_input_headers, input_headers, header_include_names, pfn_notify, user_data );
+    return opencl_funcs->pclCompileProgram( program, num_devices, device_list, options, num_input_headers, input_headers, header_include_names, pfn_notify, user_data );
+}
+
 cl_mem WINAPI clCreateBuffer( cl_context context, cl_mem_flags flags, size_t size, void* host_ptr, cl_int* errcode_ret )
 {
     TRACE( "(%p, %s, %Iu, %p, %p)\n", context, wine_dbgstr_longlong(flags), size, host_ptr, errcode_ret );
@@ -36,6 +42,12 @@ cl_context WINAPI clCreateContextFromType( const cl_context_properties* properti
     return opencl_funcs->pclCreateContextFromType( properties, device_type, pfn_notify, user_data, errcode_ret );
 }

+cl_mem WINAPI clCreateImage( 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 )
+{
+    TRACE( "(%p, %s, %p, %p, %p, %p)\n", context, wine_dbgstr_longlong(flags), image_format, image_desc, host_ptr, errcode_ret );
+    return opencl_funcs->pclCreateImage( context, flags, image_format, image_desc, host_ptr, errcode_ret );
+}
+
 cl_mem WINAPI clCreateImage2D( 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 )
 {
     TRACE( "(%p, %s, %p, %Iu, %Iu, %Iu, %p, %p)\n", context, wine_dbgstr_longlong(flags), image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret );
@@ -66,6 +78,12 @@ cl_program WINAPI clCreateProgramWithBinary( cl_context context, cl_uint num_dev
     return opencl_funcs->pclCreateProgramWithBinary( context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret );
 }

+cl_program WINAPI clCreateProgramWithBuiltInKernels( cl_context context, cl_uint num_devices, const cl_device_id* device_list, const char* kernel_names, cl_int* errcode_ret )
+{
+    TRACE( "(%p, %u, %p, %p, %p)\n", context, num_devices, device_list, kernel_names, errcode_ret );
+    return opencl_funcs->pclCreateProgramWithBuiltInKernels( context, num_devices, device_list, kernel_names, errcode_ret );
+}
+
 cl_program WINAPI clCreateProgramWithSource( cl_context context, cl_uint count, const char** strings, const size_t* lengths, cl_int* errcode_ret )
 {
     TRACE( "(%p, %u, %p, %p, %p)\n", context, count, strings, lengths, errcode_ret );
@@ -84,6 +102,12 @@ cl_mem WINAPI clCreateSubBuffer( cl_mem buffer, cl_mem_flags flags, cl_buffer_cr
     return opencl_funcs->pclCreateSubBuffer( buffer, flags, buffer_create_type, buffer_create_info, errcode_ret );
 }

+cl_int WINAPI clCreateSubDevices( 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 )
+{
+    TRACE( "(%p, %p, %u, %p, %p)\n", in_device, properties, num_devices, out_devices, num_devices_ret );
+    return opencl_funcs->pclCreateSubDevices( in_device, properties, num_devices, out_devices, num_devices_ret );
+}
+
 cl_event WINAPI clCreateUserEvent( cl_context context, cl_int* errcode_ret )
 {
     TRACE( "(%p, %p)\n", context, errcode_ret );
@@ -96,6 +120,12 @@ cl_int WINAPI clEnqueueBarrier( cl_command_queue command_queue )
     return opencl_funcs->pclEnqueueBarrier( command_queue );
 }

+cl_int WINAPI clEnqueueBarrierWithWaitList( cl_command_queue command_queue, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
+{
+    TRACE( "(%p, %u, %p, %p)\n", command_queue, num_events_in_wait_list, event_wait_list, event );
+    return opencl_funcs->pclEnqueueBarrierWithWaitList( command_queue, num_events_in_wait_list, event_wait_list, event );
+}
+
 cl_int WINAPI clEnqueueCopyBuffer( 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 )
 {
     TRACE( "(%p, %p, %p, %Iu, %Iu, %Iu, %u, %p, %p)\n", command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, event );
@@ -126,6 +156,18 @@ cl_int WINAPI clEnqueueCopyImageToBuffer( cl_command_queue command_queue, cl_mem
     return opencl_funcs->pclEnqueueCopyImageToBuffer( command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event );
 }

+cl_int WINAPI clEnqueueFillBuffer( 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 )
+{
+    TRACE( "(%p, %p, %p, %Iu, %Iu, %Iu, %u, %p, %p)\n", command_queue, buffer, pattern, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, event );
+    return opencl_funcs->pclEnqueueFillBuffer( command_queue, buffer, pattern, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, event );
+}
+
+cl_int WINAPI clEnqueueFillImage( 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 )
+{
+    TRACE( "(%p, %p, %p, %p, %p, %u, %p, %p)\n", command_queue, image, fill_color, origin, region, num_events_in_wait_list, event_wait_list, event );
+    return opencl_funcs->pclEnqueueFillImage( command_queue, image, fill_color, origin, region, num_events_in_wait_list, event_wait_list, event );
+}
+
 void* WINAPI clEnqueueMapBuffer( 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 )
 {
     TRACE( "(%p, %p, %u, %s, %Iu, %Iu, %u, %p, %p, %p)\n", command_queue, buffer, blocking_map, wine_dbgstr_longlong(map_flags), offset, size, num_events_in_wait_list, event_wait_list, event, errcode_ret );
@@ -144,6 +186,18 @@ cl_int WINAPI clEnqueueMarker( cl_command_queue command_queue, cl_event* event )
     return opencl_funcs->pclEnqueueMarker( command_queue, event );
 }

+cl_int WINAPI clEnqueueMarkerWithWaitList( cl_command_queue command_queue, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
+{
+    TRACE( "(%p, %u, %p, %p)\n", command_queue, num_events_in_wait_list, event_wait_list, event );
+    return opencl_funcs->pclEnqueueMarkerWithWaitList( command_queue, num_events_in_wait_list, event_wait_list, event );
+}
+
+cl_int WINAPI clEnqueueMigrateMemObjects( 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 )
+{
+    TRACE( "(%p, %u, %p, %s, %u, %p, %p)\n", command_queue, num_mem_objects, mem_objects, wine_dbgstr_longlong(flags), num_events_in_wait_list, event_wait_list, event );
+    return opencl_funcs->pclEnqueueMigrateMemObjects( command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, event );
+}
+
 cl_int WINAPI clEnqueueNDRangeKernel( 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 )
 {
     TRACE( "(%p, %p, %u, %p, %p, %p, %u, %p, %p)\n", command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event );
@@ -258,6 +312,12 @@ cl_int WINAPI clGetImageInfo( cl_mem image, cl_image_info param_name, size_t par
     return opencl_funcs->pclGetImageInfo( image, param_name, param_value_size, param_value, param_value_size_ret );
 }

+cl_int WINAPI clGetKernelArgInfo( 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 )
+{
+    TRACE( "(%p, %u, %u, %Iu, %p, %p)\n", kernel, arg_index, param_name, param_value_size, param_value, param_value_size_ret );
+    return opencl_funcs->pclGetKernelArgInfo( kernel, arg_index, param_name, param_value_size, param_value, param_value_size_ret );
+}
+
 cl_int WINAPI clGetKernelInfo( cl_kernel kernel, cl_kernel_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
 {
     TRACE( "(%p, %u, %Iu, %p, %p)\n", kernel, param_name, param_value_size, param_value, param_value_size_ret );
@@ -306,6 +366,12 @@ cl_int WINAPI clGetSupportedImageFormats( cl_context context, cl_mem_flags flags
     return opencl_funcs->pclGetSupportedImageFormats( context, flags, image_type, num_entries, image_formats, num_image_formats );
 }

+cl_program WINAPI 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 (WINAPI* pfn_notify)(cl_program program, void* user_data), void* user_data, cl_int* errcode_ret )
+{
+    TRACE( "(%p, %u, %p, %p, %u, %p, %p, %p, %p)\n", context, num_devices, device_list, options, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret );
+    return opencl_funcs->pclLinkProgram( context, num_devices, device_list, options, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret );
+}
+
 cl_int WINAPI clReleaseCommandQueue( cl_command_queue command_queue )
 {
     TRACE( "(%p)\n", command_queue );
@@ -318,6 +384,12 @@ cl_int WINAPI clReleaseContext( cl_context context )
     return opencl_funcs->pclReleaseContext( context );
 }

+cl_int WINAPI clReleaseDevice( cl_device_id device )
+{
+    TRACE( "(%p)\n", device );
+    return opencl_funcs->pclReleaseDevice( device );
+}
+
 cl_int WINAPI clReleaseEvent( cl_event event )
 {
     TRACE( "(%p)\n", event );
@@ -360,6 +432,12 @@ cl_int WINAPI clRetainContext( cl_context context )
     return opencl_funcs->pclRetainContext( context );
 }

+cl_int WINAPI clRetainDevice( cl_device_id device )
+{
+    TRACE( "(%p)\n", device );
+    return opencl_funcs->pclRetainDevice( device );
+}
+
 cl_int WINAPI clRetainEvent( cl_event event )
 {
     TRACE( "(%p)\n", event );
@@ -420,6 +498,12 @@ cl_int WINAPI clUnloadCompiler( void  )
     return opencl_funcs->pclUnloadCompiler();
 }

+cl_int WINAPI clUnloadPlatformCompiler( cl_platform_id platform )
+{
+    TRACE( "(%p)\n", platform );
+    return opencl_funcs->pclUnloadPlatformCompiler( platform );
+}
+
 cl_int WINAPI clWaitForEvents( cl_uint num_events, const cl_event* event_list )
 {
     TRACE( "(%u, %p)\n", num_events, event_list );
diff --git a/dlls/opencl/pe_wrappers.c b/dlls/opencl/pe_wrappers.c
index a91797e8ac0..b2ce4fbd81a 100644
--- a/dlls/opencl/pe_wrappers.c
+++ b/dlls/opencl/pe_wrappers.c
@@ -185,6 +185,13 @@ cl_int WINAPI clSetCommandQueueProperty( cl_command_queue command_queue, cl_comm
 }

+void * WINAPI clGetExtensionFunctionAddressForPlatform( cl_platform_id platform, const char *func_name )
+{
+    FIXME( "(%p, %s) stub!\n", platform, debugstr_a(func_name) );
+    return NULL;
+}
+
+
 BOOL WINAPI DllMain( HINSTANCE instance, DWORD reason, void *reserved )
 {
     if (reason == DLL_PROCESS_ATTACH)
diff --git a/dlls/opencl/unix_private.h b/dlls/opencl/unix_private.h
index 324df387169..d139f144b76 100644
--- a/dlls/opencl/unix_private.h
+++ b/dlls/opencl/unix_private.h
@@ -71,6 +71,17 @@ cl_int WINAPI wrap_clSetMemObjectDestructorCallback(cl_mem memobj,
         void (WINAPI *pfn_notify)(cl_mem, void *),
         void *user_data) DECLSPEC_HIDDEN;

+cl_int WINAPI wrap_clCompileProgram( 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 (WINAPI *pfn_notify)(cl_program program, void *user_data),
+        void *user_data ) DECLSPEC_HIDDEN;
+
+cl_program WINAPI wrap_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 (WINAPI *pfn_notify)(cl_program program, void *user_data),
+        void *user_data, cl_int *errcode_ret ) DECLSPEC_HIDDEN;
+
 extern const struct opencl_funcs funcs;

#endif
diff --git a/dlls/opencl/unix_thunks.c b/dlls/opencl/unix_thunks.c
index 656d4787fb2..726f81bceb4 100644
--- a/dlls/opencl/unix_thunks.c
+++ b/dlls/opencl/unix_thunks.c
@@ -17,6 +17,11 @@ static cl_command_queue WINAPI wrap_clCreateCommandQueue( cl_context context, cl
     return clCreateCommandQueue( context, device, properties, errcode_ret );
 }

+static cl_mem WINAPI wrap_clCreateImage( 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 )
+{
+    return clCreateImage( context, flags, image_format, image_desc, host_ptr, errcode_ret );
+}
+
 static cl_mem WINAPI wrap_clCreateImage2D( 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 )
 {
     return clCreateImage2D( context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret );
@@ -42,6 +47,11 @@ static cl_program WINAPI wrap_clCreateProgramWithBinary( cl_context context, cl_
     return clCreateProgramWithBinary( context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret );
 }

+static cl_program WINAPI wrap_clCreateProgramWithBuiltInKernels( cl_context context, cl_uint num_devices, const cl_device_id* device_list, const char* kernel_names, cl_int* errcode_ret )
+{
+    return clCreateProgramWithBuiltInKernels( context, num_devices, device_list, kernel_names, errcode_ret );
+}
+
 static cl_program WINAPI wrap_clCreateProgramWithSource( cl_context context, cl_uint count, const char** strings, const size_t* lengths, cl_int* errcode_ret )
 {
     return clCreateProgramWithSource( context, count, strings, lengths, errcode_ret );
@@ -57,6 +67,11 @@ static cl_mem WINAPI wrap_clCreateSubBuffer( cl_mem buffer, cl_mem_flags flags,
     return clCreateSubBuffer( buffer, flags, buffer_create_type, buffer_create_info, errcode_ret );
 }

+static cl_int WINAPI wrap_clCreateSubDevices( 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 )
+{
+    return clCreateSubDevices( in_device, properties, num_devices, out_devices, num_devices_ret );
+}
+
 static cl_event WINAPI wrap_clCreateUserEvent( cl_context context, cl_int* errcode_ret )
 {
     return clCreateUserEvent( context, errcode_ret );
@@ -67,6 +82,11 @@ static cl_int WINAPI wrap_clEnqueueBarrier( cl_command_queue command_queue )
     return clEnqueueBarrier( command_queue );
 }

+static cl_int WINAPI wrap_clEnqueueBarrierWithWaitList( cl_command_queue command_queue, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
+{
+    return clEnqueueBarrierWithWaitList( command_queue, num_events_in_wait_list, event_wait_list, event );
+}
+
 static cl_int WINAPI wrap_clEnqueueCopyBuffer( 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 )
 {
     return clEnqueueCopyBuffer( command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, event );
@@ -92,6 +112,16 @@ static cl_int WINAPI wrap_clEnqueueCopyImageToBuffer( cl_command_queue command_q
     return clEnqueueCopyImageToBuffer( command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event );
 }

+static cl_int WINAPI wrap_clEnqueueFillBuffer( 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 )
+{
+    return clEnqueueFillBuffer( command_queue, buffer, pattern, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, event );
+}
+
+static cl_int WINAPI wrap_clEnqueueFillImage( 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 )
+{
+    return clEnqueueFillImage( command_queue, image, fill_color, origin, region, num_events_in_wait_list, event_wait_list, event );
+}
+
 static void* WINAPI wrap_clEnqueueMapBuffer( 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 )
 {
     return clEnqueueMapBuffer( command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list, event, errcode_ret );
@@ -107,6 +137,16 @@ static cl_int WINAPI wrap_clEnqueueMarker( cl_command_queue command_queue, cl_ev
     return clEnqueueMarker( command_queue, event );
 }

+static cl_int WINAPI wrap_clEnqueueMarkerWithWaitList( cl_command_queue command_queue, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
+{
+    return clEnqueueMarkerWithWaitList( command_queue, num_events_in_wait_list, event_wait_list, event );
+}
+
+static cl_int WINAPI wrap_clEnqueueMigrateMemObjects( 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 )
+{
+    return clEnqueueMigrateMemObjects( command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, event );
+}
+
 static cl_int WINAPI wrap_clEnqueueNDRangeKernel( 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 )
 {
     return clEnqueueNDRangeKernel( command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event );
@@ -202,6 +242,11 @@ static cl_int WINAPI wrap_clGetImageInfo( cl_mem image, cl_image_info param_name
     return clGetImageInfo( image, param_name, param_value_size, param_value, param_value_size_ret );
 }

+static cl_int WINAPI wrap_clGetKernelArgInfo( 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 )
+{
+    return clGetKernelArgInfo( kernel, arg_index, param_name, param_value_size, param_value, param_value_size_ret );
+}
+
 static cl_int WINAPI wrap_clGetKernelInfo( cl_kernel kernel, cl_kernel_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
 {
     return clGetKernelInfo( kernel, param_name, param_value_size, param_value, param_value_size_ret );
@@ -257,6 +302,11 @@ static cl_int WINAPI wrap_clReleaseContext( cl_context context )
     return clReleaseContext( context );
 }

+static cl_int WINAPI wrap_clReleaseDevice( cl_device_id device )
+{
+    return clReleaseDevice( device );
+}
+
 static cl_int WINAPI wrap_clReleaseEvent( cl_event event )
 {
     return clReleaseEvent( event );
@@ -292,6 +342,11 @@ static cl_int WINAPI wrap_clRetainContext( cl_context context )
     return clRetainContext( context );
 }

+static cl_int WINAPI wrap_clRetainDevice( cl_device_id device )
+{
+    return clRetainDevice( device );
+}
+
 static cl_int WINAPI wrap_clRetainEvent( cl_event event )
 {
     return clRetainEvent( event );
@@ -332,6 +387,11 @@ static cl_int WINAPI wrap_clUnloadCompiler( void  )
     return clUnloadCompiler();
 }

+static cl_int WINAPI wrap_clUnloadPlatformCompiler( cl_platform_id platform )
+{
+    return clUnloadPlatformCompiler( platform );
+}
+
 static cl_int WINAPI wrap_clWaitForEvents( cl_uint num_events, const cl_event* event_list )
 {
     return clWaitForEvents( num_events, event_list );
@@ -340,28 +400,37 @@ static cl_int WINAPI wrap_clWaitForEvents( cl_uint num_events, const cl_event* e
 const struct opencl_funcs funcs =
 {
     wrap_clBuildProgram,
+    wrap_clCompileProgram,
     wrap_clCreateBuffer,
     wrap_clCreateCommandQueue,
     wrap_clCreateContext,
     wrap_clCreateContextFromType,
+    wrap_clCreateImage,
     wrap_clCreateImage2D,
     wrap_clCreateImage3D,
     wrap_clCreateKernel,
     wrap_clCreateKernelsInProgram,
     wrap_clCreateProgramWithBinary,
+    wrap_clCreateProgramWithBuiltInKernels,
     wrap_clCreateProgramWithSource,
     wrap_clCreateSampler,
     wrap_clCreateSubBuffer,
+    wrap_clCreateSubDevices,
     wrap_clCreateUserEvent,
     wrap_clEnqueueBarrier,
+    wrap_clEnqueueBarrierWithWaitList,
     wrap_clEnqueueCopyBuffer,
     wrap_clEnqueueCopyBufferRect,
     wrap_clEnqueueCopyBufferToImage,
     wrap_clEnqueueCopyImage,
     wrap_clEnqueueCopyImageToBuffer,
+    wrap_clEnqueueFillBuffer,
+    wrap_clEnqueueFillImage,
     wrap_clEnqueueMapBuffer,
     wrap_clEnqueueMapImage,
     wrap_clEnqueueMarker,
+    wrap_clEnqueueMarkerWithWaitList,
+    wrap_clEnqueueMigrateMemObjects,
     wrap_clEnqueueNDRangeKernel,
     wrap_clEnqueueNativeKernel,
     wrap_clEnqueueReadBuffer,
@@ -382,6 +451,7 @@ const struct opencl_funcs funcs =
     wrap_clGetEventInfo,
     wrap_clGetEventProfilingInfo,
     wrap_clGetImageInfo,
+    wrap_clGetKernelArgInfo,
     wrap_clGetKernelInfo,
     wrap_clGetKernelWorkGroupInfo,
     wrap_clGetMemObjectInfo,
@@ -391,8 +461,10 @@ const struct opencl_funcs funcs =
     wrap_clGetProgramInfo,
     wrap_clGetSamplerInfo,
     wrap_clGetSupportedImageFormats,
+    wrap_clLinkProgram,
     wrap_clReleaseCommandQueue,
     wrap_clReleaseContext,
+    wrap_clReleaseDevice,
     wrap_clReleaseEvent,
     wrap_clReleaseKernel,
     wrap_clReleaseMemObject,
@@ -400,6 +472,7 @@ const struct opencl_funcs funcs =
     wrap_clReleaseSampler,
     wrap_clRetainCommandQueue,
     wrap_clRetainContext,
+    wrap_clRetainDevice,
     wrap_clRetainEvent,
     wrap_clRetainKernel,
     wrap_clRetainMemObject,
@@ -410,5 +483,6 @@ const struct opencl_funcs funcs =
     wrap_clSetMemObjectDestructorCallback,
     wrap_clSetUserEventStatus,
     wrap_clUnloadCompiler,
+    wrap_clUnloadPlatformCompiler,
     wrap_clWaitForEvents,
 };
diff --git a/dlls/opencl/unix_wrappers.c b/dlls/opencl/unix_wrappers.c
index fb4e611f3f0..9c83250b4e1 100644
--- a/dlls/opencl/unix_wrappers.c
+++ b/dlls/opencl/unix_wrappers.c
@@ -154,6 +154,26 @@ cl_int WINAPI wrap_clSetMemObjectDestructorCallback(cl_mem memobj,
     return CL_INVALID_OPERATION;
 }

+cl_int WINAPI wrap_clCompileProgram( 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 (WINAPI *pfn_notify)(cl_program program, void *user_data),
+        void *user_data )
+{
+    FIXME( "not yet implemented\n" );
+    return CL_INVALID_OPERATION;
+}
+
+cl_program WINAPI wrap_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 (WINAPI *pfn_notify)(cl_program program, void *user_data),
+        void *user_data, cl_int *errcode_ret )
+{
+    FIXME( "not yet implemented\n" );
+    *errcode_ret = CL_INVALID_OPERATION;
+    return NULL;
+}
+
 NTSTATUS CDECL __wine_init_unix_lib( HMODULE module, DWORD reason, const void *ptr_in, void *ptr_out )
 {
     if (reason != DLL_PROCESS_ATTACH) return STATUS_SUCCESS;
diff --git a/dlls/opencl/unixlib.h b/dlls/opencl/unixlib.h
index 617d590acc3..8d454a12b97 100644
--- a/dlls/opencl/unixlib.h
+++ b/dlls/opencl/unixlib.h
@@ -3,28 +3,37 @@
 struct opencl_funcs
 {
     cl_int (WINAPI *pclBuildProgram)( cl_program program, cl_uint num_devices, const cl_device_id* device_list, const char* options, void (WINAPI* pfn_notify)(cl_program program, void* user_data), void* user_data );
+    cl_int (WINAPI *pclCompileProgram)( 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 (WINAPI* pfn_notify)(cl_program program, void* user_data), void* user_data );
     cl_mem (WINAPI *pclCreateBuffer)( cl_context context, cl_mem_flags flags, size_t size, void* host_ptr, cl_int* errcode_ret );
     cl_command_queue (WINAPI *pclCreateCommandQueue)( cl_context context, cl_device_id device, cl_command_queue_properties properties, cl_int* errcode_ret );
     cl_context (WINAPI *pclCreateContext)( const cl_context_properties* properties, cl_uint num_devices, const cl_device_id* devices, void (WINAPI* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data), void* user_data, cl_int* errcode_ret );
     cl_context (WINAPI *pclCreateContextFromType)( const cl_context_properties* properties, cl_device_type device_type, void (WINAPI* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data), void* user_data, cl_int* errcode_ret );
+    cl_mem (WINAPI *pclCreateImage)( 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_mem (WINAPI *pclCreateImage2D)( 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_mem (WINAPI *pclCreateImage3D)( 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_kernel (WINAPI *pclCreateKernel)( cl_program program, const char* kernel_name, cl_int* errcode_ret );
     cl_int (WINAPI *pclCreateKernelsInProgram)( cl_program program, cl_uint num_kernels, cl_kernel* kernels, cl_uint* num_kernels_ret );
     cl_program (WINAPI *pclCreateProgramWithBinary)( 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_program (WINAPI *pclCreateProgramWithBuiltInKernels)( cl_context context, cl_uint num_devices, const cl_device_id* device_list, const char* kernel_names, cl_int* errcode_ret );
     cl_program (WINAPI *pclCreateProgramWithSource)( cl_context context, cl_uint count, const char** strings, const size_t* lengths, cl_int* errcode_ret );
     cl_sampler (WINAPI *pclCreateSampler)( cl_context context, cl_bool normalized_coords, cl_addressing_mode addressing_mode, cl_filter_mode filter_mode, cl_int* errcode_ret );
     cl_mem (WINAPI *pclCreateSubBuffer)( cl_mem buffer, cl_mem_flags flags, cl_buffer_create_type buffer_create_type, const void* buffer_create_info, cl_int* errcode_ret );
+    cl_int (WINAPI *pclCreateSubDevices)( 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_event (WINAPI *pclCreateUserEvent)( cl_context context, cl_int* errcode_ret );
     cl_int (WINAPI *pclEnqueueBarrier)( cl_command_queue command_queue );
+    cl_int (WINAPI *pclEnqueueBarrierWithWaitList)( cl_command_queue command_queue, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event );
     cl_int (WINAPI *pclEnqueueCopyBuffer)( 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_int (WINAPI *pclEnqueueCopyBufferRect)( 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_int (WINAPI *pclEnqueueCopyBufferToImage)( 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_int (WINAPI *pclEnqueueCopyImage)( 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_int (WINAPI *pclEnqueueCopyImageToBuffer)( 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_int (WINAPI *pclEnqueueFillBuffer)( 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_int (WINAPI *pclEnqueueFillImage)( 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 );
     void* (WINAPI *pclEnqueueMapBuffer)( 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 );
     void* (WINAPI *pclEnqueueMapImage)( 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_int (WINAPI *pclEnqueueMarker)( cl_command_queue command_queue, cl_event* event );
+    cl_int (WINAPI *pclEnqueueMarkerWithWaitList)( cl_command_queue command_queue, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event );
+    cl_int (WINAPI *pclEnqueueMigrateMemObjects)( 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_int (WINAPI *pclEnqueueNDRangeKernel)( 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_int (WINAPI *pclEnqueueNativeKernel)( cl_command_queue command_queue, void (WINAPI* 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_int (WINAPI *pclEnqueueReadBuffer)( 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 );
@@ -45,6 +54,7 @@ struct opencl_funcs
     cl_int (WINAPI *pclGetEventInfo)( cl_event event, cl_event_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
     cl_int (WINAPI *pclGetEventProfilingInfo)( cl_event event, cl_profiling_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
     cl_int (WINAPI *pclGetImageInfo)( cl_mem image, cl_image_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
+    cl_int (WINAPI *pclGetKernelArgInfo)( 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_int (WINAPI *pclGetKernelInfo)( cl_kernel kernel, cl_kernel_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
     cl_int (WINAPI *pclGetKernelWorkGroupInfo)( 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_int (WINAPI *pclGetMemObjectInfo)( cl_mem memobj, cl_mem_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
@@ -54,8 +64,10 @@ struct opencl_funcs
     cl_int (WINAPI *pclGetProgramInfo)( cl_program program, cl_program_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
     cl_int (WINAPI *pclGetSamplerInfo)( cl_sampler sampler, cl_sampler_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
     cl_int (WINAPI *pclGetSupportedImageFormats)( 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_program (WINAPI *pclLinkProgram)( 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 (WINAPI* pfn_notify)(cl_program program, void* user_data), void* user_data, cl_int* errcode_ret );
     cl_int (WINAPI *pclReleaseCommandQueue)( cl_command_queue command_queue );
     cl_int (WINAPI *pclReleaseContext)( cl_context context );
+    cl_int (WINAPI *pclReleaseDevice)( cl_device_id device );
     cl_int (WINAPI *pclReleaseEvent)( cl_event event );
     cl_int (WINAPI *pclReleaseKernel)( cl_kernel kernel );
     cl_int (WINAPI *pclReleaseMemObject)( cl_mem memobj );
@@ -63,6 +75,7 @@ struct opencl_funcs
     cl_int (WINAPI *pclReleaseSampler)( cl_sampler sampler );
     cl_int (WINAPI *pclRetainCommandQueue)( cl_command_queue command_queue );
     cl_int (WINAPI *pclRetainContext)( cl_context context );
+    cl_int (WINAPI *pclRetainDevice)( cl_device_id device );
     cl_int (WINAPI *pclRetainEvent)( cl_event event );
     cl_int (WINAPI *pclRetainKernel)( cl_kernel kernel );
     cl_int (WINAPI *pclRetainMemObject)( cl_mem memobj );
@@ -73,6 +86,7 @@ struct opencl_funcs
     cl_int (WINAPI *pclSetMemObjectDestructorCallback)( cl_mem memobj, void (WINAPI* pfn_notify)(cl_mem memobj, void* user_data), void* user_data );
     cl_int (WINAPI *pclSetUserEventStatus)( cl_event event, cl_int execution_status );
     cl_int (WINAPI *pclUnloadCompiler)( void  );
+    cl_int (WINAPI *pclUnloadPlatformCompiler)( cl_platform_id platform );
     cl_int (WINAPI *pclWaitForEvents)( cl_uint num_events, const cl_event* event_list );
 };

[Alexandre Julliard]

Zebediah Figura  writes:
> Signed-off-by: Zebediah Figura
>
> dlls/opencl/pe_wrappers.c | 3 ++-
>  1 file changed, 2 insertions(+), 1 deletion(-)
>
> diff --git a/dlls/opencl/pe_wrappers.c b/dlls/opencl/pe_wrappers.c
> index 35c78181580..56ff204c900 100644
> --- a/dlls/opencl/pe_wrappers.c
> +++ b/dlls/opencl/pe_wrappers.c
> @@ -132,7 +132,8 @@ BOOL WINAPI DllMain( HINSTANCE instance, DWORD reason, void *reserved )
>      if (reason == DLL_PROCESS_ATTACH)
>      {
>          DisableThreadLibraryCalls( instance );
> -
>    return __wine_init_unix_lib( instance, reason, NULL, &opencl_funcs );
> -
>    if (__wine_init_unix_lib( instance, reason, NULL, &opencl_funcs ))
> -
>        ERR( "failed to load libOpenCL\n" );

Sorry for screwing this up, but I still think the dll should fail to
load without the Unix library, that's how it behaved previously.

[Zebediah Figura (she/her)]

On 3/20/21 3:55 PM, Alexandre Julliard wrote:
> Zebediah Figura  writes:
> > Signed-off-by: Zebediah Figura
> >
> > dlls/opencl/pe_wrappers.c | 3 ++-
> >  1 file changed, 2 insertions(+), 1 deletion(-)
> >
> > diff --git a/dlls/opencl/pe_wrappers.c b/dlls/opencl/pe_wrappers.c
> > index 35c78181580..56ff204c900 100644
> > --- a/dlls/opencl/pe_wrappers.c
> > +++ b/dlls/opencl/pe_wrappers.c
> > @@ -132,7 +132,8 @@ BOOL WINAPI DllMain( HINSTANCE instance, DWORD reason, void *reserved )
> >      if (reason == DLL_PROCESS_ATTACH)
> >      {
> >          DisableThreadLibraryCalls( instance );
> > -
> >    return __wine_init_unix_lib( instance, reason, NULL, &opencl_funcs );
> > -
> >    if (__wine_init_unix_lib( instance, reason, NULL, &opencl_funcs ))
> > -
> >        ERR( "failed to load libOpenCL\n" );
>
> Sorry for screwing this up, but I still think the dll should fail to
> load without the Unix library, that's how it behaved previously.

Fair enough, I'll send an updated version.

Sorry for screwing this up on my end as well...