[PATCH 1/3] opencl: Move libOpenCL support to a new Unix library.
Signed-off-by: Zebediah Figura <z.figura12(a)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
Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/opencl/Makefile.in | 2 + dlls/opencl/make_opencl | 92 ++++++++-- dlls/opencl/opencl_private.h | 15 +- dlls/opencl/opencl_types.h | 343 +++++++++++++++++++++++++++++++++++ dlls/opencl/pe_thunks.c | 51 +++--- dlls/opencl/pe_wrappers.c | 3 +- dlls/opencl/unix_private.h | 14 ++ 7 files changed, 468 insertions(+), 52 deletions(-) create mode 100644 dlls/opencl/opencl_types.h diff --git a/dlls/opencl/Makefile.in b/dlls/opencl/Makefile.in index 8a6a03175cb..6b2471b914d 100644 --- a/dlls/opencl/Makefile.in +++ b/dlls/opencl/Makefile.in @@ -1,6 +1,8 @@ MODULE = opencl.dll EXTRALIBS = $(OPENCL_LIBS) +EXTRADLLFLAGS = -mno-cygwin + C_SRCS = \ pe_thunks.c \ pe_wrappers.c \ diff --git a/dlls/opencl/make_opencl b/dlls/opencl/make_opencl index fc5d4ad4bf6..6f901d570f0 100755 --- a/dlls/opencl/make_opencl +++ b/dlls/opencl/make_opencl @@ -21,6 +21,7 @@ use XML::LibXML; # Files to generate my $spec_file = "opencl.spec"; my $pe_file = "pe_thunks.c"; +my $types_file = "opencl_types.h"; my $unix_file = "unix_thunks.c"; my $unixheader_file = "unixlib.h"; @@ -42,8 +43,8 @@ my %arg_types = "int16_t" => [ "long", "%d" ], "int32_t" => [ "long", "%d" ], "int64_t" => [ "int64", "wine_dbgstr_longlong(%s)" ], - "intptr_t" => [ "long", "%ld" ], - "size_t" => [ "long", "%zu" ], + "intptr_t" => [ "long", "%Id" ], + "size_t" => [ "long", "%Iu" ], "uint8_t" => [ "long", "%u" ], "uint16_t" => [ "long", "%u" ], "uint32_t" => [ "long", "%u" ], @@ -237,12 +238,27 @@ sub needs_unix_wrapper($) return defined $funcs{$name}; } +sub generate_struct($) +{ + my $type = shift; + my $name = $type->{name}; + my $ret = "typedef struct _$name\n{\n"; + foreach my $member ($type->findnodes("./member")) + { + ($member = $member->textContent()) =~ s/ +/ /g; + $ret .= " $member;\n"; + } + $ret .= "} $name;\n"; + return $ret; +} + sub parse_file($) { my $file = shift; my $xml = XML::LibXML->load_xml( location => $file ); my %functions; my %enums; + my %types; # save all functions foreach my $command ($xml->findnodes("/registry/commands/command")) @@ -257,20 +273,25 @@ sub parse_file($) # save all enums foreach my $enum ($xml->findnodes("/registry/enums/enum")) { - $enums{$enum->{name}} = $enum->{value}; + if (defined $enum->{value}) + { + $enums{$enum->{name}} = $enum->{value}; + } + else + { + $enums{$enum->{name}} = "(1 << " . $enum->{bitpos} . ")"; + } } # save all types foreach my $type ($xml->findnodes("/registry/types/type")) { - my $name = @{$type->findnodes("./name")}[0]; - next unless $name; - $name = $name->textContent; - push @cl_types, $name unless $cl_types{$name}; - $cl_types{$name} = $type; - - if ($type->{category} eq "define" and not defined($arg_types{$name})) + if ($type->{category} eq "define") { + my $name = @{$type->findnodes("./name")}[0]; + $name = $name->textContent; + $types{$name} = $type; + my $basetype = @{$type->findnodes("./type")}[0]; if ($type->textContent() =~ /[[*]/) { @@ -285,6 +306,11 @@ sub parse_file($) die "No conversion for type $name\n" } } + elsif ($type->{category} eq "struct") + { + my $name = $type->{name}; + $types{$name} = $type; + } } # generate core functions @@ -299,6 +325,12 @@ sub parse_file($) { $cl_enums{$enum->{name}} = $enums{$enum->{name}}; } + foreach my $type ($feature->findnodes("./require/type")) + { + next unless $types{$type->{name}}; + push @cl_types, $type->{name} unless $cl_types{$type->{name}}; + $cl_types{$type->{name}} = $types{$type->{name}}; + } } } @@ -319,8 +351,9 @@ 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 "#include \"opencl_private.h\"\n"; +print PE "#include \"opencl_types.h\"\n"; +print PE "#include \"unixlib.h\"\n\n"; print PE "WINE_DEFAULT_DEBUG_CHANNEL(opencl);\n" if $gen_traces; @@ -377,3 +410,38 @@ print UNIXHEADER "};\n\n"; print UNIXHEADER "extern const struct opencl_funcs *opencl_funcs;\n"; close(UNIXHEADER); + +# generate the Win32 type definitions +open(TYPES, ">$types_file") or die "cannot create $types_file"; + +print TYPES <<END +/* Automatically generated from OpenCL registry files; DO NOT EDIT! */ + +typedef int32_t cl_int DECLSPEC_ALIGN(4); +typedef uint32_t cl_uint DECLSPEC_ALIGN(4); +typedef uint64_t cl_ulong DECLSPEC_ALIGN(8); + +END +; + +foreach (@cl_types) +{ + my $type = $cl_types{$_}; + if ($type->{category} eq "define") + { + print TYPES $type->textContent() . "\n"; + } + elsif ($type->{category} eq "struct") + { + print TYPES generate_struct( $type ); + } +} + +print TYPES "\n"; + +foreach (sort keys %cl_enums) +{ + printf TYPES "#define %s %s\n", $_, $cl_enums{$_}; +} + +close(TYPES); diff --git a/dlls/opencl/opencl_private.h b/dlls/opencl/opencl_private.h index ff34dad94db..d88f6b2b8b6 100644 --- a/dlls/opencl/opencl_private.h +++ b/dlls/opencl/opencl_private.h @@ -20,6 +20,7 @@ #define __WINE_OPENCL_PRIVATE_H #include <stdarg.h> +#include <stdint.h> #include "ntstatus.h" #define WIN32_NO_STATUS @@ -29,18 +30,4 @@ #include "wine/debug.h" -#define CL_SILENCE_DEPRECATION -#if defined(HAVE_CL_CL_H) -#define CL_USE_DEPRECATED_OPENCL_1_0_APIS -#define CL_USE_DEPRECATED_OPENCL_1_1_APIS -#define CL_USE_DEPRECATED_OPENCL_1_2_APIS -#define CL_USE_DEPRECATED_OPENCL_2_0_APIS -#define CL_TARGET_OPENCL_VERSION 220 -#include <CL/cl.h> -#elif defined(HAVE_OPENCL_OPENCL_H) -#include <OpenCL/opencl.h> -#endif - -#include "unixlib.h" - #endif diff --git a/dlls/opencl/opencl_types.h b/dlls/opencl/opencl_types.h new file mode 100644 index 00000000000..eb5530d0a8d --- /dev/null +++ b/dlls/opencl/opencl_types.h @@ -0,0 +1,343 @@ +/* Automatically generated from OpenCL registry files; DO NOT EDIT! */ + +typedef int32_t cl_int DECLSPEC_ALIGN(4); +typedef uint32_t cl_uint DECLSPEC_ALIGN(4); +typedef uint64_t cl_ulong DECLSPEC_ALIGN(8); + +typedef struct _cl_platform_id * cl_platform_id; +typedef struct _cl_device_id * cl_device_id; +typedef struct _cl_context * cl_context; +typedef struct _cl_command_queue * cl_command_queue; +typedef struct _cl_mem * cl_mem; +typedef struct _cl_program * cl_program; +typedef struct _cl_kernel * cl_kernel; +typedef struct _cl_event * cl_event; +typedef struct _cl_sampler * cl_sampler; +typedef cl_uint cl_bool; +typedef cl_ulong cl_bitfield; +typedef cl_bitfield cl_device_type; +typedef cl_uint cl_platform_info; +typedef cl_uint cl_device_info; +typedef cl_bitfield cl_device_fp_config; +typedef cl_uint cl_device_mem_cache_type; +typedef cl_uint cl_device_local_mem_type; +typedef cl_bitfield cl_device_exec_capabilities; +typedef cl_bitfield cl_command_queue_properties; +typedef intptr_t cl_context_properties; +typedef cl_uint cl_context_info; +typedef cl_uint cl_command_queue_info; +typedef cl_uint cl_channel_order; +typedef cl_uint cl_channel_type; +typedef cl_bitfield cl_mem_flags; +typedef cl_uint cl_mem_object_type; +typedef cl_uint cl_mem_info; +typedef cl_uint cl_image_info; +typedef cl_uint cl_addressing_mode; +typedef cl_uint cl_filter_mode; +typedef cl_uint cl_sampler_info; +typedef cl_bitfield cl_map_flags; +typedef cl_uint cl_program_info; +typedef cl_uint cl_program_build_info; +typedef cl_int cl_build_status; +typedef cl_uint cl_kernel_info; +typedef cl_uint cl_kernel_work_group_info; +typedef cl_uint cl_event_info; +typedef cl_uint cl_command_type; +typedef cl_uint cl_profiling_info; +typedef struct _cl_image_format +{ + cl_channel_order image_channel_order; + cl_channel_type image_channel_data_type; +} cl_image_format; +typedef struct _cl_buffer_region +{ + size_t origin; + size_t size; +} cl_buffer_region; + +#define CL_A 0x10B1 +#define CL_ADDRESS_CLAMP 0x1132 +#define CL_ADDRESS_CLAMP_TO_EDGE 0x1131 +#define CL_ADDRESS_NONE 0x1130 +#define CL_ADDRESS_REPEAT 0x1133 +#define CL_ARGB 0x10B7 +#define CL_BGRA 0x10B6 +#define CL_BUILD_ERROR -2 +#define CL_BUILD_IN_PROGRESS -3 +#define CL_BUILD_NONE -1 +#define CL_BUILD_PROGRAM_FAILURE -11 +#define CL_BUILD_SUCCESS 0 +#define CL_CHAR_BIT 8 +#define CL_CHAR_MAX CL_SCHAR_MAX +#define CL_CHAR_MIN CL_SCHAR_MIN +#define CL_COMMAND_ACQUIRE_GL_OBJECTS 0x11FF +#define CL_COMMAND_COPY_BUFFER 0x11F5 +#define CL_COMMAND_COPY_BUFFER_TO_IMAGE 0x11FA +#define CL_COMMAND_COPY_IMAGE 0x11F8 +#define CL_COMMAND_COPY_IMAGE_TO_BUFFER 0x11F9 +#define CL_COMMAND_MAP_BUFFER 0x11FB +#define CL_COMMAND_MAP_IMAGE 0x11FC +#define CL_COMMAND_MARKER 0x11FE +#define CL_COMMAND_NATIVE_KERNEL 0x11F2 +#define CL_COMMAND_NDRANGE_KERNEL 0x11F0 +#define CL_COMMAND_READ_BUFFER 0x11F3 +#define CL_COMMAND_READ_IMAGE 0x11F6 +#define CL_COMMAND_RELEASE_GL_OBJECTS 0x1200 +#define CL_COMMAND_TASK 0x11F1 +#define CL_COMMAND_UNMAP_MEM_OBJECT 0x11FD +#define CL_COMMAND_WRITE_BUFFER 0x11F4 +#define CL_COMMAND_WRITE_IMAGE 0x11F7 +#define CL_COMPILER_NOT_AVAILABLE -3 +#define CL_COMPLETE 0x0 +#define CL_CONTEXT_DEVICES 0x1081 +#define CL_CONTEXT_PLATFORM 0x1084 +#define CL_CONTEXT_PROPERTIES 0x1082 +#define CL_CONTEXT_REFERENCE_COUNT 0x1080 +#define CL_DBL_DIG 15 +#define CL_DBL_EPSILON 2.220446049250313080847e-16 +#define CL_DBL_MANT_DIG 53 +#define CL_DBL_MAX 1.7976931348623158e+308 +#define CL_DBL_MAX_10_EXP +308 +#define CL_DBL_MAX_EXP +1024 +#define CL_DBL_MIN 2.225073858507201383090e-308 +#define CL_DBL_MIN_10_EXP -307 +#define CL_DBL_MIN_EXP -1021 +#define CL_DBL_RADIX 2 +#define CL_DEVICE_ADDRESS_BITS 0x100D +#define CL_DEVICE_AVAILABLE 0x1027 +#define CL_DEVICE_COMPILER_AVAILABLE 0x1028 +#define CL_DEVICE_ENDIAN_LITTLE 0x1026 +#define CL_DEVICE_ERROR_CORRECTION_SUPPORT 0x1024 +#define CL_DEVICE_EXECUTION_CAPABILITIES 0x1029 +#define CL_DEVICE_EXTENSIONS 0x1030 +#define CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE 0x101D +#define CL_DEVICE_GLOBAL_MEM_CACHE_SIZE 0x101E +#define CL_DEVICE_GLOBAL_MEM_CACHE_TYPE 0x101C +#define CL_DEVICE_GLOBAL_MEM_SIZE 0x101F +#define CL_DEVICE_IMAGE2D_MAX_HEIGHT 0x1012 +#define CL_DEVICE_IMAGE2D_MAX_WIDTH 0x1011 +#define CL_DEVICE_IMAGE3D_MAX_DEPTH 0x1015 +#define CL_DEVICE_IMAGE3D_MAX_HEIGHT 0x1014 +#define CL_DEVICE_IMAGE3D_MAX_WIDTH 0x1013 +#define CL_DEVICE_IMAGE_SUPPORT 0x1016 +#define CL_DEVICE_LOCAL_MEM_SIZE 0x1023 +#define CL_DEVICE_LOCAL_MEM_TYPE 0x1022 +#define CL_DEVICE_MAX_CLOCK_FREQUENCY 0x100C +#define CL_DEVICE_MAX_COMPUTE_UNITS 0x1002 +#define CL_DEVICE_MAX_CONSTANT_ARGS 0x1021 +#define CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE 0x1020 +#define CL_DEVICE_MAX_MEM_ALLOC_SIZE 0x1010 +#define CL_DEVICE_MAX_PARAMETER_SIZE 0x1017 +#define CL_DEVICE_MAX_READ_IMAGE_ARGS 0x100E +#define CL_DEVICE_MAX_SAMPLERS 0x1018 +#define CL_DEVICE_MAX_WORK_GROUP_SIZE 0x1004 +#define CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS 0x1003 +#define CL_DEVICE_MAX_WORK_ITEM_SIZES 0x1005 +#define CL_DEVICE_MAX_WRITE_IMAGE_ARGS 0x100F +#define CL_DEVICE_MEM_BASE_ADDR_ALIGN 0x1019 +#define CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE 0x101A +#define CL_DEVICE_NAME 0x102B +#define CL_DEVICE_NOT_AVAILABLE -2 +#define CL_DEVICE_NOT_FOUND -1 +#define CL_DEVICE_PLATFORM 0x1031 +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR 0x1006 +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE 0x100B +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT 0x100A +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT 0x1008 +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG 0x1009 +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT 0x1007 +#define CL_DEVICE_PROFILE 0x102E +#define CL_DEVICE_PROFILING_TIMER_RESOLUTION 0x1025 +#define CL_DEVICE_QUEUE_PROPERTIES 0x102A +#define CL_DEVICE_SINGLE_FP_CONFIG 0x101B +#define CL_DEVICE_TYPE 0x1000 +#define CL_DEVICE_TYPE_ACCELERATOR (1 << 3) +#define CL_DEVICE_TYPE_ALL 0xFFFFFFFF +#define CL_DEVICE_TYPE_CPU (1 << 1) +#define CL_DEVICE_TYPE_DEFAULT (1 << 0) +#define CL_DEVICE_TYPE_GPU (1 << 2) +#define CL_DEVICE_VENDOR 0x102C +#define CL_DEVICE_VENDOR_ID 0x1001 +#define CL_DEVICE_VERSION 0x102F +#define CL_DRIVER_VERSION 0x102D +#define CL_EVENT_COMMAND_EXECUTION_STATUS 0x11D3 +#define CL_EVENT_COMMAND_QUEUE 0x11D0 +#define CL_EVENT_COMMAND_TYPE 0x11D1 +#define CL_EVENT_REFERENCE_COUNT 0x11D2 +#define CL_EXEC_KERNEL (1 << 0) +#define CL_EXEC_NATIVE_KERNEL (1 << 1) +#define CL_FALSE 0 +#define CL_FILTER_LINEAR 0x1141 +#define CL_FILTER_NEAREST 0x1140 +#define CL_FLOAT 0x10DE +#define CL_FLT_DIG 6 +#define CL_FLT_EPSILON 1.1920928955078125e-7f +#define CL_FLT_MANT_DIG 24 +#define CL_FLT_MAX 340282346638528859811704183484516925440.0f +#define CL_FLT_MAX_10_EXP +38 +#define CL_FLT_MAX_EXP +128 +#define CL_FLT_MIN 1.175494350822287507969e-38f +#define CL_FLT_MIN_10_EXP -37 +#define CL_FLT_MIN_EXP -125 +#define CL_FLT_RADIX 2 +#define CL_FP_DENORM (1 << 0) +#define CL_FP_FMA (1 << 5) +#define CL_FP_INF_NAN (1 << 1) +#define CL_FP_ROUND_TO_INF (1 << 4) +#define CL_FP_ROUND_TO_NEAREST (1 << 2) +#define CL_FP_ROUND_TO_ZERO (1 << 3) +#define CL_GLOBAL 0x2 +#define CL_HALF_FLOAT 0x10DD +#define CL_HUGE_VAL ((cl_double) 1e500) +#define CL_HUGE_VALF ((cl_float) 1e50) +#define CL_IMAGE_DEPTH 0x1116 +#define CL_IMAGE_ELEMENT_SIZE 0x1111 +#define CL_IMAGE_FORMAT 0x1110 +#define CL_IMAGE_FORMAT_MISMATCH -9 +#define CL_IMAGE_FORMAT_NOT_SUPPORTED -10 +#define CL_IMAGE_HEIGHT 0x1115 +#define CL_IMAGE_ROW_PITCH 0x1112 +#define CL_IMAGE_SLICE_PITCH 0x1113 +#define CL_IMAGE_WIDTH 0x1114 +#define CL_INFINITY CL_HUGE_VALF +#define CL_INTENSITY 0x10B8 +#define CL_INT_MAX 2147483647 +#define CL_INT_MIN (-2147483647-1) +#define CL_INVALID_ARG_INDEX -49 +#define CL_INVALID_ARG_SIZE -51 +#define CL_INVALID_ARG_VALUE -50 +#define CL_INVALID_BINARY -42 +#define CL_INVALID_BUFFER_SIZE -61 +#define CL_INVALID_BUILD_OPTIONS -43 +#define CL_INVALID_COMMAND_QUEUE -36 +#define CL_INVALID_CONTEXT -34 +#define CL_INVALID_DEVICE -33 +#define CL_INVALID_DEVICE_TYPE -31 +#define CL_INVALID_EVENT -58 +#define CL_INVALID_EVENT_WAIT_LIST -57 +#define CL_INVALID_GLOBAL_OFFSET -56 +#define CL_INVALID_GLOBAL_WORK_SIZE -63 +#define CL_INVALID_GL_OBJECT -60 +#define CL_INVALID_HOST_PTR -37 +#define CL_INVALID_IMAGE_FORMAT_DESCRIPTOR -39 +#define CL_INVALID_IMAGE_SIZE -40 +#define CL_INVALID_KERNEL -48 +#define CL_INVALID_KERNEL_ARGS -52 +#define CL_INVALID_KERNEL_DEFINITION -47 +#define CL_INVALID_KERNEL_NAME -46 +#define CL_INVALID_MEM_OBJECT -38 +#define CL_INVALID_MIP_LEVEL -62 +#define CL_INVALID_OPERATION -59 +#define CL_INVALID_PLATFORM -32 +#define CL_INVALID_PROGRAM -44 +#define CL_INVALID_PROGRAM_EXECUTABLE -45 +#define CL_INVALID_QUEUE_PROPERTIES -35 +#define CL_INVALID_SAMPLER -41 +#define CL_INVALID_VALUE -30 +#define CL_INVALID_WORK_DIMENSION -53 +#define CL_INVALID_WORK_GROUP_SIZE -54 +#define CL_INVALID_WORK_ITEM_SIZE -55 +#define CL_KERNEL_COMPILE_WORK_GROUP_SIZE 0x11B1 +#define CL_KERNEL_CONTEXT 0x1193 +#define CL_KERNEL_FUNCTION_NAME 0x1190 +#define CL_KERNEL_LOCAL_MEM_SIZE 0x11B2 +#define CL_KERNEL_NUM_ARGS 0x1191 +#define CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE 0x11B3 +#define CL_KERNEL_PRIVATE_MEM_SIZE 0x11B4 +#define CL_KERNEL_PROGRAM 0x1194 +#define CL_KERNEL_REFERENCE_COUNT 0x1192 +#define CL_KERNEL_WORK_GROUP_SIZE 0x11B0 +#define CL_LOCAL 0x1 +#define CL_LONG_MAX ((cl_long) 0x7FFFFFFFFFFFFFFFLL) +#define CL_LONG_MIN ((cl_long) -0x7FFFFFFFFFFFFFFFLL - 1LL) +#define CL_LUMINANCE 0x10B9 +#define CL_MAP_FAILURE -12 +#define CL_MAP_READ (1 << 0) +#define CL_MAP_WRITE (1 << 1) +#define CL_MAXFLOAT CL_FLT_MAX +#define CL_MEM_ALLOC_HOST_PTR (1 << 4) +#define CL_MEM_CONTEXT 0x1106 +#define CL_MEM_COPY_HOST_PTR (1 << 5) +#define CL_MEM_COPY_OVERLAP -8 +#define CL_MEM_FLAGS 0x1101 +#define CL_MEM_HOST_PTR 0x1103 +#define CL_MEM_MAP_COUNT 0x1104 +#define CL_MEM_OBJECT_ALLOCATION_FAILURE -4 +#define CL_MEM_OBJECT_BUFFER 0x10F0 +#define CL_MEM_OBJECT_IMAGE2D 0x10F1 +#define CL_MEM_OBJECT_IMAGE3D 0x10F2 +#define CL_MEM_READ_ONLY (1 << 2) +#define CL_MEM_READ_WRITE (1 << 0) +#define CL_MEM_REFERENCE_COUNT 0x1105 +#define CL_MEM_SIZE 0x1102 +#define CL_MEM_TYPE 0x1100 +#define CL_MEM_USE_HOST_PTR (1 << 3) +#define CL_MEM_WRITE_ONLY (1 << 1) +#define CL_NAN (CL_INFINITY - CL_INFINITY) +#define CL_NONE 0x0 +#define CL_OUT_OF_HOST_MEMORY -6 +#define CL_OUT_OF_RESOURCES -5 +#define CL_PLATFORM_EXTENSIONS 0x0904 +#define CL_PLATFORM_NAME 0x0902 +#define CL_PLATFORM_PROFILE 0x0900 +#define CL_PLATFORM_VENDOR 0x0903 +#define CL_PLATFORM_VERSION 0x0901 +#define CL_PROFILING_COMMAND_END 0x1283 +#define CL_PROFILING_COMMAND_QUEUED 0x1280 +#define CL_PROFILING_COMMAND_START 0x1282 +#define CL_PROFILING_COMMAND_SUBMIT 0x1281 +#define CL_PROFILING_INFO_NOT_AVAILABLE -7 +#define CL_PROGRAM_BINARIES 0x1166 +#define CL_PROGRAM_BINARY_SIZES 0x1165 +#define CL_PROGRAM_BUILD_LOG 0x1183 +#define CL_PROGRAM_BUILD_OPTIONS 0x1182 +#define CL_PROGRAM_BUILD_STATUS 0x1181 +#define CL_PROGRAM_CONTEXT 0x1161 +#define CL_PROGRAM_DEVICES 0x1163 +#define CL_PROGRAM_NUM_DEVICES 0x1162 +#define CL_PROGRAM_REFERENCE_COUNT 0x1160 +#define CL_PROGRAM_SOURCE 0x1164 +#define CL_QUEUED 0x3 +#define CL_QUEUE_CONTEXT 0x1090 +#define CL_QUEUE_DEVICE 0x1091 +#define CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE (1 << 0) +#define CL_QUEUE_PROFILING_ENABLE (1 << 1) +#define CL_QUEUE_PROPERTIES 0x1093 +#define CL_QUEUE_REFERENCE_COUNT 0x1092 +#define CL_R 0x10B0 +#define CL_RA 0x10B3 +#define CL_READ_ONLY_CACHE 0x1 +#define CL_READ_WRITE_CACHE 0x2 +#define CL_RG 0x10B2 +#define CL_RGB 0x10B4 +#define CL_RGBA 0x10B5 +#define CL_RUNNING 0x1 +#define CL_SAMPLER_ADDRESSING_MODE 0x1153 +#define CL_SAMPLER_CONTEXT 0x1151 +#define CL_SAMPLER_FILTER_MODE 0x1154 +#define CL_SAMPLER_NORMALIZED_COORDS 0x1152 +#define CL_SAMPLER_REFERENCE_COUNT 0x1150 +#define CL_SCHAR_MAX 127 +#define CL_SCHAR_MIN (-127-1) +#define CL_SHRT_MAX 32767 +#define CL_SHRT_MIN (-32767-1) +#define CL_SIGNED_INT16 0x10D8 +#define CL_SIGNED_INT32 0x10D9 +#define CL_SIGNED_INT8 0x10D7 +#define CL_SNORM_INT16 0x10D1 +#define CL_SNORM_INT8 0x10D0 +#define CL_SUBMITTED 0x2 +#define CL_SUCCESS 0 +#define CL_TRUE 1 +#define CL_UCHAR_MAX 255 +#define CL_UINT_MAX 0xffffffffU +#define CL_ULONG_MAX ((cl_ulong) 0xFFFFFFFFFFFFFFFFULL) +#define CL_UNORM_INT16 0x10D3 +#define CL_UNORM_INT8 0x10D2 +#define CL_UNORM_INT_101010 0x10D6 +#define CL_UNORM_SHORT_555 0x10D5 +#define CL_UNORM_SHORT_565 0x10D4 +#define CL_UNSIGNED_INT16 0x10DB +#define CL_UNSIGNED_INT32 0x10DC +#define CL_UNSIGNED_INT8 0x10DA +#define CL_USHRT_MAX 65535 diff --git a/dlls/opencl/pe_thunks.c b/dlls/opencl/pe_thunks.c index 0b91f885c18..b4a938a034c 100644 --- a/dlls/opencl/pe_thunks.c +++ b/dlls/opencl/pe_thunks.c @@ -1,7 +1,8 @@ /* Automatically generated from OpenCL registry files; DO NOT EDIT! */ -#include "config.h" #include "opencl_private.h" +#include "opencl_types.h" +#include "unixlib.h" WINE_DEFAULT_DEBUG_CHANNEL(opencl); @@ -13,7 +14,7 @@ cl_int WINAPI wine_clBuildProgram( cl_program program, cl_uint num_devices, cons 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 ); + TRACE( "(%p, %s, %Iu, %p, %p)\n", context, wine_dbgstr_longlong(flags), size, host_ptr, errcode_ret ); return opencl_funcs->pclCreateBuffer( context, flags, size, host_ptr, errcode_ret ); } @@ -37,13 +38,13 @@ cl_context WINAPI wine_clCreateContextFromType( const cl_context_properties* pro 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 ); + TRACE( "(%p, %s, %p, %Iu, %Iu, %Iu, %p, %p)\n", context, wine_dbgstr_longlong(flags), image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret ); 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 ); + TRACE( "(%p, %s, %p, %Iu, %Iu, %Iu, %Iu, %Iu, %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 opencl_funcs->pclCreateImage3D( context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret ); } @@ -85,13 +86,13 @@ cl_int WINAPI wine_clEnqueueBarrier( cl_command_queue 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 ); + TRACE( "(%p, %p, %p, %Iu, %Iu, %Iu, %u, %p, %p)\n", command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, event ); 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 ); + TRACE( "(%p, %p, %p, %Iu, %p, %p, %u, %p, %p)\n", command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event ); return opencl_funcs->pclEnqueueCopyBufferToImage( command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event ); } @@ -103,13 +104,13 @@ cl_int WINAPI wine_clEnqueueCopyImage( cl_command_queue command_queue, cl_mem sr 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 ); + TRACE( "(%p, %p, %p, %p, %p, %Iu, %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 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 ); + TRACE( "(%p, %p, %u, %s, %Iu, %Iu, %u, %p, %p, %p)\n", command_queue, buffer, blocking_map, wine_dbgstr_longlong(map_flags), offset, size, num_events_in_wait_list, event_wait_list, event, errcode_ret ); return opencl_funcs->pclEnqueueMapBuffer( command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list, event, errcode_ret ); } @@ -133,19 +134,19 @@ cl_int WINAPI wine_clEnqueueNDRangeKernel( cl_command_queue command_queue, cl_ke 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 ); + TRACE( "(%p, %p, %p, %Iu, %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 ); + TRACE( "(%p, %p, %u, %Iu, %Iu, %p, %u, %p, %p)\n", 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 ); + TRACE( "(%p, %p, %u, %p, %p, %Iu, %Iu, %p, %u, %p, %p)\n", command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event ); 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 ); } @@ -169,13 +170,13 @@ cl_int WINAPI wine_clEnqueueWaitForEvents( cl_command_queue command_queue, cl_ui 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 ); + TRACE( "(%p, %p, %u, %Iu, %Iu, %p, %u, %p, %p)\n", 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 ); + TRACE( "(%p, %p, %u, %p, %p, %Iu, %Iu, %p, %u, %p, %p)\n", command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event ); 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 ); } @@ -193,13 +194,13 @@ cl_int WINAPI wine_clFlush( cl_command_queue 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 ); + TRACE( "(%p, %u, %Iu, %p, %p)\n", 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 ); + TRACE( "(%p, %u, %Iu, %p, %p)\n", 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 ); } @@ -211,37 +212,37 @@ cl_int WINAPI wine_clGetDeviceIDs( cl_platform_id platform, cl_device_type devic 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 ); + TRACE( "(%p, %u, %Iu, %p, %p)\n", 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 ); + TRACE( "(%p, %u, %Iu, %p, %p)\n", 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 ); + TRACE( "(%p, %u, %Iu, %p, %p)\n", 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 ); + TRACE( "(%p, %u, %Iu, %p, %p)\n", 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 ); + TRACE( "(%p, %p, %u, %Iu, %p, %p)\n", 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 ); + TRACE( "(%p, %u, %Iu, %p, %p)\n", 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 ); } @@ -253,19 +254,19 @@ cl_int WINAPI wine_clGetPlatformIDs( cl_uint num_entries, cl_platform_id* platfo 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 ); + TRACE( "(%p, %p, %u, %Iu, %p, %p)\n", 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 ); + TRACE( "(%p, %u, %Iu, %p, %p)\n", 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 ); + TRACE( "(%p, %u, %Iu, %p, %p)\n", 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 ); } @@ -367,7 +368,7 @@ cl_int WINAPI wine_clSetCommandQueueProperty( cl_command_queue command_queue, cl 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 ); + TRACE( "(%p, %u, %Iu, %p)\n", kernel, arg_index, arg_size, arg_value ); return opencl_funcs->pclSetKernelArg( kernel, arg_index, arg_size, arg_value ); } diff --git a/dlls/opencl/pe_wrappers.c b/dlls/opencl/pe_wrappers.c index c2551e785c7..e84c061c079 100644 --- a/dlls/opencl/pe_wrappers.c +++ b/dlls/opencl/pe_wrappers.c @@ -18,8 +18,9 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ -#include "config.h" #include "opencl_private.h" +#include "opencl_types.h" +#include "unixlib.h" WINE_DEFAULT_DEBUG_CHANNEL(opencl); diff --git a/dlls/opencl/unix_private.h b/dlls/opencl/unix_private.h index 2259a87827c..82fb83bd491 100644 --- a/dlls/opencl/unix_private.h +++ b/dlls/opencl/unix_private.h @@ -21,6 +21,20 @@ #include "opencl_private.h" +#define CL_SILENCE_DEPRECATION +#if defined(HAVE_CL_CL_H) +#define CL_USE_DEPRECATED_OPENCL_1_0_APIS +#define CL_USE_DEPRECATED_OPENCL_1_1_APIS +#define CL_USE_DEPRECATED_OPENCL_1_2_APIS +#define CL_USE_DEPRECATED_OPENCL_2_0_APIS +#define CL_TARGET_OPENCL_VERSION 220 +#include <CL/cl.h> +#elif defined(HAVE_OPENCL_OPENCL_H) +#include <OpenCL/opencl.h> +#endif + +#include "unixlib.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), -- 2.20.1
Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/opencl/make_opencl | 4 +- dlls/opencl/opencl.spec | 132 +++++++++++++++++++------------------- dlls/opencl/pe_thunks.c | 126 ++++++++++++++++++------------------ dlls/opencl/pe_wrappers.c | 10 +-- 4 files changed, 136 insertions(+), 136 deletions(-) diff --git a/dlls/opencl/make_opencl b/dlls/opencl/make_opencl index 6f901d570f0..4859a45b292 100755 --- a/dlls/opencl/make_opencl +++ b/dlls/opencl/make_opencl @@ -59,7 +59,7 @@ sub generate_pe_thunk($$) my $trace_call_arg = ""; my $trace_arg = ""; - my $ret = get_func_proto( "%s WINAPI wine_%s(%s)", $name, $func_ref ); + my $ret = get_func_proto( "%s WINAPI %s(%s)", $name, $func_ref ); foreach my $arg (@{$func_ref->[1]}) { my $ptype = get_arg_type( $arg ); @@ -198,7 +198,7 @@ sub generate_spec_entry($$) } } $args = substr($args,1,-1); - return "@ stdcall $_($args) wine_$_"; + return "@ stdcall $_($args)"; } my %core_functions; diff --git a/dlls/opencl/opencl.spec b/dlls/opencl/opencl.spec index 34123885587..61a83fae8cd 100644 --- a/dlls/opencl/opencl.spec +++ b/dlls/opencl/opencl.spec @@ -1,66 +1,66 @@ -@ stdcall clBuildProgram(ptr long ptr ptr ptr ptr) wine_clBuildProgram -@ stdcall clCreateBuffer(ptr int64 long ptr ptr) wine_clCreateBuffer -@ stdcall clCreateCommandQueue(ptr ptr int64 ptr) wine_clCreateCommandQueue -@ stdcall clCreateContext(ptr long ptr ptr ptr ptr) wine_clCreateContext -@ stdcall clCreateContextFromType(ptr int64 ptr ptr ptr) wine_clCreateContextFromType -@ stdcall clCreateImage2D(ptr int64 ptr long long long ptr ptr) wine_clCreateImage2D -@ stdcall clCreateImage3D(ptr int64 ptr long long long long long ptr ptr) wine_clCreateImage3D -@ stdcall clCreateKernel(ptr ptr ptr) wine_clCreateKernel -@ stdcall clCreateKernelsInProgram(ptr long ptr ptr) wine_clCreateKernelsInProgram -@ stdcall clCreateProgramWithBinary(ptr long ptr ptr ptr ptr ptr) wine_clCreateProgramWithBinary -@ stdcall clCreateProgramWithSource(ptr long ptr ptr ptr) wine_clCreateProgramWithSource -@ stdcall clCreateSampler(ptr long long long ptr) wine_clCreateSampler -@ stdcall clEnqueueBarrier(ptr) wine_clEnqueueBarrier -@ stdcall clEnqueueCopyBuffer(ptr ptr ptr long long long long ptr ptr) wine_clEnqueueCopyBuffer -@ stdcall clEnqueueCopyBufferToImage(ptr ptr ptr long ptr ptr long ptr ptr) wine_clEnqueueCopyBufferToImage -@ stdcall clEnqueueCopyImage(ptr ptr ptr ptr ptr ptr long ptr ptr) wine_clEnqueueCopyImage -@ stdcall clEnqueueCopyImageToBuffer(ptr ptr ptr ptr ptr long long ptr ptr) wine_clEnqueueCopyImageToBuffer -@ stdcall clEnqueueMapBuffer(ptr ptr long int64 long long long ptr ptr ptr) wine_clEnqueueMapBuffer -@ stdcall clEnqueueMapImage(ptr ptr long int64 ptr ptr ptr ptr long ptr ptr ptr) wine_clEnqueueMapImage -@ stdcall clEnqueueMarker(ptr ptr) wine_clEnqueueMarker -@ stdcall clEnqueueNDRangeKernel(ptr ptr long ptr ptr ptr long ptr ptr) wine_clEnqueueNDRangeKernel -@ stdcall clEnqueueNativeKernel(ptr ptr ptr long long ptr ptr long ptr ptr) wine_clEnqueueNativeKernel -@ stdcall clEnqueueReadBuffer(ptr ptr long long long ptr long ptr ptr) wine_clEnqueueReadBuffer -@ stdcall clEnqueueReadImage(ptr ptr long ptr ptr long long ptr long ptr ptr) wine_clEnqueueReadImage -@ stdcall clEnqueueTask(ptr ptr long ptr ptr) wine_clEnqueueTask -@ stdcall clEnqueueUnmapMemObject(ptr ptr ptr long ptr ptr) wine_clEnqueueUnmapMemObject -@ stdcall clEnqueueWaitForEvents(ptr long ptr) wine_clEnqueueWaitForEvents -@ stdcall clEnqueueWriteBuffer(ptr ptr long long long ptr long ptr ptr) wine_clEnqueueWriteBuffer -@ stdcall clEnqueueWriteImage(ptr ptr long ptr ptr long long ptr long ptr ptr) wine_clEnqueueWriteImage -@ stdcall clFinish(ptr) wine_clFinish -@ stdcall clFlush(ptr) wine_clFlush -@ stdcall clGetCommandQueueInfo(ptr long long ptr ptr) wine_clGetCommandQueueInfo -@ stdcall clGetContextInfo(ptr long long ptr ptr) wine_clGetContextInfo -@ stdcall clGetDeviceIDs(ptr int64 long ptr ptr) wine_clGetDeviceIDs -@ stdcall clGetDeviceInfo(ptr long long ptr ptr) wine_clGetDeviceInfo -@ stdcall clGetEventInfo(ptr long long ptr ptr) wine_clGetEventInfo -@ stdcall clGetEventProfilingInfo(ptr long long ptr ptr) wine_clGetEventProfilingInfo -@ stdcall clGetExtensionFunctionAddress(ptr) wine_clGetExtensionFunctionAddress -@ stdcall clGetImageInfo(ptr long long ptr ptr) wine_clGetImageInfo -@ stdcall clGetKernelInfo(ptr long long ptr ptr) wine_clGetKernelInfo -@ stdcall clGetKernelWorkGroupInfo(ptr ptr long long ptr ptr) wine_clGetKernelWorkGroupInfo -@ stdcall clGetMemObjectInfo(ptr long long ptr ptr) wine_clGetMemObjectInfo -@ stdcall clGetPlatformIDs(long ptr ptr) wine_clGetPlatformIDs -@ stdcall clGetPlatformInfo(ptr long long ptr ptr) wine_clGetPlatformInfo -@ stdcall clGetProgramBuildInfo(ptr ptr long long ptr ptr) wine_clGetProgramBuildInfo -@ stdcall clGetProgramInfo(ptr long long ptr ptr) wine_clGetProgramInfo -@ stdcall clGetSamplerInfo(ptr long long ptr ptr) wine_clGetSamplerInfo -@ stdcall clGetSupportedImageFormats(ptr int64 long long ptr ptr) wine_clGetSupportedImageFormats -@ stdcall clReleaseCommandQueue(ptr) wine_clReleaseCommandQueue -@ stdcall clReleaseContext(ptr) wine_clReleaseContext -@ stdcall clReleaseEvent(ptr) wine_clReleaseEvent -@ stdcall clReleaseKernel(ptr) wine_clReleaseKernel -@ stdcall clReleaseMemObject(ptr) wine_clReleaseMemObject -@ stdcall clReleaseProgram(ptr) wine_clReleaseProgram -@ stdcall clReleaseSampler(ptr) wine_clReleaseSampler -@ stdcall clRetainCommandQueue(ptr) wine_clRetainCommandQueue -@ stdcall clRetainContext(ptr) wine_clRetainContext -@ stdcall clRetainEvent(ptr) wine_clRetainEvent -@ stdcall clRetainKernel(ptr) wine_clRetainKernel -@ stdcall clRetainMemObject(ptr) wine_clRetainMemObject -@ stdcall clRetainProgram(ptr) wine_clRetainProgram -@ stdcall clRetainSampler(ptr) wine_clRetainSampler -@ stdcall clSetCommandQueueProperty(ptr int64 long ptr) wine_clSetCommandQueueProperty -@ stdcall clSetKernelArg(ptr long long ptr) wine_clSetKernelArg -@ stdcall clUnloadCompiler() wine_clUnloadCompiler -@ stdcall clWaitForEvents(long ptr) wine_clWaitForEvents +@ stdcall clBuildProgram(ptr long ptr ptr ptr ptr) +@ stdcall clCreateBuffer(ptr int64 long ptr ptr) +@ stdcall clCreateCommandQueue(ptr ptr int64 ptr) +@ stdcall clCreateContext(ptr long ptr ptr ptr ptr) +@ stdcall clCreateContextFromType(ptr int64 ptr ptr ptr) +@ stdcall clCreateImage2D(ptr int64 ptr long long long ptr ptr) +@ stdcall clCreateImage3D(ptr int64 ptr long long long long long ptr ptr) +@ stdcall clCreateKernel(ptr ptr ptr) +@ stdcall clCreateKernelsInProgram(ptr long ptr ptr) +@ stdcall clCreateProgramWithBinary(ptr long ptr ptr ptr ptr ptr) +@ stdcall clCreateProgramWithSource(ptr long ptr ptr ptr) +@ stdcall clCreateSampler(ptr long long long ptr) +@ stdcall clEnqueueBarrier(ptr) +@ stdcall clEnqueueCopyBuffer(ptr ptr ptr long long long long ptr ptr) +@ stdcall clEnqueueCopyBufferToImage(ptr ptr ptr long ptr ptr long ptr ptr) +@ stdcall clEnqueueCopyImage(ptr ptr ptr ptr ptr ptr long ptr ptr) +@ stdcall clEnqueueCopyImageToBuffer(ptr ptr ptr ptr ptr long long ptr ptr) +@ stdcall clEnqueueMapBuffer(ptr ptr long int64 long long long ptr ptr ptr) +@ stdcall clEnqueueMapImage(ptr ptr long int64 ptr ptr ptr ptr long ptr ptr ptr) +@ stdcall clEnqueueMarker(ptr ptr) +@ stdcall clEnqueueNDRangeKernel(ptr ptr long ptr ptr ptr long ptr ptr) +@ stdcall clEnqueueNativeKernel(ptr ptr ptr long long ptr ptr long ptr ptr) +@ stdcall clEnqueueReadBuffer(ptr ptr long long long ptr long ptr ptr) +@ stdcall clEnqueueReadImage(ptr ptr long ptr ptr long long ptr long ptr ptr) +@ stdcall clEnqueueTask(ptr ptr long ptr ptr) +@ stdcall clEnqueueUnmapMemObject(ptr ptr ptr long ptr ptr) +@ stdcall clEnqueueWaitForEvents(ptr long ptr) +@ stdcall clEnqueueWriteBuffer(ptr ptr long long long ptr long ptr ptr) +@ stdcall clEnqueueWriteImage(ptr ptr long ptr ptr long long ptr long ptr ptr) +@ stdcall clFinish(ptr) +@ stdcall clFlush(ptr) +@ stdcall clGetCommandQueueInfo(ptr long long ptr ptr) +@ stdcall clGetContextInfo(ptr long long ptr ptr) +@ stdcall clGetDeviceIDs(ptr int64 long ptr ptr) +@ stdcall clGetDeviceInfo(ptr long long ptr ptr) +@ stdcall clGetEventInfo(ptr long long ptr ptr) +@ stdcall clGetEventProfilingInfo(ptr long long ptr ptr) +@ stdcall clGetExtensionFunctionAddress(ptr) +@ stdcall clGetImageInfo(ptr long long ptr ptr) +@ stdcall clGetKernelInfo(ptr long long ptr ptr) +@ stdcall clGetKernelWorkGroupInfo(ptr ptr long long ptr ptr) +@ stdcall clGetMemObjectInfo(ptr long long ptr ptr) +@ stdcall clGetPlatformIDs(long ptr ptr) +@ stdcall clGetPlatformInfo(ptr long long ptr ptr) +@ stdcall clGetProgramBuildInfo(ptr ptr long long ptr ptr) +@ stdcall clGetProgramInfo(ptr long long ptr ptr) +@ stdcall clGetSamplerInfo(ptr long long ptr ptr) +@ stdcall clGetSupportedImageFormats(ptr int64 long long ptr ptr) +@ stdcall clReleaseCommandQueue(ptr) +@ stdcall clReleaseContext(ptr) +@ stdcall clReleaseEvent(ptr) +@ stdcall clReleaseKernel(ptr) +@ stdcall clReleaseMemObject(ptr) +@ stdcall clReleaseProgram(ptr) +@ stdcall clReleaseSampler(ptr) +@ stdcall clRetainCommandQueue(ptr) +@ stdcall clRetainContext(ptr) +@ stdcall clRetainEvent(ptr) +@ stdcall clRetainKernel(ptr) +@ stdcall clRetainMemObject(ptr) +@ stdcall clRetainProgram(ptr) +@ stdcall clRetainSampler(ptr) +@ stdcall clSetCommandQueueProperty(ptr int64 long ptr) +@ stdcall clSetKernelArg(ptr long long ptr) +@ stdcall clUnloadCompiler() +@ stdcall clWaitForEvents(long ptr) diff --git a/dlls/opencl/pe_thunks.c b/dlls/opencl/pe_thunks.c index b4a938a034c..b3b08688d16 100644 --- a/dlls/opencl/pe_thunks.c +++ b/dlls/opencl/pe_thunks.c @@ -6,379 +6,379 @@ 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 ) +cl_int WINAPI 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 ) +cl_mem WINAPI clCreateBuffer( cl_context context, cl_mem_flags flags, size_t size, void* host_ptr, cl_int* errcode_ret ) { TRACE( "(%p, %s, %Iu, %p, %p)\n", context, wine_dbgstr_longlong(flags), size, host_ptr, errcode_ret ); 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 ) +cl_command_queue WINAPI 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 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 ) +cl_context WINAPI 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 ) +cl_context WINAPI 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 ) +cl_mem WINAPI clCreateImage2D( cl_context context, cl_mem_flags flags, const cl_image_format* image_format, size_t image_width, size_t image_height, size_t image_row_pitch, void* host_ptr, cl_int* errcode_ret ) { TRACE( "(%p, %s, %p, %Iu, %Iu, %Iu, %p, %p)\n", context, wine_dbgstr_longlong(flags), image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret ); 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 ) +cl_mem WINAPI 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, %Iu, %Iu, %Iu, %Iu, %Iu, %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 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 ) +cl_kernel WINAPI clCreateKernel( cl_program program, const char* kernel_name, cl_int* errcode_ret ) { TRACE( "(%p, %p, %p)\n", 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 ) +cl_int WINAPI 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 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 ) +cl_program WINAPI 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 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 ) +cl_program WINAPI clCreateProgramWithSource( cl_context context, cl_uint count, const char** strings, const size_t* lengths, cl_int* errcode_ret ) { TRACE( "(%p, %u, %p, %p, %p)\n", context, count, strings, lengths, errcode_ret ); 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 ) +cl_sampler WINAPI 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 opencl_funcs->pclCreateSampler( context, normalized_coords, addressing_mode, filter_mode, errcode_ret ); } -cl_int WINAPI wine_clEnqueueBarrier( cl_command_queue command_queue ) +cl_int WINAPI clEnqueueBarrier( cl_command_queue command_queue ) { TRACE( "(%p)\n", 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 ) +cl_int WINAPI clEnqueueCopyBuffer( cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer, size_t src_offset, size_t dst_offset, size_t size, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event ) { TRACE( "(%p, %p, %p, %Iu, %Iu, %Iu, %u, %p, %p)\n", command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, event ); 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 ) +cl_int WINAPI clEnqueueCopyBufferToImage( cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_image, size_t src_offset, const size_t* dst_origin, const size_t* region, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event ) { TRACE( "(%p, %p, %p, %Iu, %p, %p, %u, %p, %p)\n", command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event ); 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 ) +cl_int WINAPI 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 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 ) +cl_int WINAPI 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, %Iu, %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 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 ) +void* WINAPI clEnqueueMapBuffer( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_map, cl_map_flags map_flags, size_t offset, size_t size, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event, cl_int* errcode_ret ) { TRACE( "(%p, %p, %u, %s, %Iu, %Iu, %u, %p, %p, %p)\n", command_queue, buffer, blocking_map, wine_dbgstr_longlong(map_flags), offset, size, num_events_in_wait_list, event_wait_list, event, errcode_ret ); 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 ) +void* WINAPI 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 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 ) +cl_int WINAPI clEnqueueMarker( cl_command_queue command_queue, cl_event* event ) { TRACE( "(%p, %p)\n", 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 ) +cl_int WINAPI clEnqueueNDRangeKernel( cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim, const size_t* global_work_offset, const size_t* global_work_size, const size_t* local_work_size, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event ) { TRACE( "(%p, %p, %u, %p, %p, %p, %u, %p, %p)\n", command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event ); 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 ) +cl_int WINAPI 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, %Iu, %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 ) +cl_int WINAPI 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, %Iu, %Iu, %p, %u, %p, %p)\n", 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 ) +cl_int WINAPI clEnqueueReadImage( cl_command_queue command_queue, cl_mem image, cl_bool blocking_read, const size_t* origin, const size_t* region, size_t row_pitch, size_t slice_pitch, void* ptr, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event ) { TRACE( "(%p, %p, %u, %p, %p, %Iu, %Iu, %p, %u, %p, %p)\n", command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event ); 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 ) +cl_int WINAPI 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 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 ) +cl_int WINAPI 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 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 ) +cl_int WINAPI 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 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 ) +cl_int WINAPI 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, %Iu, %Iu, %p, %u, %p, %p)\n", 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 ) +cl_int WINAPI clEnqueueWriteImage( cl_command_queue command_queue, cl_mem image, cl_bool blocking_write, const size_t* origin, const size_t* region, size_t input_row_pitch, size_t input_slice_pitch, const void* ptr, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event ) { TRACE( "(%p, %p, %u, %p, %p, %Iu, %Iu, %p, %u, %p, %p)\n", command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event ); 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 ) +cl_int WINAPI clFinish( cl_command_queue command_queue ) { TRACE( "(%p)\n", command_queue ); return opencl_funcs->pclFinish( command_queue ); } -cl_int WINAPI wine_clFlush( cl_command_queue command_queue ) +cl_int WINAPI clFlush( cl_command_queue command_queue ) { TRACE( "(%p)\n", 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 ) +cl_int WINAPI 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, %Iu, %p, %p)\n", 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 ) +cl_int WINAPI 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, %Iu, %p, %p)\n", 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 ) +cl_int WINAPI 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 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 ) +cl_int WINAPI 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, %Iu, %p, %p)\n", 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 ) +cl_int WINAPI 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, %Iu, %p, %p)\n", 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 ) +cl_int WINAPI 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, %Iu, %p, %p)\n", 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 ) +cl_int WINAPI clGetKernelInfo( cl_kernel kernel, cl_kernel_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret ) { TRACE( "(%p, %u, %Iu, %p, %p)\n", kernel, param_name, param_value_size, param_value, param_value_size_ret ); 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 ) +cl_int WINAPI 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, %Iu, %p, %p)\n", 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 ) +cl_int WINAPI 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, %Iu, %p, %p)\n", 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 ) +cl_int WINAPI clGetPlatformIDs( cl_uint num_entries, cl_platform_id* platforms, cl_uint* num_platforms ) { TRACE( "(%u, %p, %p)\n", 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 ) +cl_int WINAPI 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, %Iu, %p, %p)\n", 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 ) +cl_int WINAPI 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, %Iu, %p, %p)\n", 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 ) +cl_int WINAPI 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, %Iu, %p, %p)\n", 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 ) +cl_int WINAPI 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 opencl_funcs->pclGetSupportedImageFormats( context, flags, image_type, num_entries, image_formats, num_image_formats ); } -cl_int WINAPI wine_clReleaseCommandQueue( cl_command_queue command_queue ) +cl_int WINAPI clReleaseCommandQueue( cl_command_queue command_queue ) { TRACE( "(%p)\n", command_queue ); return opencl_funcs->pclReleaseCommandQueue( command_queue ); } -cl_int WINAPI wine_clReleaseContext( cl_context context ) +cl_int WINAPI clReleaseContext( cl_context context ) { TRACE( "(%p)\n", context ); return opencl_funcs->pclReleaseContext( context ); } -cl_int WINAPI wine_clReleaseEvent( cl_event event ) +cl_int WINAPI clReleaseEvent( cl_event event ) { TRACE( "(%p)\n", event ); return opencl_funcs->pclReleaseEvent( event ); } -cl_int WINAPI wine_clReleaseKernel( cl_kernel kernel ) +cl_int WINAPI clReleaseKernel( cl_kernel kernel ) { TRACE( "(%p)\n", kernel ); return opencl_funcs->pclReleaseKernel( kernel ); } -cl_int WINAPI wine_clReleaseMemObject( cl_mem memobj ) +cl_int WINAPI clReleaseMemObject( cl_mem memobj ) { TRACE( "(%p)\n", memobj ); return opencl_funcs->pclReleaseMemObject( memobj ); } -cl_int WINAPI wine_clReleaseProgram( cl_program program ) +cl_int WINAPI clReleaseProgram( cl_program program ) { TRACE( "(%p)\n", program ); return opencl_funcs->pclReleaseProgram( program ); } -cl_int WINAPI wine_clReleaseSampler( cl_sampler sampler ) +cl_int WINAPI clReleaseSampler( cl_sampler sampler ) { TRACE( "(%p)\n", sampler ); return opencl_funcs->pclReleaseSampler( sampler ); } -cl_int WINAPI wine_clRetainCommandQueue( cl_command_queue command_queue ) +cl_int WINAPI clRetainCommandQueue( cl_command_queue command_queue ) { TRACE( "(%p)\n", command_queue ); return opencl_funcs->pclRetainCommandQueue( command_queue ); } -cl_int WINAPI wine_clRetainContext( cl_context context ) +cl_int WINAPI clRetainContext( cl_context context ) { TRACE( "(%p)\n", context ); return opencl_funcs->pclRetainContext( context ); } -cl_int WINAPI wine_clRetainEvent( cl_event event ) +cl_int WINAPI clRetainEvent( cl_event event ) { TRACE( "(%p)\n", event ); return opencl_funcs->pclRetainEvent( event ); } -cl_int WINAPI wine_clRetainKernel( cl_kernel kernel ) +cl_int WINAPI clRetainKernel( cl_kernel kernel ) { TRACE( "(%p)\n", kernel ); return opencl_funcs->pclRetainKernel( kernel ); } -cl_int WINAPI wine_clRetainMemObject( cl_mem memobj ) +cl_int WINAPI clRetainMemObject( cl_mem memobj ) { TRACE( "(%p)\n", memobj ); return opencl_funcs->pclRetainMemObject( memobj ); } -cl_int WINAPI wine_clRetainProgram( cl_program program ) +cl_int WINAPI clRetainProgram( cl_program program ) { TRACE( "(%p)\n", program ); return opencl_funcs->pclRetainProgram( program ); } -cl_int WINAPI wine_clRetainSampler( cl_sampler sampler ) +cl_int WINAPI clRetainSampler( cl_sampler sampler ) { TRACE( "(%p)\n", 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 ) +cl_int WINAPI 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 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 ) +cl_int WINAPI clSetKernelArg( cl_kernel kernel, cl_uint arg_index, size_t arg_size, const void* arg_value ) { TRACE( "(%p, %u, %Iu, %p)\n", kernel, arg_index, arg_size, arg_value ); return opencl_funcs->pclSetKernelArg( kernel, arg_index, arg_size, arg_value ); } -cl_int WINAPI wine_clUnloadCompiler( void ) +cl_int WINAPI clUnloadCompiler( void ) { TRACE( "()\n" ); return opencl_funcs->pclUnloadCompiler(); } -cl_int WINAPI wine_clWaitForEvents( cl_uint num_events, const cl_event* event_list ) +cl_int WINAPI clWaitForEvents( cl_uint num_events, const cl_event* event_list ) { TRACE( "(%u, %p)\n", num_events, event_list ); return opencl_funcs->pclWaitForEvents( num_events, event_list ); diff --git a/dlls/opencl/pe_wrappers.c b/dlls/opencl/pe_wrappers.c index e84c061c079..8fdef4de399 100644 --- a/dlls/opencl/pe_wrappers.c +++ b/dlls/opencl/pe_wrappers.c @@ -26,8 +26,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) +cl_int WINAPI clGetPlatformInfo( cl_platform_id platform, cl_platform_info param_name, + SIZE_T param_value_size, void * param_value, size_t * param_value_size_ret ) { cl_int ret; TRACE("(%p, 0x%x, %ld, %p, %p)\n", platform, param_name, param_value_size, param_value, param_value_size_ret); @@ -62,8 +62,8 @@ cl_int WINAPI wine_clGetPlatformInfo(cl_platform_id platform, cl_platform_info p } -cl_int WINAPI wine_clGetDeviceInfo(cl_device_id device, cl_device_info param_name, - SIZE_T param_value_size, void * param_value, size_t * param_value_size_ret) +cl_int WINAPI clGetDeviceInfo( cl_device_id device, cl_device_info param_name, + SIZE_T param_value_size, void * param_value, size_t * param_value_size_ret ) { cl_int ret; TRACE("(%p, 0x%x, %ld, %p, %p)\n",device, param_name, param_value_size, param_value, param_value_size_ret); @@ -105,7 +105,7 @@ cl_int WINAPI wine_clGetDeviceInfo(cl_device_id device, cl_device_info param_nam } -void * WINAPI wine_clGetExtensionFunctionAddress(const char * func_name) +void * WINAPI clGetExtensionFunctionAddress( const char *func_name ) { void * ret = 0; TRACE("(%s)\n",func_name); -- 2.20.1
participants (1)
-
Zebediah Figura