dlls/opencl/unix_thunks.c

   1 /* Automatically generated from OpenCL registry files; DO NOT EDIT! */
   2
   3 #if 0
   4 #pragma makedep unix
   5 #endif
   6
   7 #include "config.h"
   8 #include "unix_private.h"
   9
  10 static cl_mem WINAPI wrap_clCreateBuffer( cl_context context, cl_mem_flags flags, size_t size, void* host_ptr, cl_int* errcode_ret )
  11 {
  12     return clCreateBuffer( context, flags, size, host_ptr, errcode_ret );
  13 }
  14
  15 static cl_command_queue WINAPI wrap_clCreateCommandQueue( cl_context context, cl_device_id device, cl_command_queue_properties properties, cl_int* errcode_ret )
  16 {
  17     return clCreateCommandQueue( context, device, properties, errcode_ret );
  18 }
  19
  20 static cl_mem WINAPI wrap_clCreateImage( cl_context context, cl_mem_flags flags, const cl_image_format* image_format, const cl_image_desc* image_desc, void* host_ptr, cl_int* errcode_ret )
  21 {
  22     return clCreateImage( context, flags, image_format, image_desc, host_ptr, errcode_ret );
  23 }
  24
  25 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 )
  26 {
  27     return clCreateImage2D( context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret );
  28 }
  29
  30 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 )
  31 {
  32     return clCreateImage3D( context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret );
  33 }
  34
  35 static cl_kernel WINAPI wrap_clCreateKernel( cl_program program, const char* kernel_name, cl_int* errcode_ret )
  36 {
  37     return clCreateKernel( program, kernel_name, errcode_ret );
  38 }
  39
  40 static cl_int WINAPI wrap_clCreateKernelsInProgram( cl_program program, cl_uint num_kernels, cl_kernel* kernels, cl_uint* num_kernels_ret )
  41 {
  42     return clCreateKernelsInProgram( program, num_kernels, kernels, num_kernels_ret );
  43 }
  44
  45 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 )
  46 {
  47     return clCreateProgramWithBinary( context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret );
  48 }
  49
  50 static cl_program WINAPI wrap_clCreateProgramWithBuiltInKernels( cl_context context, cl_uint num_devices, const cl_device_id* device_list, const char* kernel_names, cl_int* errcode_ret )
  51 {
  52     return clCreateProgramWithBuiltInKernels( context, num_devices, device_list, kernel_names, errcode_ret );
  53 }
  54
  55 static cl_program WINAPI wrap_clCreateProgramWithSource( cl_context context, cl_uint count, const char** strings, const size_t* lengths, cl_int* errcode_ret )
  56 {
  57     return clCreateProgramWithSource( context, count, strings, lengths, errcode_ret );
  58 }
  59
  60 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 )
  61 {
  62     return clCreateSampler( context, normalized_coords, addressing_mode, filter_mode, errcode_ret );
  63 }
  64
  65 static cl_mem WINAPI wrap_clCreateSubBuffer( cl_mem buffer, cl_mem_flags flags, cl_buffer_create_type buffer_create_type, const void* buffer_create_info, cl_int* errcode_ret )
  66 {
  67     return clCreateSubBuffer( buffer, flags, buffer_create_type, buffer_create_info, errcode_ret );
  68 }
  69
  70 static cl_int WINAPI wrap_clCreateSubDevices( cl_device_id in_device, const cl_device_partition_property* properties, cl_uint num_devices, cl_device_id* out_devices, cl_uint* num_devices_ret )
  71 {
  72     return clCreateSubDevices( in_device, properties, num_devices, out_devices, num_devices_ret );
  73 }
  74
  75 static cl_event WINAPI wrap_clCreateUserEvent( cl_context context, cl_int* errcode_ret )
  76 {
  77     return clCreateUserEvent( context, errcode_ret );
  78 }
  79
  80 static cl_int WINAPI wrap_clEnqueueBarrier( cl_command_queue command_queue )
  81 {
  82     return clEnqueueBarrier( command_queue );
  83 }
  84
  85 static cl_int WINAPI wrap_clEnqueueBarrierWithWaitList( cl_command_queue command_queue, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
  86 {
  87     return clEnqueueBarrierWithWaitList( command_queue, num_events_in_wait_list, event_wait_list, event );
  88 }
  89
  90 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 )
  91 {
  92     return clEnqueueCopyBuffer( command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, event );
  93 }
  94
  95 static cl_int WINAPI wrap_clEnqueueCopyBufferRect( cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer, const size_t* src_origin, const size_t* dst_origin, const size_t* region, size_t src_row_pitch, size_t src_slice_pitch, size_t dst_row_pitch, size_t dst_slice_pitch, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
  96 {
  97     return clEnqueueCopyBufferRect( command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, event );
  98 }
  99
 100 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 )
 101 {
 102     return clEnqueueCopyBufferToImage( command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
 103 }
 104
 105 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 )
 106 {
 107     return clEnqueueCopyImage( command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
 108 }
 109
 110 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 )
 111 {
 112     return clEnqueueCopyImageToBuffer( command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event );
 113 }
 114
 115 static cl_int WINAPI wrap_clEnqueueFillBuffer( cl_command_queue command_queue, cl_mem buffer, const void* pattern, size_t pattern_size, size_t offset, size_t size, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
 116 {
 117     return clEnqueueFillBuffer( command_queue, buffer, pattern, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, event );
 118 }
 119
 120 static cl_int WINAPI wrap_clEnqueueFillImage( cl_command_queue command_queue, cl_mem image, const void* fill_color, const size_t* origin, const size_t* region, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
 121 {
 122     return clEnqueueFillImage( command_queue, image, fill_color, origin, region, num_events_in_wait_list, event_wait_list, event );
 123 }
 124
 125 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 )
 126 {
 127     return clEnqueueMapBuffer( command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list, event, errcode_ret );
 128 }
 129
 130 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 )
 131 {
 132     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 );
 133 }
 134
 135 static cl_int WINAPI wrap_clEnqueueMarker( cl_command_queue command_queue, cl_event* event )
 136 {
 137     return clEnqueueMarker( command_queue, event );
 138 }
 139
 140 static cl_int WINAPI wrap_clEnqueueMarkerWithWaitList( cl_command_queue command_queue, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
 141 {
 142     return clEnqueueMarkerWithWaitList( command_queue, num_events_in_wait_list, event_wait_list, event );
 143 }
 144
 145 static cl_int WINAPI wrap_clEnqueueMigrateMemObjects( cl_command_queue command_queue, cl_uint num_mem_objects, const cl_mem* mem_objects, cl_mem_migration_flags flags, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
 146 {
 147     return clEnqueueMigrateMemObjects( command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, event );
 148 }
 149
 150 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 )
 151 {
 152     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 );
 153 }
 154
 155 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 )
 156 {
 157     return clEnqueueReadBuffer( command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
 158 }
 159
 160 static cl_int WINAPI wrap_clEnqueueReadBufferRect( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, const size_t* buffer_origin, const size_t* host_origin, const size_t* region, size_t buffer_row_pitch, size_t buffer_slice_pitch, size_t host_row_pitch, size_t host_slice_pitch, void* ptr, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
 161 {
 162     return clEnqueueReadBufferRect( command_queue, buffer, blocking_read, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
 163 }
 164
 165 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 )
 166 {
 167     return clEnqueueReadImage( command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
 168 }
 169
 170 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 )
 171 {
 172     return clEnqueueTask( command_queue, kernel, num_events_in_wait_list, event_wait_list, event );
 173 }
 174
 175 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 )
 176 {
 177     return clEnqueueUnmapMemObject( command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event );
 178 }
 179
 180 static cl_int WINAPI wrap_clEnqueueWaitForEvents( cl_command_queue command_queue, cl_uint num_events, const cl_event* event_list )
 181 {
 182     return clEnqueueWaitForEvents( command_queue, num_events, event_list );
 183 }
 184
 185 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 )
 186 {
 187     return clEnqueueWriteBuffer( command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
 188 }
 189
 190 static cl_int WINAPI wrap_clEnqueueWriteBufferRect( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, const size_t* buffer_origin, const size_t* host_origin, const size_t* region, size_t buffer_row_pitch, size_t buffer_slice_pitch, size_t host_row_pitch, size_t host_slice_pitch, const void* ptr, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
 191 {
 192     return clEnqueueWriteBufferRect( command_queue, buffer, blocking_write, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
 193 }
 194
 195 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 )
 196 {
 197     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 );
 198 }
 199
 200 static cl_int WINAPI wrap_clFinish( cl_command_queue command_queue )
 201 {
 202     return clFinish( command_queue );
 203 }
 204
 205 static cl_int WINAPI wrap_clFlush( cl_command_queue command_queue )
 206 {
 207     return clFlush( command_queue );
 208 }
 209
 210 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 )
 211 {
 212     return clGetCommandQueueInfo( command_queue, param_name, param_value_size, param_value, param_value_size_ret );
 213 }
 214
 215 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 )
 216 {
 217     return clGetContextInfo( context, param_name, param_value_size, param_value, param_value_size_ret );
 218 }
 219
 220 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 )
 221 {
 222     return clGetDeviceIDs( platform, device_type, num_entries, devices, num_devices );
 223 }
 224
 225 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 )
 226 {
 227     return clGetDeviceInfo( device, param_name, param_value_size, param_value, param_value_size_ret );
 228 }
 229
 230 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 )
 231 {
 232     return clGetEventInfo( event, param_name, param_value_size, param_value, param_value_size_ret );
 233 }
 234
 235 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 )
 236 {
 237     return clGetEventProfilingInfo( event, param_name, param_value_size, param_value, param_value_size_ret );
 238 }
 239
 240 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 )
 241 {
 242     return clGetImageInfo( image, param_name, param_value_size, param_value, param_value_size_ret );
 243 }
 244
 245 static cl_int WINAPI wrap_clGetKernelArgInfo( cl_kernel kernel, cl_uint arg_index, cl_kernel_arg_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
 246 {
 247     return clGetKernelArgInfo( kernel, arg_index, param_name, param_value_size, param_value, param_value_size_ret );
 248 }
 249
 250 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 )
 251 {
 252     return clGetKernelInfo( kernel, param_name, param_value_size, param_value, param_value_size_ret );
 253 }
 254
 255 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 )
 256 {
 257     return clGetKernelWorkGroupInfo( kernel, device, param_name, param_value_size, param_value, param_value_size_ret );
 258 }
 259
 260 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 )
 261 {
 262     return clGetMemObjectInfo( memobj, param_name, param_value_size, param_value, param_value_size_ret );
 263 }
 264
 265 static cl_int WINAPI wrap_clGetPlatformIDs( cl_uint num_entries, cl_platform_id* platforms, cl_uint* num_platforms )
 266 {
 267     return clGetPlatformIDs( num_entries, platforms, num_platforms );
 268 }
 269
 270 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 )
 271 {
 272     return clGetPlatformInfo( platform, param_name, param_value_size, param_value, param_value_size_ret );
 273 }
 274
 275 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 )
 276 {
 277     return clGetProgramBuildInfo( program, device, param_name, param_value_size, param_value, param_value_size_ret );
 278 }
 279
 280 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 )
 281 {
 282     return clGetProgramInfo( program, param_name, param_value_size, param_value, param_value_size_ret );
 283 }
 284
 285 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 )
 286 {
 287     return clGetSamplerInfo( sampler, param_name, param_value_size, param_value, param_value_size_ret );
 288 }
 289
 290 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 )
 291 {
 292     return clGetSupportedImageFormats( context, flags, image_type, num_entries, image_formats, num_image_formats );
 293 }
 294
 295 static cl_int WINAPI wrap_clReleaseCommandQueue( cl_command_queue command_queue )
 296 {
 297     return clReleaseCommandQueue( command_queue );
 298 }
 299
 300 static cl_int WINAPI wrap_clReleaseContext( cl_context context )
 301 {
 302     return clReleaseContext( context );
 303 }
 304
 305 static cl_int WINAPI wrap_clReleaseDevice( cl_device_id device )
 306 {
 307     return clReleaseDevice( device );
 308 }
 309
 310 static cl_int WINAPI wrap_clReleaseEvent( cl_event event )
 311 {
 312     return clReleaseEvent( event );
 313 }
 314
 315 static cl_int WINAPI wrap_clReleaseKernel( cl_kernel kernel )
 316 {
 317     return clReleaseKernel( kernel );
 318 }
 319
 320 static cl_int WINAPI wrap_clReleaseMemObject( cl_mem memobj )
 321 {
 322     return clReleaseMemObject( memobj );
 323 }
 324
 325 static cl_int WINAPI wrap_clReleaseProgram( cl_program program )
 326 {
 327     return clReleaseProgram( program );
 328 }
 329
 330 static cl_int WINAPI wrap_clReleaseSampler( cl_sampler sampler )
 331 {
 332     return clReleaseSampler( sampler );
 333 }
 334
 335 static cl_int WINAPI wrap_clRetainCommandQueue( cl_command_queue command_queue )
 336 {
 337     return clRetainCommandQueue( command_queue );
 338 }
 339
 340 static cl_int WINAPI wrap_clRetainContext( cl_context context )
 341 {
 342     return clRetainContext( context );
 343 }
 344
 345 static cl_int WINAPI wrap_clRetainDevice( cl_device_id device )
 346 {
 347     return clRetainDevice( device );
 348 }
 349
 350 static cl_int WINAPI wrap_clRetainEvent( cl_event event )
 351 {
 352     return clRetainEvent( event );
 353 }
 354
 355 static cl_int WINAPI wrap_clRetainKernel( cl_kernel kernel )
 356 {
 357     return clRetainKernel( kernel );
 358 }
 359
 360 static cl_int WINAPI wrap_clRetainMemObject( cl_mem memobj )
 361 {
 362     return clRetainMemObject( memobj );
 363 }
 364
 365 static cl_int WINAPI wrap_clRetainProgram( cl_program program )
 366 {
 367     return clRetainProgram( program );
 368 }
 369
 370 static cl_int WINAPI wrap_clRetainSampler( cl_sampler sampler )
 371 {
 372     return clRetainSampler( sampler );
 373 }
 374
 375 static cl_int WINAPI wrap_clSetKernelArg( cl_kernel kernel, cl_uint arg_index, size_t arg_size, const void* arg_value )
 376 {
 377     return clSetKernelArg( kernel, arg_index, arg_size, arg_value );
 378 }
 379
 380 static cl_int WINAPI wrap_clSetUserEventStatus( cl_event event, cl_int execution_status )
 381 {
 382     return clSetUserEventStatus( event, execution_status );
 383 }
 384
 385 static cl_int WINAPI wrap_clUnloadCompiler( void  )
 386 {
 387     return clUnloadCompiler();
 388 }
 389
 390 static cl_int WINAPI wrap_clUnloadPlatformCompiler( cl_platform_id platform )
 391 {
 392     return clUnloadPlatformCompiler( platform );
 393 }
 394
 395 static cl_int WINAPI wrap_clWaitForEvents( cl_uint num_events, const cl_event* event_list )
 396 {
 397     return clWaitForEvents( num_events, event_list );
 398 }
 399
 400 const struct opencl_funcs funcs =
 401 {
 402     wrap_clBuildProgram,
 403     wrap_clCompileProgram,
 404     wrap_clCreateBuffer,
 405     wrap_clCreateCommandQueue,
 406     wrap_clCreateContext,
 407     wrap_clCreateContextFromType,
 408     wrap_clCreateImage,
 409     wrap_clCreateImage2D,
 410     wrap_clCreateImage3D,
 411     wrap_clCreateKernel,
 412     wrap_clCreateKernelsInProgram,
 413     wrap_clCreateProgramWithBinary,
 414     wrap_clCreateProgramWithBuiltInKernels,
 415     wrap_clCreateProgramWithSource,
 416     wrap_clCreateSampler,
 417     wrap_clCreateSubBuffer,
 418     wrap_clCreateSubDevices,
 419     wrap_clCreateUserEvent,
 420     wrap_clEnqueueBarrier,
 421     wrap_clEnqueueBarrierWithWaitList,
 422     wrap_clEnqueueCopyBuffer,
 423     wrap_clEnqueueCopyBufferRect,
 424     wrap_clEnqueueCopyBufferToImage,
 425     wrap_clEnqueueCopyImage,
 426     wrap_clEnqueueCopyImageToBuffer,
 427     wrap_clEnqueueFillBuffer,
 428     wrap_clEnqueueFillImage,
 429     wrap_clEnqueueMapBuffer,
 430     wrap_clEnqueueMapImage,
 431     wrap_clEnqueueMarker,
 432     wrap_clEnqueueMarkerWithWaitList,
 433     wrap_clEnqueueMigrateMemObjects,
 434     wrap_clEnqueueNDRangeKernel,
 435     wrap_clEnqueueNativeKernel,
 436     wrap_clEnqueueReadBuffer,
 437     wrap_clEnqueueReadBufferRect,
 438     wrap_clEnqueueReadImage,
 439     wrap_clEnqueueTask,
 440     wrap_clEnqueueUnmapMemObject,
 441     wrap_clEnqueueWaitForEvents,
 442     wrap_clEnqueueWriteBuffer,
 443     wrap_clEnqueueWriteBufferRect,
 444     wrap_clEnqueueWriteImage,
 445     wrap_clFinish,
 446     wrap_clFlush,
 447     wrap_clGetCommandQueueInfo,
 448     wrap_clGetContextInfo,
 449     wrap_clGetDeviceIDs,
 450     wrap_clGetDeviceInfo,
 451     wrap_clGetEventInfo,
 452     wrap_clGetEventProfilingInfo,
 453     wrap_clGetImageInfo,
 454     wrap_clGetKernelArgInfo,
 455     wrap_clGetKernelInfo,
 456     wrap_clGetKernelWorkGroupInfo,
 457     wrap_clGetMemObjectInfo,
 458     wrap_clGetPlatformIDs,
 459     wrap_clGetPlatformInfo,
 460     wrap_clGetProgramBuildInfo,
 461     wrap_clGetProgramInfo,
 462     wrap_clGetSamplerInfo,
 463     wrap_clGetSupportedImageFormats,
 464     wrap_clLinkProgram,
 465     wrap_clReleaseCommandQueue,
 466     wrap_clReleaseContext,
 467     wrap_clReleaseDevice,
 468     wrap_clReleaseEvent,
 469     wrap_clReleaseKernel,
 470     wrap_clReleaseMemObject,
 471     wrap_clReleaseProgram,
 472     wrap_clReleaseSampler,
 473     wrap_clRetainCommandQueue,
 474     wrap_clRetainContext,
 475     wrap_clRetainDevice,
 476     wrap_clRetainEvent,
 477     wrap_clRetainKernel,
 478     wrap_clRetainMemObject,
 479     wrap_clRetainProgram,
 480     wrap_clRetainSampler,
 481     wrap_clSetEventCallback,
 482     wrap_clSetKernelArg,
 483     wrap_clSetMemObjectDestructorCallback,
 484     wrap_clSetUserEventStatus,
 485     wrap_clUnloadCompiler,
 486     wrap_clUnloadPlatformCompiler,
 487     wrap_clWaitForEvents,
 488 };