[PATCH 3/3] opencl: Do not prepend "wine_" to export names.
Zebediah Figura
z.figura12 at gmail.com
Mon Mar 15 23:44:52 CDT 2021
Signed-off-by: Zebediah Figura <z.figura12 at 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
More information about the wine-devel
mailing list