Signed-off-by: Zebediah Figura z.figura12@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;