[PATCH 1/3] opencl: Move libOpenCL support to a new Unix library.
Zebediah Figura
z.figura12 at gmail.com
Mon Mar 15 23:44:50 CDT 2021
Signed-off-by: Zebediah Figura <z.figura12 at gmail.com>
---
If it helps for review, I can resend this series without the generated changes.
dlls/opencl/Makefile.in | 6 +-
dlls/opencl/make_opencl | 120 +++++-
dlls/opencl/opencl_private.h | 5 +
dlls/opencl/{opencl_thunks.c => pe_thunks.c} | 142 ++++---
dlls/opencl/{opencl.c => pe_wrappers.c} | 136 +------
dlls/opencl/unix_private.h | 45 +++
dlls/opencl/unix_thunks.c | 388 +++++++++++++++++++
dlls/opencl/unix_wrappers.c | 146 +++++++
dlls/opencl/unixlib.h | 73 ++++
9 files changed, 858 insertions(+), 203 deletions(-)
rename dlls/opencl/{opencl_thunks.c => pe_thunks.c} (65%)
rename dlls/opencl/{opencl.c => pe_wrappers.c} (36%)
create mode 100644 dlls/opencl/unix_private.h
create mode 100644 dlls/opencl/unix_thunks.c
create mode 100644 dlls/opencl/unix_wrappers.c
create mode 100644 dlls/opencl/unixlib.h
diff --git a/dlls/opencl/Makefile.in b/dlls/opencl/Makefile.in
index f9fa2dcaa96..8a6a03175cb 100644
--- a/dlls/opencl/Makefile.in
+++ b/dlls/opencl/Makefile.in
@@ -2,5 +2,7 @@ MODULE = opencl.dll
EXTRALIBS = $(OPENCL_LIBS)
C_SRCS = \
- opencl.c \
- opencl_thunks.c
+ pe_thunks.c \
+ pe_wrappers.c \
+ unix_thunks.c \
+ unix_wrappers.c
diff --git a/dlls/opencl/make_opencl b/dlls/opencl/make_opencl
index c3bc3da524c..fc5d4ad4bf6 100755
--- a/dlls/opencl/make_opencl
+++ b/dlls/opencl/make_opencl
@@ -20,7 +20,9 @@ use XML::LibXML;
# Files to generate
my $spec_file = "opencl.spec";
-my $thunks_file = "opencl_thunks.c";
+my $pe_file = "pe_thunks.c";
+my $unix_file = "unix_thunks.c";
+my $unixheader_file = "unixlib.h";
# If set to 1, generate TRACEs for each OpenGL function
my $gen_traces = 1;
@@ -49,7 +51,7 @@ my %arg_types =
"unsigned int" => [ "long", "%u" ],
);
-sub generate_thunk($$)
+sub generate_pe_thunk($$)
{
my ($name, $func_ref) = @_;
my $call_arg = "";
@@ -86,6 +88,28 @@ sub generate_thunk($$)
$ret .= " TRACE( \"($trace_arg)\\n\"$trace_call_arg );\n" if $gen_traces;
$ret .= " ";
$ret .= "return " unless is_void_func( $func_ref );
+ $ret .= "opencl_funcs->p$name($call_arg);\n";
+ $ret .= "}\n";
+ return $ret;
+}
+
+sub generate_unix_thunk($$)
+{
+ my ($name, $func_ref) = @_;
+ my $call_arg = "";
+
+ my $ret = get_func_proto( "static %s WINAPI wrap_%s(%s)", $name, $func_ref );
+ foreach my $arg (@{$func_ref->[1]})
+ {
+ my $ptype = get_arg_type( $arg );
+ next unless $arg->findnodes("./name");
+ my $pname = get_arg_name( $arg );
+ my $param = $arg->textContent();
+ $call_arg .= " " . $pname . ",";
+ }
+ $call_arg =~ s/,$/ /;
+ $ret .= "\n{\n ";
+ $ret .= "return " unless is_void_func( $func_ref );
$ret .= "$name($call_arg);\n";
$ret .= "}\n";
return $ret;
@@ -122,6 +146,7 @@ sub get_func_proto($$$)
foreach my $arg (@{$func->[1]})
{
(my $argtext = $arg->textContent()) =~ s/ +/ /g;
+ $argtext =~ s/CL_CALLBACK/WINAPI/g;
$args .= " " . $argtext . ",";
}
$args =~ s/,$/ /;
@@ -180,16 +205,10 @@ my %cl_enums;
my (%cl_types, @cl_types); # also use an array to preserve declaration order
# some functions need a hand-written wrapper
-sub needs_wrapper($)
+sub needs_pe_wrapper($)
{
my %funcs =
(
- # need callback conversion
- "clBuildProgram" => 1,
- "clCreateContext" => 1,
- "clCreateContextFromType" => 1,
- "clEnqueueNativeKernel" => 1,
-
# need extension filtering
"clGetDeviceInfo" => 1,
"clGetPlatformInfo" => 1,
@@ -202,6 +221,22 @@ sub needs_wrapper($)
return defined $funcs{$name};
}
+# some functions need a hand-written wrapper
+sub needs_unix_wrapper($)
+{
+ my %funcs =
+ (
+ # need callback conversion
+ "clBuildProgram" => 1,
+ "clCreateContext" => 1,
+ "clCreateContextFromType" => 1,
+ "clEnqueueNativeKernel" => 1,
+ );
+ my $name = shift;
+
+ return defined $funcs{$name};
+}
+
sub parse_file($)
{
my $file = shift;
@@ -279,21 +314,66 @@ foreach (sort keys %core_functions)
close(SPEC);
-my $file_header =
-"/* Automatically generated from OpenCL registry files; DO NOT EDIT! */\n\n" .
-"#include \"config.h\"\n" .
-"#include \"opencl_private.h\"\n\n";
+# generate the PE thunks
+open(PE, ">$pe_file") or die "cannot create $pe_file";
+
+print PE "/* Automatically generated from OpenCL registry files; DO NOT EDIT! */\n\n";
+
+print PE "#include \"config.h\"\n";
+print PE "#include \"opencl_private.h\"\n\n";
+
+print PE "WINE_DEFAULT_DEBUG_CHANNEL(opencl);\n" if $gen_traces;
+
+foreach (sort keys %core_functions)
+{
+ next if needs_pe_wrapper( $_ );
+ print PE "\n", generate_pe_thunk( $_, $core_functions{$_} );
+}
+
+close(PE);
+
+# generate the unix library thunks
+open(UNIX, ">$unix_file") or die "cannot create $unix_file";
+
+print UNIX <<EOF
+/* Automatically generated from OpenCL registry files; DO NOT EDIT! */
+
+#if 0
+#pragma makedep unix
+#endif
-$file_header .= "WINE_DEFAULT_DEBUG_CHANNEL(opencl);\n" if $gen_traces;
+#include "config.h"
+#include "unix_private.h"
+EOF
+;
-# generate the thunks file
-open(THUNKS, ">$thunks_file") or die "cannot create $thunks_file";
-print THUNKS $file_header;
+foreach (sort keys %core_functions)
+{
+ next if needs_unix_wrapper( $_ );
+ print UNIX "\n", generate_unix_thunk( $_, $core_functions{$_} );
+}
+print UNIX "\nconst struct opencl_funcs funcs =\n{\n";
foreach (sort keys %core_functions)
{
- next if needs_wrapper( $_ );
- print THUNKS "\n", generate_thunk( $_, $core_functions{$_} );
+ print UNIX " wrap_" . $_ . ",\n";
}
+print UNIX "};\n";
+
+close(UNIX);
+
+# generate the unix library header
+open(UNIXHEADER, ">$unixheader_file") or die "cannot create $unixheader_file";
+
+print UNIXHEADER "/* Automatically generated from OpenCL registry files; DO NOT EDIT! */\n\n";
+
+print UNIXHEADER "struct opencl_funcs\n{\n";
+foreach (sort keys %core_functions)
+{
+ print UNIXHEADER get_func_proto( " %s (WINAPI *p%s)(%s);\n", $_, $core_functions{$_} );
+}
+print UNIXHEADER "};\n\n";
+
+print UNIXHEADER "extern const struct opencl_funcs *opencl_funcs;\n";
-close(THUNKS);
+close(UNIXHEADER);
diff --git a/dlls/opencl/opencl_private.h b/dlls/opencl/opencl_private.h
index 1859f756f70..ff34dad94db 100644
--- a/dlls/opencl/opencl_private.h
+++ b/dlls/opencl/opencl_private.h
@@ -21,8 +21,11 @@
#include <stdarg.h>
+#include "ntstatus.h"
+#define WIN32_NO_STATUS
#include "windef.h"
#include "winbase.h"
+#include "winternl.h"
#include "wine/debug.h"
@@ -38,4 +41,6 @@
#include <OpenCL/opencl.h>
#endif
+#include "unixlib.h"
+
#endif
diff --git a/dlls/opencl/opencl_thunks.c b/dlls/opencl/pe_thunks.c
similarity index 65%
rename from dlls/opencl/opencl_thunks.c
rename to dlls/opencl/pe_thunks.c
index 0de573f57a0..0b91f885c18 100644
--- a/dlls/opencl/opencl_thunks.c
+++ b/dlls/opencl/pe_thunks.c
@@ -5,356 +5,380 @@
WINE_DEFAULT_DEBUG_CHANNEL(opencl);
+cl_int WINAPI wine_clBuildProgram( 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 )
+{
+ TRACE( "(%p, %u, %p, %p, %p, %p)\n", program, num_devices, device_list, options, pfn_notify, user_data );
+ return opencl_funcs->pclBuildProgram( program, num_devices, device_list, options, pfn_notify, user_data );
+}
+
cl_mem WINAPI wine_clCreateBuffer( cl_context context, cl_mem_flags flags, size_t size, void* host_ptr, cl_int* errcode_ret )
{
TRACE( "(%p, %s, %zu, %p, %p)\n", context, wine_dbgstr_longlong(flags), size, host_ptr, errcode_ret );
- return clCreateBuffer( context, flags, size, host_ptr, errcode_ret );
+ return opencl_funcs->pclCreateBuffer( context, flags, size, host_ptr, errcode_ret );
}
cl_command_queue WINAPI wine_clCreateCommandQueue( cl_context context, cl_device_id device, cl_command_queue_properties properties, cl_int* errcode_ret )
{
TRACE( "(%p, %p, %s, %p)\n", context, device, wine_dbgstr_longlong(properties), errcode_ret );
- return clCreateCommandQueue( context, device, properties, errcode_ret );
+ return opencl_funcs->pclCreateCommandQueue( context, device, properties, errcode_ret );
+}
+
+cl_context WINAPI wine_clCreateContext( 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 )
+{
+ TRACE( "(%p, %u, %p, %p, %p, %p)\n", properties, num_devices, devices, pfn_notify, user_data, errcode_ret );
+ return opencl_funcs->pclCreateContext( properties, num_devices, devices, pfn_notify, user_data, errcode_ret );
+}
+
+cl_context WINAPI wine_clCreateContextFromType( 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 )
+{
+ TRACE( "(%p, %s, %p, %p, %p)\n", properties, wine_dbgstr_longlong(device_type), pfn_notify, user_data, errcode_ret );
+ return opencl_funcs->pclCreateContextFromType( properties, device_type, pfn_notify, user_data, errcode_ret );
}
cl_mem WINAPI wine_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, %zu, %zu, %zu, %p, %p)\n", context, wine_dbgstr_longlong(flags), image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret );
- return clCreateImage2D( context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret );
+ return opencl_funcs->pclCreateImage2D( context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret );
}
cl_mem WINAPI wine_clCreateImage3D( 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 )
{
TRACE( "(%p, %s, %p, %zu, %zu, %zu, %zu, %zu, %p, %p)\n", context, wine_dbgstr_longlong(flags), image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret );
- return clCreateImage3D( context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret );
+ return opencl_funcs->pclCreateImage3D( context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret );
}
cl_kernel WINAPI wine_clCreateKernel( cl_program program, const char* kernel_name, cl_int* errcode_ret )
{
TRACE( "(%p, %p, %p)\n", program, kernel_name, errcode_ret );
- return clCreateKernel( program, kernel_name, errcode_ret );
+ return opencl_funcs->pclCreateKernel( program, kernel_name, errcode_ret );
}
cl_int WINAPI wine_clCreateKernelsInProgram( cl_program program, cl_uint num_kernels, cl_kernel* kernels, cl_uint* num_kernels_ret )
{
TRACE( "(%p, %u, %p, %p)\n", program, num_kernels, kernels, num_kernels_ret );
- return clCreateKernelsInProgram( program, num_kernels, kernels, num_kernels_ret );
+ return opencl_funcs->pclCreateKernelsInProgram( program, num_kernels, kernels, num_kernels_ret );
}
cl_program WINAPI wine_clCreateProgramWithBinary( 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 )
{
TRACE( "(%p, %u, %p, %p, %p, %p, %p)\n", context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret );
- return clCreateProgramWithBinary( context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret );
+ return opencl_funcs->pclCreateProgramWithBinary( context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret );
}
cl_program WINAPI wine_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 );
- return clCreateProgramWithSource( context, count, strings, lengths, errcode_ret );
+ return opencl_funcs->pclCreateProgramWithSource( context, count, strings, lengths, errcode_ret );
}
cl_sampler WINAPI wine_clCreateSampler( cl_context context, cl_bool normalized_coords, cl_addressing_mode addressing_mode, cl_filter_mode filter_mode, cl_int* errcode_ret )
{
TRACE( "(%p, %u, %u, %u, %p)\n", context, normalized_coords, addressing_mode, filter_mode, errcode_ret );
- return clCreateSampler( context, normalized_coords, addressing_mode, filter_mode, errcode_ret );
+ return opencl_funcs->pclCreateSampler( context, normalized_coords, addressing_mode, filter_mode, errcode_ret );
}
cl_int WINAPI wine_clEnqueueBarrier( cl_command_queue command_queue )
{
TRACE( "(%p)\n", command_queue );
- return clEnqueueBarrier( command_queue );
+ return opencl_funcs->pclEnqueueBarrier( command_queue );
}
cl_int WINAPI wine_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, %zu, %zu, %zu, %u, %p, %p)\n", command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, event );
- return clEnqueueCopyBuffer( command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, event );
+ 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 wine_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, %zu, %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 );
- return clEnqueueCopyBufferToImage( command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
+ return opencl_funcs->pclEnqueueCopyBufferToImage( command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_clEnqueueCopyImage( 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 )
{
TRACE( "(%p, %p, %p, %p, %p, %p, %u, %p, %p)\n", command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
- return clEnqueueCopyImage( command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
+ return opencl_funcs->pclEnqueueCopyImage( command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_clEnqueueCopyImageToBuffer( 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 )
{
TRACE( "(%p, %p, %p, %p, %p, %zu, %u, %p, %p)\n", command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event );
- return clEnqueueCopyImageToBuffer( command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event );
+ return opencl_funcs->pclEnqueueCopyImageToBuffer( command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event );
}
void* WINAPI wine_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, %zu, %zu, %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 );
- return clEnqueueMapBuffer( command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list, event, errcode_ret );
+ return opencl_funcs->pclEnqueueMapBuffer( command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list, event, errcode_ret );
}
void* WINAPI wine_clEnqueueMapImage( 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 )
{
TRACE( "(%p, %p, %u, %s, %p, %p, %p, %p, %u, %p, %p, %p)\n", command_queue, image, blocking_map, wine_dbgstr_longlong(map_flags), origin, region, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, event, errcode_ret );
- return clEnqueueMapImage( command_queue, image, blocking_map, map_flags, origin, region, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, event, errcode_ret );
+ return opencl_funcs->pclEnqueueMapImage( command_queue, image, blocking_map, map_flags, origin, region, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, event, errcode_ret );
}
cl_int WINAPI wine_clEnqueueMarker( cl_command_queue command_queue, cl_event* event )
{
TRACE( "(%p, %p)\n", command_queue, event );
- return clEnqueueMarker( command_queue, event );
+ return opencl_funcs->pclEnqueueMarker( command_queue, event );
}
cl_int WINAPI wine_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 );
- 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 );
+ return opencl_funcs->pclEnqueueNDRangeKernel( command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event );
+}
+
+cl_int WINAPI wine_clEnqueueNativeKernel( 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 )
+{
+ TRACE( "(%p, %p, %p, %zu, %u, %p, %p, %u, %p, %p)\n", command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, event );
+ return opencl_funcs->pclEnqueueNativeKernel( command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_clEnqueueReadBuffer( 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 )
{
TRACE( "(%p, %p, %u, %zu, %zu, %p, %u, %p, %p)\n", command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
- return clEnqueueReadBuffer( command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
+ return opencl_funcs->pclEnqueueReadBuffer( command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_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, %zu, %zu, %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 );
- return clEnqueueReadImage( command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
+ return opencl_funcs->pclEnqueueReadImage( command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_clEnqueueTask( cl_command_queue command_queue, cl_kernel kernel, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
{
TRACE( "(%p, %p, %u, %p, %p)\n", command_queue, kernel, num_events_in_wait_list, event_wait_list, event );
- return clEnqueueTask( command_queue, kernel, num_events_in_wait_list, event_wait_list, event );
+ return opencl_funcs->pclEnqueueTask( command_queue, kernel, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_clEnqueueUnmapMemObject( 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 )
{
TRACE( "(%p, %p, %p, %u, %p, %p)\n", command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event );
- return clEnqueueUnmapMemObject( command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event );
+ return opencl_funcs->pclEnqueueUnmapMemObject( command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_clEnqueueWaitForEvents( cl_command_queue command_queue, cl_uint num_events, const cl_event* event_list )
{
TRACE( "(%p, %u, %p)\n", command_queue, num_events, event_list );
- return clEnqueueWaitForEvents( command_queue, num_events, event_list );
+ return opencl_funcs->pclEnqueueWaitForEvents( command_queue, num_events, event_list );
}
cl_int WINAPI wine_clEnqueueWriteBuffer( 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 )
{
TRACE( "(%p, %p, %u, %zu, %zu, %p, %u, %p, %p)\n", command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
- return clEnqueueWriteBuffer( command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
+ return opencl_funcs->pclEnqueueWriteBuffer( command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_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, %zu, %zu, %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 );
- 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 );
+ return opencl_funcs->pclEnqueueWriteImage( command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
}
cl_int WINAPI wine_clFinish( cl_command_queue command_queue )
{
TRACE( "(%p)\n", command_queue );
- return clFinish( command_queue );
+ return opencl_funcs->pclFinish( command_queue );
}
cl_int WINAPI wine_clFlush( cl_command_queue command_queue )
{
TRACE( "(%p)\n", command_queue );
- return clFlush( command_queue );
+ return opencl_funcs->pclFlush( command_queue );
}
cl_int WINAPI wine_clGetCommandQueueInfo( cl_command_queue command_queue, cl_command_queue_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", command_queue, param_name, param_value_size, param_value, param_value_size_ret );
- return clGetCommandQueueInfo( command_queue, param_name, param_value_size, param_value, param_value_size_ret );
+ return opencl_funcs->pclGetCommandQueueInfo( command_queue, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetContextInfo( cl_context context, cl_context_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", context, param_name, param_value_size, param_value, param_value_size_ret );
- return clGetContextInfo( context, param_name, param_value_size, param_value, param_value_size_ret );
+ return opencl_funcs->pclGetContextInfo( context, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetDeviceIDs( cl_platform_id platform, cl_device_type device_type, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices )
{
TRACE( "(%p, %s, %u, %p, %p)\n", platform, wine_dbgstr_longlong(device_type), num_entries, devices, num_devices );
- return clGetDeviceIDs( platform, device_type, num_entries, devices, num_devices );
+ return opencl_funcs->pclGetDeviceIDs( platform, device_type, num_entries, devices, num_devices );
}
cl_int WINAPI wine_clGetEventInfo( cl_event event, cl_event_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", event, param_name, param_value_size, param_value, param_value_size_ret );
- return clGetEventInfo( event, param_name, param_value_size, param_value, param_value_size_ret );
+ return opencl_funcs->pclGetEventInfo( event, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetEventProfilingInfo( cl_event event, cl_profiling_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", event, param_name, param_value_size, param_value, param_value_size_ret );
- return clGetEventProfilingInfo( event, param_name, param_value_size, param_value, param_value_size_ret );
+ return opencl_funcs->pclGetEventProfilingInfo( event, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetImageInfo( cl_mem image, cl_image_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", image, param_name, param_value_size, param_value, param_value_size_ret );
- return clGetImageInfo( image, param_name, param_value_size, param_value, param_value_size_ret );
+ return opencl_funcs->pclGetImageInfo( image, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_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, %zu, %p, %p)\n", kernel, param_name, param_value_size, param_value, param_value_size_ret );
- return clGetKernelInfo( kernel, param_name, param_value_size, param_value, param_value_size_ret );
+ return opencl_funcs->pclGetKernelInfo( kernel, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetKernelWorkGroupInfo( 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 )
{
TRACE( "(%p, %p, %u, %zu, %p, %p)\n", kernel, device, param_name, param_value_size, param_value, param_value_size_ret );
- return clGetKernelWorkGroupInfo( kernel, device, param_name, param_value_size, param_value, param_value_size_ret );
+ return opencl_funcs->pclGetKernelWorkGroupInfo( kernel, device, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetMemObjectInfo( cl_mem memobj, cl_mem_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", memobj, param_name, param_value_size, param_value, param_value_size_ret );
- return clGetMemObjectInfo( memobj, param_name, param_value_size, param_value, param_value_size_ret );
+ return opencl_funcs->pclGetMemObjectInfo( memobj, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetPlatformIDs( cl_uint num_entries, cl_platform_id* platforms, cl_uint* num_platforms )
{
TRACE( "(%u, %p, %p)\n", num_entries, platforms, num_platforms );
- return clGetPlatformIDs( num_entries, platforms, num_platforms );
+ return opencl_funcs->pclGetPlatformIDs( num_entries, platforms, num_platforms );
}
cl_int WINAPI wine_clGetProgramBuildInfo( cl_program program, cl_device_id device, cl_program_build_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %p, %u, %zu, %p, %p)\n", program, device, param_name, param_value_size, param_value, param_value_size_ret );
- return clGetProgramBuildInfo( program, device, param_name, param_value_size, param_value, param_value_size_ret );
+ return opencl_funcs->pclGetProgramBuildInfo( program, device, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetProgramInfo( cl_program program, cl_program_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", program, param_name, param_value_size, param_value, param_value_size_ret );
- return clGetProgramInfo( program, param_name, param_value_size, param_value, param_value_size_ret );
+ return opencl_funcs->pclGetProgramInfo( program, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetSamplerInfo( cl_sampler sampler, cl_sampler_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
{
TRACE( "(%p, %u, %zu, %p, %p)\n", sampler, param_name, param_value_size, param_value, param_value_size_ret );
- return clGetSamplerInfo( sampler, param_name, param_value_size, param_value, param_value_size_ret );
+ return opencl_funcs->pclGetSamplerInfo( sampler, param_name, param_value_size, param_value, param_value_size_ret );
}
cl_int WINAPI wine_clGetSupportedImageFormats( 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 )
{
TRACE( "(%p, %s, %u, %u, %p, %p)\n", context, wine_dbgstr_longlong(flags), image_type, num_entries, image_formats, num_image_formats );
- return clGetSupportedImageFormats( context, flags, image_type, num_entries, image_formats, num_image_formats );
+ return opencl_funcs->pclGetSupportedImageFormats( context, flags, image_type, num_entries, image_formats, num_image_formats );
}
cl_int WINAPI wine_clReleaseCommandQueue( cl_command_queue command_queue )
{
TRACE( "(%p)\n", command_queue );
- return clReleaseCommandQueue( command_queue );
+ return opencl_funcs->pclReleaseCommandQueue( command_queue );
}
cl_int WINAPI wine_clReleaseContext( cl_context context )
{
TRACE( "(%p)\n", context );
- return clReleaseContext( context );
+ return opencl_funcs->pclReleaseContext( context );
}
cl_int WINAPI wine_clReleaseEvent( cl_event event )
{
TRACE( "(%p)\n", event );
- return clReleaseEvent( event );
+ return opencl_funcs->pclReleaseEvent( event );
}
cl_int WINAPI wine_clReleaseKernel( cl_kernel kernel )
{
TRACE( "(%p)\n", kernel );
- return clReleaseKernel( kernel );
+ return opencl_funcs->pclReleaseKernel( kernel );
}
cl_int WINAPI wine_clReleaseMemObject( cl_mem memobj )
{
TRACE( "(%p)\n", memobj );
- return clReleaseMemObject( memobj );
+ return opencl_funcs->pclReleaseMemObject( memobj );
}
cl_int WINAPI wine_clReleaseProgram( cl_program program )
{
TRACE( "(%p)\n", program );
- return clReleaseProgram( program );
+ return opencl_funcs->pclReleaseProgram( program );
}
cl_int WINAPI wine_clReleaseSampler( cl_sampler sampler )
{
TRACE( "(%p)\n", sampler );
- return clReleaseSampler( sampler );
+ return opencl_funcs->pclReleaseSampler( sampler );
}
cl_int WINAPI wine_clRetainCommandQueue( cl_command_queue command_queue )
{
TRACE( "(%p)\n", command_queue );
- return clRetainCommandQueue( command_queue );
+ return opencl_funcs->pclRetainCommandQueue( command_queue );
}
cl_int WINAPI wine_clRetainContext( cl_context context )
{
TRACE( "(%p)\n", context );
- return clRetainContext( context );
+ return opencl_funcs->pclRetainContext( context );
}
cl_int WINAPI wine_clRetainEvent( cl_event event )
{
TRACE( "(%p)\n", event );
- return clRetainEvent( event );
+ return opencl_funcs->pclRetainEvent( event );
}
cl_int WINAPI wine_clRetainKernel( cl_kernel kernel )
{
TRACE( "(%p)\n", kernel );
- return clRetainKernel( kernel );
+ return opencl_funcs->pclRetainKernel( kernel );
}
cl_int WINAPI wine_clRetainMemObject( cl_mem memobj )
{
TRACE( "(%p)\n", memobj );
- return clRetainMemObject( memobj );
+ return opencl_funcs->pclRetainMemObject( memobj );
}
cl_int WINAPI wine_clRetainProgram( cl_program program )
{
TRACE( "(%p)\n", program );
- return clRetainProgram( program );
+ return opencl_funcs->pclRetainProgram( program );
}
cl_int WINAPI wine_clRetainSampler( cl_sampler sampler )
{
TRACE( "(%p)\n", sampler );
- return clRetainSampler( sampler );
+ return opencl_funcs->pclRetainSampler( sampler );
}
cl_int WINAPI wine_clSetCommandQueueProperty( cl_command_queue command_queue, cl_command_queue_properties properties, cl_bool enable, cl_command_queue_properties* old_properties )
{
TRACE( "(%p, %s, %u, %p)\n", command_queue, wine_dbgstr_longlong(properties), enable, old_properties );
- return clSetCommandQueueProperty( command_queue, properties, enable, old_properties );
+ return opencl_funcs->pclSetCommandQueueProperty( command_queue, properties, enable, old_properties );
}
cl_int WINAPI wine_clSetKernelArg( cl_kernel kernel, cl_uint arg_index, size_t arg_size, const void* arg_value )
{
TRACE( "(%p, %u, %zu, %p)\n", kernel, arg_index, arg_size, arg_value );
- return clSetKernelArg( kernel, arg_index, arg_size, arg_value );
+ return opencl_funcs->pclSetKernelArg( kernel, arg_index, arg_size, arg_value );
}
cl_int WINAPI wine_clUnloadCompiler( void )
{
TRACE( "()\n" );
- return clUnloadCompiler();
+ return opencl_funcs->pclUnloadCompiler();
}
cl_int WINAPI wine_clWaitForEvents( cl_uint num_events, const cl_event* event_list )
{
TRACE( "(%u, %p)\n", num_events, event_list );
- return clWaitForEvents( num_events, event_list );
+ return opencl_funcs->pclWaitForEvents( num_events, event_list );
}
diff --git a/dlls/opencl/opencl.c b/dlls/opencl/pe_wrappers.c
similarity index 36%
rename from dlls/opencl/opencl.c
rename to dlls/opencl/pe_wrappers.c
index f678ed8cca0..c2551e785c7 100644
--- a/dlls/opencl/opencl.c
+++ b/dlls/opencl/pe_wrappers.c
@@ -23,6 +23,8 @@
WINE_DEFAULT_DEBUG_CHANNEL(opencl);
+const struct opencl_funcs *opencl_funcs = NULL;
+
cl_int WINAPI wine_clGetPlatformInfo(cl_platform_id platform, cl_platform_info param_name,
SIZE_T param_value_size, void * param_value, size_t * param_value_size_ret)
{
@@ -51,7 +53,7 @@ cl_int WINAPI wine_clGetPlatformInfo(cl_platform_id platform, cl_platform_info p
}
else
{
- ret = clGetPlatformInfo(platform, param_name, param_value_size, param_value, param_value_size_ret);
+ ret = opencl_funcs->pclGetPlatformInfo(platform, param_name, param_value_size, param_value, param_value_size_ret);
}
TRACE("(%p, 0x%x, %ld, %p, %p)=%d\n", platform, param_name, param_value_size, param_value, param_value_size_ret, ret);
@@ -87,7 +89,7 @@ cl_int WINAPI wine_clGetDeviceInfo(cl_device_id device, cl_device_info param_nam
}
else
{
- ret = clGetDeviceInfo(device, param_name, param_value_size, param_value, param_value_size_ret);
+ ret = opencl_funcs->pclGetDeviceInfo(device, param_name, param_value_size, param_value, param_value_size_ret);
}
/* Filter out the CL_EXEC_NATIVE_KERNEL flag */
@@ -102,126 +104,6 @@ cl_int WINAPI wine_clGetDeviceInfo(cl_device_id device, cl_device_info param_nam
}
-typedef struct
-{
- void WINAPI (*pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data);
- void *user_data;
-} CONTEXT_CALLBACK;
-
-static void context_fn_notify(const char *errinfo, const void *private_info, size_t cb, void *user_data)
-{
- CONTEXT_CALLBACK *ccb;
- TRACE("(%s, %p, %ld, %p)\n", errinfo, private_info, (SIZE_T)cb, user_data);
- ccb = (CONTEXT_CALLBACK *) user_data;
- if(ccb->pfn_notify) ccb->pfn_notify(errinfo, private_info, cb, ccb->user_data);
- TRACE("Callback COMPLETED\n");
-}
-
-cl_context WINAPI wine_clCreateContext(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 ret;
- CONTEXT_CALLBACK *ccb;
- TRACE("(%p, %d, %p, %p, %p, %p)\n", properties, num_devices, devices, pfn_notify, user_data, errcode_ret);
- /* FIXME: The CONTEXT_CALLBACK structure is currently leaked.
- * Pointers to callback redirectors should be remembered and free()d when the context is destroyed.
- * The problem is determining when a context is being destroyed. clReleaseContext only decrements
- * the use count for a context, its destruction can come much later and therefore there is a risk
- * that the callback could be invoked after the user_data memory has been free()d.
- */
- ccb = HeapAlloc(GetProcessHeap(), 0, sizeof(CONTEXT_CALLBACK));
- ccb->pfn_notify = pfn_notify;
- ccb->user_data = user_data;
- ret = clCreateContext(properties, num_devices, devices, context_fn_notify, ccb, errcode_ret);
- TRACE("(%p, %d, %p, %p, %p, %p (%d)))=%p\n", properties, num_devices, devices, &pfn_notify, user_data, errcode_ret, errcode_ret ? *errcode_ret : 0, ret);
- return ret;
-}
-
-
-cl_context WINAPI wine_clCreateContextFromType(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_context ret;
- CONTEXT_CALLBACK *ccb;
- TRACE("(%p, 0x%lx, %p, %p, %p)\n", properties, (long unsigned int)device_type, pfn_notify, user_data, errcode_ret);
- /* FIXME: The CONTEXT_CALLBACK structure is currently leaked.
- * Pointers to callback redirectors should be remembered and free()d when the context is destroyed.
- * The problem is determining when a context is being destroyed. clReleaseContext only decrements
- * the use count for a context, its destruction can come much later and therefore there is a risk
- * that the callback could be invoked after the user_data memory has been free()d.
- */
- ccb = HeapAlloc(GetProcessHeap(), 0, sizeof(CONTEXT_CALLBACK));
- ccb->pfn_notify = pfn_notify;
- ccb->user_data = user_data;
- ret = clCreateContextFromType(properties, device_type, context_fn_notify, ccb, errcode_ret);
- TRACE("(%p, 0x%lx, %p, %p, %p (%d)))=%p\n", properties, (long unsigned int)device_type, pfn_notify, user_data, errcode_ret, errcode_ret ? *errcode_ret : 0, ret);
- return ret;
-}
-
-typedef struct
-{
- void WINAPI (*pfn_notify)(cl_program program, void * user_data);
- void *user_data;
-} PROGRAM_CALLBACK;
-
-static void program_fn_notify(cl_program program, void * user_data)
-{
- PROGRAM_CALLBACK *pcb;
- TRACE("(%p, %p)\n", program, user_data);
- pcb = (PROGRAM_CALLBACK *) user_data;
- pcb->pfn_notify(program, pcb->user_data);
- HeapFree(GetProcessHeap(), 0, pcb);
- TRACE("Callback COMPLETED\n");
-}
-
-cl_int WINAPI wine_clBuildProgram(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 ret;
- TRACE("\n");
- if(pfn_notify)
- {
- /* When pfn_notify is provided, clBuildProgram is asynchronous */
- PROGRAM_CALLBACK *pcb;
- pcb = HeapAlloc(GetProcessHeap(), 0, sizeof(PROGRAM_CALLBACK));
- pcb->pfn_notify = pfn_notify;
- pcb->user_data = user_data;
- ret = clBuildProgram(program, num_devices, device_list, options, program_fn_notify, pcb);
- }
- else
- {
- /* When pfn_notify is NULL, clBuildProgram is synchronous */
- ret = clBuildProgram(program, num_devices, device_list, options, NULL, user_data);
- }
- return ret;
-}
-
-
-cl_int WINAPI wine_clEnqueueNativeKernel(cl_command_queue command_queue,
- void WINAPI (*user_func)(void *args),
- 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 ret = CL_INVALID_OPERATION;
- /* FIXME: There appears to be no obvious method for translating the ABI for user_func.
- * There is no opaque user_data structure passed, that could encapsulate the return address.
- * The OpenCL specification seems to indicate that args has an implementation specific
- * structure that cannot be used to stash away a return address for the WINAPI user_func.
- */
-#if 0
- ret = clEnqueueNativeKernel(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc,
- num_events_in_wait_list, event_wait_list, event);
-#else
- FIXME("not supported due to user_func ABI mismatch\n");
-#endif
- return ret;
-}
-
-
void * WINAPI wine_clGetExtensionFunctionAddress(const char * func_name)
{
void * ret = 0;
@@ -234,3 +116,13 @@ void * WINAPI wine_clGetExtensionFunctionAddress(const char * func_name)
TRACE("(%s)=%p\n",func_name, ret);
return ret;
}
+
+BOOL WINAPI DllMain( HINSTANCE instance, DWORD reason, void *reserved )
+{
+ if (reason == DLL_PROCESS_ATTACH)
+ {
+ if (__wine_init_unix_lib( instance, reason, NULL, &opencl_funcs ))
+ ERR( "failed to initialize unix library\n" );
+ }
+ return TRUE;
+}
diff --git a/dlls/opencl/unix_private.h b/dlls/opencl/unix_private.h
new file mode 100644
index 00000000000..2259a87827c
--- /dev/null
+++ b/dlls/opencl/unix_private.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2021 Zebediah Figura
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef __WINE_UNIX_PRIVATE_H
+#define __WINE_UNIX_PRIVATE_H
+
+#include "opencl_private.h"
+
+cl_int WINAPI wrap_clBuildProgram( 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 ) DECLSPEC_HIDDEN;
+
+cl_context WINAPI wrap_clCreateContext( 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 ) DECLSPEC_HIDDEN;
+
+cl_context WINAPI wrap_clCreateContextFromType( 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 ) DECLSPEC_HIDDEN;
+
+cl_int WINAPI wrap_clEnqueueNativeKernel( 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 ) DECLSPEC_HIDDEN;
+
+extern const struct opencl_funcs funcs;
+
+#endif
diff --git a/dlls/opencl/unix_thunks.c b/dlls/opencl/unix_thunks.c
new file mode 100644
index 00000000000..084131468d6
--- /dev/null
+++ b/dlls/opencl/unix_thunks.c
@@ -0,0 +1,388 @@
+/* Automatically generated from OpenCL registry files; DO NOT EDIT! */
+
+#if 0
+#pragma makedep unix
+#endif
+
+#include "config.h"
+#include "unix_private.h"
+
+static cl_mem WINAPI wrap_clCreateBuffer( cl_context context, cl_mem_flags flags, size_t size, void* host_ptr, cl_int* errcode_ret )
+{
+ return clCreateBuffer( context, flags, size, host_ptr, errcode_ret );
+}
+
+static cl_command_queue WINAPI wrap_clCreateCommandQueue( cl_context context, cl_device_id device, cl_command_queue_properties properties, cl_int* errcode_ret )
+{
+ return clCreateCommandQueue( context, device, properties, 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 );
+}
+
+static cl_mem WINAPI wrap_clCreateImage3D( 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 )
+{
+ return clCreateImage3D( context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret );
+}
+
+static cl_kernel WINAPI wrap_clCreateKernel( cl_program program, const char* kernel_name, cl_int* errcode_ret )
+{
+ return clCreateKernel( program, kernel_name, errcode_ret );
+}
+
+static cl_int WINAPI wrap_clCreateKernelsInProgram( cl_program program, cl_uint num_kernels, cl_kernel* kernels, cl_uint* num_kernels_ret )
+{
+ return clCreateKernelsInProgram( program, num_kernels, kernels, num_kernels_ret );
+}
+
+static cl_program WINAPI wrap_clCreateProgramWithBinary( 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 )
+{
+ return clCreateProgramWithBinary( context, num_devices, device_list, lengths, binaries, binary_status, 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 );
+}
+
+static cl_sampler WINAPI wrap_clCreateSampler( cl_context context, cl_bool normalized_coords, cl_addressing_mode addressing_mode, cl_filter_mode filter_mode, cl_int* errcode_ret )
+{
+ return clCreateSampler( context, normalized_coords, addressing_mode, filter_mode, errcode_ret );
+}
+
+static cl_int WINAPI wrap_clEnqueueBarrier( cl_command_queue command_queue )
+{
+ return clEnqueueBarrier( command_queue );
+}
+
+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 );
+}
+
+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 );
+}
+
+static cl_int WINAPI wrap_clEnqueueCopyImage( 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 )
+{
+ return clEnqueueCopyImage( command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
+}
+
+static cl_int WINAPI wrap_clEnqueueCopyImageToBuffer( 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 )
+{
+ return clEnqueueCopyImageToBuffer( command_queue, src_image, dst_buffer, src_origin, region, dst_offset, 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 );
+}
+
+static void* WINAPI wrap_clEnqueueMapImage( 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 )
+{
+ return clEnqueueMapImage( command_queue, image, blocking_map, map_flags, origin, region, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, event, errcode_ret );
+}
+
+static cl_int WINAPI wrap_clEnqueueMarker( cl_command_queue command_queue, cl_event* event )
+{
+ return clEnqueueMarker( command_queue, 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 );
+}
+
+static cl_int WINAPI wrap_clEnqueueReadBuffer( 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 )
+{
+ return clEnqueueReadBuffer( command_queue, buffer, blocking_read, offset, size, 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 );
+}
+
+static cl_int WINAPI wrap_clEnqueueTask( cl_command_queue command_queue, cl_kernel kernel, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
+{
+ return clEnqueueTask( command_queue, kernel, num_events_in_wait_list, event_wait_list, event );
+}
+
+static cl_int WINAPI wrap_clEnqueueUnmapMemObject( 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 )
+{
+ return clEnqueueUnmapMemObject( command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event );
+}
+
+static cl_int WINAPI wrap_clEnqueueWaitForEvents( cl_command_queue command_queue, cl_uint num_events, const cl_event* event_list )
+{
+ return clEnqueueWaitForEvents( command_queue, num_events, event_list );
+}
+
+static cl_int WINAPI wrap_clEnqueueWriteBuffer( 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 )
+{
+ return clEnqueueWriteBuffer( command_queue, buffer, blocking_write, offset, size, 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 );
+}
+
+static cl_int WINAPI wrap_clFinish( cl_command_queue command_queue )
+{
+ return clFinish( command_queue );
+}
+
+static cl_int WINAPI wrap_clFlush( cl_command_queue command_queue )
+{
+ return clFlush( command_queue );
+}
+
+static cl_int WINAPI wrap_clGetCommandQueueInfo( cl_command_queue command_queue, cl_command_queue_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
+{
+ return clGetCommandQueueInfo( command_queue, param_name, param_value_size, param_value, param_value_size_ret );
+}
+
+static cl_int WINAPI wrap_clGetContextInfo( cl_context context, cl_context_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
+{
+ return clGetContextInfo( context, param_name, param_value_size, param_value, param_value_size_ret );
+}
+
+static cl_int WINAPI wrap_clGetDeviceIDs( cl_platform_id platform, cl_device_type device_type, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices )
+{
+ return clGetDeviceIDs( platform, device_type, num_entries, devices, num_devices );
+}
+
+static cl_int WINAPI wrap_clGetDeviceInfo( cl_device_id device, cl_device_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
+{
+ return clGetDeviceInfo( device, param_name, param_value_size, param_value, param_value_size_ret );
+}
+
+static cl_int WINAPI wrap_clGetEventInfo( cl_event event, cl_event_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
+{
+ return clGetEventInfo( event, param_name, param_value_size, param_value, param_value_size_ret );
+}
+
+static cl_int WINAPI wrap_clGetEventProfilingInfo( cl_event event, cl_profiling_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
+{
+ return clGetEventProfilingInfo( event, param_name, param_value_size, param_value, param_value_size_ret );
+}
+
+static void* WINAPI wrap_clGetExtensionFunctionAddress( const char* func_name )
+{
+ return clGetExtensionFunctionAddress( func_name );
+}
+
+static cl_int WINAPI wrap_clGetImageInfo( cl_mem image, cl_image_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
+{
+ return clGetImageInfo( image, 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 );
+}
+
+static cl_int WINAPI wrap_clGetKernelWorkGroupInfo( 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 )
+{
+ return clGetKernelWorkGroupInfo( kernel, device, param_name, param_value_size, param_value, param_value_size_ret );
+}
+
+static cl_int WINAPI wrap_clGetMemObjectInfo( cl_mem memobj, cl_mem_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
+{
+ return clGetMemObjectInfo( memobj, param_name, param_value_size, param_value, param_value_size_ret );
+}
+
+static cl_int WINAPI wrap_clGetPlatformIDs( cl_uint num_entries, cl_platform_id* platforms, cl_uint* num_platforms )
+{
+ return clGetPlatformIDs( num_entries, platforms, num_platforms );
+}
+
+static cl_int WINAPI wrap_clGetPlatformInfo( cl_platform_id platform, cl_platform_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
+{
+ return clGetPlatformInfo( platform, param_name, param_value_size, param_value, param_value_size_ret );
+}
+
+static cl_int WINAPI wrap_clGetProgramBuildInfo( cl_program program, cl_device_id device, cl_program_build_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
+{
+ return clGetProgramBuildInfo( program, device, param_name, param_value_size, param_value, param_value_size_ret );
+}
+
+static cl_int WINAPI wrap_clGetProgramInfo( cl_program program, cl_program_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
+{
+ return clGetProgramInfo( program, param_name, param_value_size, param_value, param_value_size_ret );
+}
+
+static cl_int WINAPI wrap_clGetSamplerInfo( cl_sampler sampler, cl_sampler_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
+{
+ return clGetSamplerInfo( sampler, param_name, param_value_size, param_value, param_value_size_ret );
+}
+
+static cl_int WINAPI wrap_clGetSupportedImageFormats( 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 )
+{
+ return clGetSupportedImageFormats( context, flags, image_type, num_entries, image_formats, num_image_formats );
+}
+
+static cl_int WINAPI wrap_clReleaseCommandQueue( cl_command_queue command_queue )
+{
+ return clReleaseCommandQueue( command_queue );
+}
+
+static cl_int WINAPI wrap_clReleaseContext( cl_context context )
+{
+ return clReleaseContext( context );
+}
+
+static cl_int WINAPI wrap_clReleaseEvent( cl_event event )
+{
+ return clReleaseEvent( event );
+}
+
+static cl_int WINAPI wrap_clReleaseKernel( cl_kernel kernel )
+{
+ return clReleaseKernel( kernel );
+}
+
+static cl_int WINAPI wrap_clReleaseMemObject( cl_mem memobj )
+{
+ return clReleaseMemObject( memobj );
+}
+
+static cl_int WINAPI wrap_clReleaseProgram( cl_program program )
+{
+ return clReleaseProgram( program );
+}
+
+static cl_int WINAPI wrap_clReleaseSampler( cl_sampler sampler )
+{
+ return clReleaseSampler( sampler );
+}
+
+static cl_int WINAPI wrap_clRetainCommandQueue( cl_command_queue command_queue )
+{
+ return clRetainCommandQueue( command_queue );
+}
+
+static cl_int WINAPI wrap_clRetainContext( cl_context context )
+{
+ return clRetainContext( context );
+}
+
+static cl_int WINAPI wrap_clRetainEvent( cl_event event )
+{
+ return clRetainEvent( event );
+}
+
+static cl_int WINAPI wrap_clRetainKernel( cl_kernel kernel )
+{
+ return clRetainKernel( kernel );
+}
+
+static cl_int WINAPI wrap_clRetainMemObject( cl_mem memobj )
+{
+ return clRetainMemObject( memobj );
+}
+
+static cl_int WINAPI wrap_clRetainProgram( cl_program program )
+{
+ return clRetainProgram( program );
+}
+
+static cl_int WINAPI wrap_clRetainSampler( cl_sampler sampler )
+{
+ return clRetainSampler( sampler );
+}
+
+static cl_int WINAPI wrap_clSetCommandQueueProperty( cl_command_queue command_queue, cl_command_queue_properties properties, cl_bool enable, cl_command_queue_properties* old_properties )
+{
+ return clSetCommandQueueProperty( command_queue, properties, enable, old_properties );
+}
+
+static cl_int WINAPI wrap_clSetKernelArg( cl_kernel kernel, cl_uint arg_index, size_t arg_size, const void* arg_value )
+{
+ return clSetKernelArg( kernel, arg_index, arg_size, arg_value );
+}
+
+static cl_int WINAPI wrap_clUnloadCompiler( void )
+{
+ return clUnloadCompiler();
+}
+
+static cl_int WINAPI wrap_clWaitForEvents( cl_uint num_events, const cl_event* event_list )
+{
+ return clWaitForEvents( num_events, event_list );
+}
+
+const struct opencl_funcs funcs =
+{
+ wrap_clBuildProgram,
+ wrap_clCreateBuffer,
+ wrap_clCreateCommandQueue,
+ wrap_clCreateContext,
+ wrap_clCreateContextFromType,
+ wrap_clCreateImage2D,
+ wrap_clCreateImage3D,
+ wrap_clCreateKernel,
+ wrap_clCreateKernelsInProgram,
+ wrap_clCreateProgramWithBinary,
+ wrap_clCreateProgramWithSource,
+ wrap_clCreateSampler,
+ wrap_clEnqueueBarrier,
+ wrap_clEnqueueCopyBuffer,
+ wrap_clEnqueueCopyBufferToImage,
+ wrap_clEnqueueCopyImage,
+ wrap_clEnqueueCopyImageToBuffer,
+ wrap_clEnqueueMapBuffer,
+ wrap_clEnqueueMapImage,
+ wrap_clEnqueueMarker,
+ wrap_clEnqueueNDRangeKernel,
+ wrap_clEnqueueNativeKernel,
+ wrap_clEnqueueReadBuffer,
+ wrap_clEnqueueReadImage,
+ wrap_clEnqueueTask,
+ wrap_clEnqueueUnmapMemObject,
+ wrap_clEnqueueWaitForEvents,
+ wrap_clEnqueueWriteBuffer,
+ wrap_clEnqueueWriteImage,
+ wrap_clFinish,
+ wrap_clFlush,
+ wrap_clGetCommandQueueInfo,
+ wrap_clGetContextInfo,
+ wrap_clGetDeviceIDs,
+ wrap_clGetDeviceInfo,
+ wrap_clGetEventInfo,
+ wrap_clGetEventProfilingInfo,
+ wrap_clGetExtensionFunctionAddress,
+ wrap_clGetImageInfo,
+ wrap_clGetKernelInfo,
+ wrap_clGetKernelWorkGroupInfo,
+ wrap_clGetMemObjectInfo,
+ wrap_clGetPlatformIDs,
+ wrap_clGetPlatformInfo,
+ wrap_clGetProgramBuildInfo,
+ wrap_clGetProgramInfo,
+ wrap_clGetSamplerInfo,
+ wrap_clGetSupportedImageFormats,
+ wrap_clReleaseCommandQueue,
+ wrap_clReleaseContext,
+ wrap_clReleaseEvent,
+ wrap_clReleaseKernel,
+ wrap_clReleaseMemObject,
+ wrap_clReleaseProgram,
+ wrap_clReleaseSampler,
+ wrap_clRetainCommandQueue,
+ wrap_clRetainContext,
+ wrap_clRetainEvent,
+ wrap_clRetainKernel,
+ wrap_clRetainMemObject,
+ wrap_clRetainProgram,
+ wrap_clRetainSampler,
+ wrap_clSetCommandQueueProperty,
+ wrap_clSetKernelArg,
+ wrap_clUnloadCompiler,
+ wrap_clWaitForEvents,
+};
diff --git a/dlls/opencl/unix_wrappers.c b/dlls/opencl/unix_wrappers.c
new file mode 100644
index 00000000000..248fe80541c
--- /dev/null
+++ b/dlls/opencl/unix_wrappers.c
@@ -0,0 +1,146 @@
+/*
+ * Copyright 2021 Zebediah Figura
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#if 0
+#pragma makedep unix
+#endif
+
+#include "config.h"
+#include <stdlib.h>
+#include "unix_private.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(opencl);
+
+struct program_callback
+{
+ void (WINAPI *pfn_notify)(cl_program program, void *user_data);
+ void *user_data;
+};
+
+static void CL_CALLBACK program_callback_wrapper(cl_program program, void *user_data)
+{
+ struct program_callback *callback = user_data;
+ TRACE("(%p, %p)\n", program, user_data);
+ callback->pfn_notify(program, callback->user_data);
+ free(callback);
+}
+
+cl_int WINAPI wrap_clBuildProgram( 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 )
+{
+ if (pfn_notify)
+ {
+ struct program_callback *callback;
+ cl_int ret;
+
+ if (!(callback = malloc(sizeof(*callback))))
+ return CL_OUT_OF_HOST_MEMORY;
+ callback->pfn_notify = pfn_notify;
+ callback->user_data = user_data;
+ if ((ret = clBuildProgram( program, num_devices, device_list, options,
+ program_callback_wrapper, callback )) != CL_SUCCESS)
+ free( callback );
+ return ret;
+ }
+
+ return clBuildProgram( program, num_devices, device_list, options, NULL, NULL );
+}
+
+struct context_callback
+{
+ void (WINAPI *pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data);
+ void *user_data;
+};
+
+static void CL_CALLBACK context_callback_wrapper(const char *errinfo,
+ const void *private_info, size_t cb, void *user_data)
+{
+ struct context_callback *callback = user_data;
+ TRACE("(%s, %p, %zu, %p)\n", debugstr_a(errinfo), private_info, cb, user_data);
+ callback->pfn_notify(errinfo, private_info, cb, callback->user_data);
+}
+
+cl_context WINAPI wrap_clCreateContext( 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 )
+{
+ if (pfn_notify)
+ {
+ struct context_callback *callback;
+ cl_context ret;
+
+ /* FIXME: the callback structure is currently leaked */
+ if (!(callback = malloc(sizeof(*callback))))
+ {
+ *errcode_ret = CL_OUT_OF_HOST_MEMORY;
+ return NULL;
+ }
+ callback->pfn_notify = pfn_notify;
+ callback->user_data = user_data;
+ if (!(ret = clCreateContext( properties, num_devices, devices, context_callback_wrapper, callback, errcode_ret )))
+ free( callback );
+ return ret;
+ }
+
+ return clCreateContext( properties, num_devices, devices, NULL, NULL, errcode_ret );
+}
+
+cl_context WINAPI wrap_clCreateContextFromType( 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 )
+{
+ if (pfn_notify)
+ {
+ struct context_callback *callback;
+ cl_context ret;
+
+ /* FIXME: the callback structure is currently leaked */
+ if (!(callback = malloc(sizeof(*callback))))
+ {
+ *errcode_ret = CL_OUT_OF_HOST_MEMORY;
+ return NULL;
+ }
+ callback->pfn_notify = pfn_notify;
+ callback->user_data = user_data;
+ if (!(ret = clCreateContextFromType( properties, device_type, context_callback_wrapper, callback, errcode_ret )))
+ free( callback );
+ return ret;
+ }
+
+ return clCreateContextFromType( properties, device_type, NULL, NULL, errcode_ret );
+}
+
+cl_int WINAPI wrap_clEnqueueNativeKernel( 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 )
+{
+ /* we have no clear way to wrap user_func */
+ FIXME( "not 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;
+ *(const struct opencl_funcs **)ptr_out = &funcs;
+ return STATUS_SUCCESS;
+}
diff --git a/dlls/opencl/unixlib.h b/dlls/opencl/unixlib.h
new file mode 100644
index 00000000000..b6e53c30330
--- /dev/null
+++ b/dlls/opencl/unixlib.h
@@ -0,0 +1,73 @@
+/* Automatically generated from OpenCL registry files; DO NOT EDIT! */
+
+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_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 *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 *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_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 *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 );
+ 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 *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 *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 *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 );
+ cl_int (WINAPI *pclGetCommandQueueInfo)( cl_command_queue command_queue, cl_command_queue_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
+ cl_int (WINAPI *pclGetContextInfo)( cl_context context, cl_context_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
+ cl_int (WINAPI *pclGetDeviceIDs)( cl_platform_id platform, cl_device_type device_type, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices );
+ cl_int (WINAPI *pclGetDeviceInfo)( 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 *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 );
+ void* (WINAPI *pclGetExtensionFunctionAddress)( const char* func_name );
+ 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 *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 );
+ cl_int (WINAPI *pclGetPlatformIDs)( cl_uint num_entries, cl_platform_id* platforms, cl_uint* num_platforms );
+ cl_int (WINAPI *pclGetPlatformInfo)( cl_platform_id platform, cl_platform_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
+ cl_int (WINAPI *pclGetProgramBuildInfo)( cl_program program, cl_device_id device, cl_program_build_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret );
+ cl_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_int (WINAPI *pclReleaseCommandQueue)( cl_command_queue command_queue );
+ cl_int (WINAPI *pclReleaseContext)( cl_context context );
+ cl_int (WINAPI *pclReleaseEvent)( cl_event event );
+ cl_int (WINAPI *pclReleaseKernel)( cl_kernel kernel );
+ cl_int (WINAPI *pclReleaseMemObject)( cl_mem memobj );
+ cl_int (WINAPI *pclReleaseProgram)( cl_program program );
+ 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 *pclRetainEvent)( cl_event event );
+ cl_int (WINAPI *pclRetainKernel)( cl_kernel kernel );
+ cl_int (WINAPI *pclRetainMemObject)( cl_mem memobj );
+ cl_int (WINAPI *pclRetainProgram)( cl_program program );
+ cl_int (WINAPI *pclRetainSampler)( cl_sampler sampler );
+ cl_int (WINAPI *pclSetCommandQueueProperty)( cl_command_queue command_queue, cl_command_queue_properties properties, cl_bool enable, cl_command_queue_properties* old_properties );
+ cl_int (WINAPI *pclSetKernelArg)( cl_kernel kernel, cl_uint arg_index, size_t arg_size, const void* arg_value );
+ cl_int (WINAPI *pclUnloadCompiler)( void );
+ cl_int (WINAPI *pclWaitForEvents)( cl_uint num_events, const cl_event* event_list );
+};
+
+extern const struct opencl_funcs *opencl_funcs;
--
2.20.1
More information about the wine-devel
mailing list