← Back to branch summary

~registry/dolphin-emu/triforce

« back to all changes in this revision

Viewing changes to Externals/CLRun/clrun/gencl.c

  • Committer: Sérgio Benjamim
  • Date: 2015-02-13 05:54:40 UTC
  • Revision ID: sergio_br2@yahoo.com.br-20150213055440-ey2rt3sjpy27km78
Dolphin Triforce branch from code.google, commit b957980 (4.0-315).

Show diffs side-by-side

added added

removed removed

Lines of Context:
Externals/CLRun/clrun/gencl.c
 
1
// Automatically generated by generateClRun.pl
 
2
#include "dynamiclib.h"
 
3
#include "../include/CL/cl.h"
 
4
 
 
5
 
 
6
static cl_int (*clGetPlatformIDs_ptr)(cl_uint, cl_platform_id *, cl_uint *) = NULL;
 
7
cl_int CL_API_CALL clGetPlatformIDs (cl_uint num_entries,cl_platform_id * platforms,cl_uint * num_platforms) {
 
8
        if(!clGetPlatformIDs_ptr) clGetPlatformIDs_ptr = getFunction("clGetPlatformIDs");
 
9
        return (*clGetPlatformIDs_ptr)(num_entries, platforms, num_platforms);
 
10
}
 
11
 
 
12
static cl_int (*clGetPlatformInfo_ptr)(cl_platform_id, cl_platform_info, size_t, void *, size_t *) = NULL;
 
13
cl_int CL_API_CALL clGetPlatformInfo (cl_platform_id platform,cl_platform_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret) {
 
14
        if(!clGetPlatformInfo_ptr) clGetPlatformInfo_ptr = getFunction("clGetPlatformInfo");
 
15
        return (*clGetPlatformInfo_ptr)(platform, param_name, param_value_size, param_value, param_value_size_ret);
 
16
}
 
17
 
 
18
static cl_int (*clGetDeviceIDs_ptr)(cl_platform_id, cl_device_type, cl_uint, cl_device_id *, cl_uint *) = NULL;
 
19
cl_int CL_API_CALL clGetDeviceIDs (cl_platform_id platform,cl_device_type device_type,cl_uint num_entries,cl_device_id * devices,cl_uint * num_devices) {
 
20
        if(!clGetDeviceIDs_ptr) clGetDeviceIDs_ptr = getFunction("clGetDeviceIDs");
 
21
        return (*clGetDeviceIDs_ptr)(platform, device_type, num_entries, devices, num_devices);
 
22
}
 
23
 
 
24
static cl_int (*clGetDeviceInfo_ptr)(cl_device_id, cl_device_info, size_t, void *, size_t *) = NULL;
 
25
cl_int CL_API_CALL clGetDeviceInfo (cl_device_id device,cl_device_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret) {
 
26
        if(!clGetDeviceInfo_ptr) clGetDeviceInfo_ptr = getFunction("clGetDeviceInfo");
 
27
        return (*clGetDeviceInfo_ptr)(device, param_name, param_value_size, param_value, param_value_size_ret);
 
28
}
 
29
 
 
30
static cl_int (*clCreateSubDevices_ptr)(cl_device_id, const cl_device_partition_property *, cl_uint, cl_device_id *, cl_uint *) = NULL;
 
31
cl_int CL_API_CALL 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) {
 
32
        if(!clCreateSubDevices_ptr) clCreateSubDevices_ptr = getFunction("clCreateSubDevices");
 
33
        return (*clCreateSubDevices_ptr)(in_device, properties, num_devices, out_devices, num_devices_ret);
 
34
}
 
35
 
 
36
static cl_int (*clRetainDevice_ptr)(cl_device_id) = NULL;
 
37
cl_int CL_API_CALL clRetainDevice (cl_device_id device) {
 
38
        if(!clRetainDevice_ptr) clRetainDevice_ptr = getFunction("clRetainDevice");
 
39
        return (*clRetainDevice_ptr)(device);
 
40
}
 
41
 
 
42
static cl_int (*clReleaseDevice_ptr)(cl_device_id) = NULL;
 
43
cl_int CL_API_CALL clReleaseDevice (cl_device_id device) {
 
44
        if(!clReleaseDevice_ptr) clReleaseDevice_ptr = getFunction("clReleaseDevice");
 
45
        return (*clReleaseDevice_ptr)(device);
 
46
}
 
47
 
 
48
static cl_context (*clCreateContext_ptr)(const cl_context_properties *, cl_uint, const cl_device_id *, void (CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *), void*, cl_int*) = NULL;
 
49
cl_context CL_API_CALL clCreateContext(const cl_context_properties * properties,
 
50
                cl_uint                  num_devices,
 
51
                const cl_device_id *     devices,
 
52
                void (CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *),
 
53
                void *                   user_data,
 
54
                cl_int *                errcode_ret)  {
 
55
        if(!clCreateContext_ptr) clCreateContext_ptr = getFunction("clCreateContext");
 
56
        return (*clCreateContext_ptr)(properties, num_devices, devices, pfn_notify, user_data, errcode_ret);
 
57
}
 
58
 
 
59
static cl_context (*clCreateContextFromType_ptr)(const cl_context_properties *, cl_device_type, void (CL_CALLBACK * /* pfn_notify */)(const char *, const void *, size_t, void *), void*, cl_int*) = NULL;
 
60
cl_context CL_API_CALL clCreateContextFromType(const cl_context_properties * properties,
 
61
                        cl_device_type          device_type,
 
62
                        void (CL_CALLBACK *     pfn_notify)(const char *, const void *, size_t, void *),
 
63
                        void *                  user_data,
 
64
                        cl_int *                errcode_ret) {
 
65
        if(!clCreateContextFromType_ptr) clCreateContextFromType_ptr = getFunction("clCreateContextFromType");
 
66
        return (*clCreateContextFromType_ptr)(properties, device_type, pfn_notify, user_data, errcode_ret);
 
67
}
 
68
 
 
69
static cl_int (*clRetainContext_ptr)(cl_context) = NULL;
 
70
cl_int CL_API_CALL clRetainContext (cl_context context) {
 
71
        if(!clRetainContext_ptr) clRetainContext_ptr = getFunction("clRetainContext");
 
72
        return (*clRetainContext_ptr)(context);
 
73
}
 
74
 
 
75
static cl_int (*clReleaseContext_ptr)(cl_context) = NULL;
 
76
cl_int CL_API_CALL clReleaseContext (cl_context context) {
 
77
        if(!clReleaseContext_ptr) clReleaseContext_ptr = getFunction("clReleaseContext");
 
78
        return (*clReleaseContext_ptr)(context);
 
79
}
 
80
 
 
81
static cl_int (*clGetContextInfo_ptr)(cl_context, cl_context_info, size_t, void *, size_t *) = NULL;
 
82
cl_int CL_API_CALL clGetContextInfo (cl_context context,cl_context_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret) {
 
83
        if(!clGetContextInfo_ptr) clGetContextInfo_ptr = getFunction("clGetContextInfo");
 
84
        return (*clGetContextInfo_ptr)(context, param_name, param_value_size, param_value, param_value_size_ret);
 
85
}
 
86
 
 
87
static cl_command_queue (*clCreateCommandQueue_ptr)(cl_context, cl_device_id, cl_command_queue_properties, cl_int *) = NULL;
 
88
cl_command_queue CL_API_CALL clCreateCommandQueue (cl_context context,cl_device_id device,cl_command_queue_properties properties,cl_int * errcode_ret) {
 
89
        if(!clCreateCommandQueue_ptr) clCreateCommandQueue_ptr = getFunction("clCreateCommandQueue");
 
90
        return (*clCreateCommandQueue_ptr)(context, device, properties, errcode_ret);
 
91
}
 
92
 
 
93
static cl_int (*clRetainCommandQueue_ptr)(cl_command_queue) = NULL;
 
94
cl_int CL_API_CALL clRetainCommandQueue (cl_command_queue command_queue) {
 
95
        if(!clRetainCommandQueue_ptr) clRetainCommandQueue_ptr = getFunction("clRetainCommandQueue");
 
96
        return (*clRetainCommandQueue_ptr)(command_queue);
 
97
}
 
98
 
 
99
static cl_int (*clReleaseCommandQueue_ptr)(cl_command_queue) = NULL;
 
100
cl_int CL_API_CALL clReleaseCommandQueue (cl_command_queue command_queue) {
 
101
        if(!clReleaseCommandQueue_ptr) clReleaseCommandQueue_ptr = getFunction("clReleaseCommandQueue");
 
102
        return (*clReleaseCommandQueue_ptr)(command_queue);
 
103
}
 
104
 
 
105
static cl_int (*clGetCommandQueueInfo_ptr)(cl_command_queue, cl_command_queue_info, size_t, void *, size_t *) = NULL;
 
106
cl_int CL_API_CALL 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) {
 
107
        if(!clGetCommandQueueInfo_ptr) clGetCommandQueueInfo_ptr = getFunction("clGetCommandQueueInfo");
 
108
        return (*clGetCommandQueueInfo_ptr)(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
 
109
}
 
110
 
 
111
static cl_mem (*clCreateBuffer_ptr)(cl_context, cl_mem_flags, size_t, void *, cl_int *) = NULL;
 
112
cl_mem CL_API_CALL clCreateBuffer (cl_context context,cl_mem_flags flags,size_t size,void * host_ptr,cl_int * errcode_ret) {
 
113
        if(!clCreateBuffer_ptr) clCreateBuffer_ptr = getFunction("clCreateBuffer");
 
114
        return (*clCreateBuffer_ptr)(context, flags, size, host_ptr, errcode_ret);
 
115
}
 
116
 
 
117
static cl_mem (*clCreateSubBuffer_ptr)(cl_mem, cl_mem_flags, cl_buffer_create_type, const void *, cl_int *) = NULL;
 
118
cl_mem CL_API_CALL clCreateSubBuffer (cl_mem buffer,cl_mem_flags flags,cl_buffer_create_type buffer_create_type,const void * buffer_create_info,cl_int * errcode_ret) {
 
119
        if(!clCreateSubBuffer_ptr) clCreateSubBuffer_ptr = getFunction("clCreateSubBuffer");
 
120
        return (*clCreateSubBuffer_ptr)(buffer, flags, buffer_create_type, buffer_create_info, errcode_ret);
 
121
}
 
122
 
 
123
static cl_mem (*clCreateImage_ptr)(cl_context, cl_mem_flags, const cl_image_format *, const cl_image_desc *, void *, cl_int *) = NULL;
 
124
cl_mem CL_API_CALL 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) {
 
125
        if(!clCreateImage_ptr) clCreateImage_ptr = getFunction("clCreateImage");
 
126
        return (*clCreateImage_ptr)(context, flags, image_format, image_desc, host_ptr, errcode_ret);
 
127
}
 
128
 
 
129
static cl_int (*clRetainMemObject_ptr)(cl_mem) = NULL;
 
130
cl_int CL_API_CALL clRetainMemObject (cl_mem memobj) {
 
131
        if(!clRetainMemObject_ptr) clRetainMemObject_ptr = getFunction("clRetainMemObject");
 
132
        return (*clRetainMemObject_ptr)(memobj);
 
133
}
 
134
 
 
135
static cl_int (*clReleaseMemObject_ptr)(cl_mem) = NULL;
 
136
cl_int CL_API_CALL clReleaseMemObject (cl_mem memobj) {
 
137
        if(!clReleaseMemObject_ptr) clReleaseMemObject_ptr = getFunction("clReleaseMemObject");
 
138
        return (*clReleaseMemObject_ptr)(memobj);
 
139
}
 
140
 
 
141
static cl_int (*clGetSupportedImageFormats_ptr)(cl_context, cl_mem_flags, cl_mem_object_type, cl_uint, cl_image_format *, cl_uint *) = NULL;
 
142
cl_int CL_API_CALL 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) {
 
143
        if(!clGetSupportedImageFormats_ptr) clGetSupportedImageFormats_ptr = getFunction("clGetSupportedImageFormats");
 
144
        return (*clGetSupportedImageFormats_ptr)(context, flags, image_type, num_entries, image_formats, num_image_formats);
 
145
}
 
146
 
 
147
static cl_int (*clGetMemObjectInfo_ptr)(cl_mem, cl_mem_info, size_t, void *, size_t *) = NULL;
 
148
cl_int CL_API_CALL clGetMemObjectInfo (cl_mem memobj,cl_mem_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret) {
 
149
        if(!clGetMemObjectInfo_ptr) clGetMemObjectInfo_ptr = getFunction("clGetMemObjectInfo");
 
150
        return (*clGetMemObjectInfo_ptr)(memobj, param_name, param_value_size, param_value, param_value_size_ret);
 
151
}
 
152
 
 
153
static cl_int (*clGetImageInfo_ptr)(cl_mem, cl_image_info, size_t, void *, size_t *) = NULL;
 
154
cl_int CL_API_CALL clGetImageInfo (cl_mem image,cl_image_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret) {
 
155
        if(!clGetImageInfo_ptr) clGetImageInfo_ptr = getFunction("clGetImageInfo");
 
156
        return (*clGetImageInfo_ptr)(image, param_name, param_value_size, param_value, param_value_size_ret);
 
157
}
 
158
 
 
159
/* Sampler APIs */
 
160
static cl_int (*clSetMemObjectDestructorCallback_ptr)(cl_mem memobj,void (CL_CALLBACK *pfn_notify)( cl_mem memobj, void*) ,void *user_data ) = NULL;
 
161
cl_int CL_API_CALL clSetMemObjectDestructorCallback (cl_mem memobj,void (CL_CALLBACK *pfn_notify)( cl_mem memobj, void*) ,void *user_data )
 
162
{
 
163
        if(!clSetMemObjectDestructorCallback_ptr) clSetMemObjectDestructorCallback_ptr = getFunction("clSetMemObjectDestructorCallback");
 
164
        return (*clSetMemObjectDestructorCallback_ptr)(memobj, pfn_notify, user_data);
 
165
}
 
166
 
 
167
/* Sampler APIs */
 
168
static cl_sampler (*clCreateSampler_ptr)(cl_context, cl_bool, cl_addressing_mode, cl_filter_mode, cl_int *) = NULL;
 
169
cl_sampler CL_API_CALL clCreateSampler(cl_context context,cl_bool normalized_coords,cl_addressing_mode addressing_mode,cl_filter_mode filter_mode,cl_int * errcode_ret) {
 
170
        if(!clCreateSampler_ptr) clCreateSampler_ptr = getFunction("clCreateSampler");
 
171
        return (*clCreateSampler_ptr)(context, normalized_coords, addressing_mode, filter_mode, errcode_ret);
 
172
}
 
173
 
 
174
static cl_int (*clRetainSampler_ptr)(cl_sampler) = NULL;
 
175
cl_int CL_API_CALL clRetainSampler (cl_sampler sampler) {
 
176
        if(!clRetainSampler_ptr) clRetainSampler_ptr = getFunction("clRetainSampler");
 
177
        return (*clRetainSampler_ptr)(sampler);
 
178
}
 
179
 
 
180
static cl_int (*clReleaseSampler_ptr)(cl_sampler) = NULL;
 
181
cl_int CL_API_CALL clReleaseSampler (cl_sampler sampler) {
 
182
        if(!clReleaseSampler_ptr) clReleaseSampler_ptr = getFunction("clReleaseSampler");
 
183
        return (*clReleaseSampler_ptr)(sampler);
 
184
}
 
185
 
 
186
static cl_int (*clGetSamplerInfo_ptr)(cl_sampler, cl_sampler_info, size_t, void *, size_t *) = NULL;
 
187
cl_int CL_API_CALL clGetSamplerInfo (cl_sampler sampler,cl_sampler_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret) {
 
188
        if(!clGetSamplerInfo_ptr) clGetSamplerInfo_ptr = getFunction("clGetSamplerInfo");
 
189
        return (*clGetSamplerInfo_ptr)(sampler, param_name, param_value_size, param_value, param_value_size_ret);
 
190
}
 
191
 
 
192
static cl_program (*clCreateProgramWithSource_ptr)(cl_context, cl_uint, const char **, const size_t *, cl_int *) = NULL;
 
193
cl_program CL_API_CALL clCreateProgramWithSource (cl_context context,cl_uint count,const char ** strings,const size_t * lengths,cl_int * errcode_ret) {
 
194
        if(!clCreateProgramWithSource_ptr) clCreateProgramWithSource_ptr = getFunction("clCreateProgramWithSource");
 
195
        return (*clCreateProgramWithSource_ptr)(context, count, strings, lengths, errcode_ret);
 
196
}
 
197
 
 
198
static cl_program (*clCreateProgramWithBinary_ptr)(cl_context, cl_uint, const cl_device_id *, const size_t *, const unsigned char **, cl_int *, cl_int *) = NULL;
 
199
cl_program CL_API_CALL 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) {
 
200
        if(!clCreateProgramWithBinary_ptr) clCreateProgramWithBinary_ptr = getFunction("clCreateProgramWithBinary");
 
201
        return (*clCreateProgramWithBinary_ptr)(context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret);
 
202
}
 
203
 
 
204
static cl_program (*clCreateProgramWithBuiltInKernels_ptr)(cl_context, cl_uint, const cl_device_id *, const char *, cl_int *) = NULL;
 
205
cl_program CL_API_CALL clCreateProgramWithBuiltInKernels (cl_context context,cl_uint num_devices,const cl_device_id * device_list,const char * kernel_names,cl_int * errcode_ret) {
 
206
        if(!clCreateProgramWithBuiltInKernels_ptr) clCreateProgramWithBuiltInKernels_ptr = getFunction("clCreateProgramWithBuiltInKernels");
 
207
        return (*clCreateProgramWithBuiltInKernels_ptr)(context, num_devices, device_list, kernel_names, errcode_ret);
 
208
}
 
209
 
 
210
static cl_int (*clRetainProgram_ptr)(cl_program) = NULL;
 
211
cl_int CL_API_CALL clRetainProgram (cl_program program) {
 
212
        if(!clRetainProgram_ptr) clRetainProgram_ptr = getFunction("clRetainProgram");
 
213
        return (*clRetainProgram_ptr)(program);
 
214
}
 
215
 
 
216
static cl_int (*clReleaseProgram_ptr)(cl_program) = NULL;
 
217
cl_int CL_API_CALL clReleaseProgram (cl_program program) {
 
218
        if(!clReleaseProgram_ptr) clReleaseProgram_ptr = getFunction("clReleaseProgram");
 
219
        return (*clReleaseProgram_ptr)(program);
 
220
}
 
221
 
 
222
static cl_int (*clBuildProgram_ptr)(cl_program, cl_uint, const cl_device_id *, const char *, void (CL_CALLBACK *  /* pfn_notify */)(cl_program /* program */, void * /* user_data */), void *) = NULL;
 
223
cl_int CL_API_CALL clBuildProgram (cl_program program,cl_uint num_devices,const cl_device_id * device_list,const char * options, void (CL_CALLBACK * pfn_notify)(cl_program /* program */, void * /* user_data */),void * user_data) {
 
224
        if(!clBuildProgram_ptr) clBuildProgram_ptr = getFunction("clBuildProgram");
 
225
        return (*clBuildProgram_ptr)(program, num_devices, device_list, options, user_data, user_data);
 
226
}
 
227
 
 
228
static cl_int (*clCompileProgram_ptr)(cl_program, cl_uint, const cl_device_id *, const char *, cl_uint, const cl_program *, const char **, void (CL_CALLBACK *  /* pfn_notify */)(cl_program /* program */, void * /* user_data */), void *) = NULL;
 
229
cl_int CL_API_CALL clCompileProgram (cl_program program,cl_uint num_devices,const cl_device_id * device_list,const char * options,cl_uint num_input_headers,const cl_program * input_headers,const char ** header_include_names,void (CL_CALLBACK *  pfn_notify)(cl_program /* program */, void * /* user_data */),void * user_data) {
 
230
        if(!clCompileProgram_ptr) clCompileProgram_ptr = getFunction("clCompileProgram");
 
231
        return (*clCompileProgram_ptr)(program, num_devices, device_list, options, num_input_headers, input_headers, header_include_names, user_data, user_data);
 
232
}
 
233
 
 
234
static cl_program (*clLinkProgram_ptr)(cl_context, cl_uint, const cl_device_id *, const char *, cl_uint, const cl_program *, void (CL_CALLBACK *  /* pfn_notify */)(cl_program /* program */, void * /* user_data */), void *, cl_int *) = NULL;
 
235
cl_program CL_API_CALL clLinkProgram (cl_context context,cl_uint num_devices,const cl_device_id * device_list,const char * options,cl_uint num_input_programs,const cl_program * input_programs,void (CL_CALLBACK * pfn_notify)(cl_program /* program */, void * /* user_data */),void * user_data,cl_int * errcode_ret) {
 
236
        if(!clLinkProgram_ptr) clLinkProgram_ptr = getFunction("clLinkProgram");
 
237
        return (*clLinkProgram_ptr)(context, num_devices, device_list, options, num_input_programs, input_programs, user_data, user_data, errcode_ret);
 
238
}
 
239
 
 
240
static cl_int (*clUnloadPlatformCompiler_ptr)(cl_platform_id) = NULL;
 
241
cl_int CL_API_CALL clUnloadPlatformCompiler (cl_platform_id platform) {
 
242
        if(!clUnloadPlatformCompiler_ptr) clUnloadPlatformCompiler_ptr = getFunction("clUnloadPlatformCompiler");
 
243
        return (*clUnloadPlatformCompiler_ptr)(platform);
 
244
}
 
245
 
 
246
static cl_int (*clGetProgramInfo_ptr)(cl_program, cl_program_info, size_t, void *, size_t *) = NULL;
 
247
cl_int CL_API_CALL clGetProgramInfo (cl_program program,cl_program_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret) {
 
248
        if(!clGetProgramInfo_ptr) clGetProgramInfo_ptr = getFunction("clGetProgramInfo");
 
249
        return (*clGetProgramInfo_ptr)(program, param_name, param_value_size, param_value, param_value_size_ret);
 
250
}
 
251
 
 
252
static cl_int (*clGetProgramBuildInfo_ptr)(cl_program, cl_device_id, cl_program_build_info, size_t, void *, size_t *) = NULL;
 
253
cl_int CL_API_CALL 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) {
 
254
        if(!clGetProgramBuildInfo_ptr) clGetProgramBuildInfo_ptr = getFunction("clGetProgramBuildInfo");
 
255
        return (*clGetProgramBuildInfo_ptr)(program, device, param_name, param_value_size, param_value, param_value_size_ret);
 
256
}
 
257
 
 
258
static cl_kernel (*clCreateKernel_ptr)(cl_program, const char *, cl_int *) = NULL;
 
259
cl_kernel CL_API_CALL clCreateKernel (cl_program program,const char * kernel_name,cl_int * errcode_ret) {
 
260
        if(!clCreateKernel_ptr) clCreateKernel_ptr = getFunction("clCreateKernel");
 
261
        return (*clCreateKernel_ptr)(program, kernel_name, errcode_ret);
 
262
}
 
263
 
 
264
static cl_int (*clCreateKernelsInProgram_ptr)(cl_program, cl_uint, cl_kernel *, cl_uint *) = NULL;
 
265
cl_int CL_API_CALL clCreateKernelsInProgram (cl_program program,cl_uint num_kernels,cl_kernel * kernels,cl_uint * num_kernels_ret) {
 
266
        if(!clCreateKernelsInProgram_ptr) clCreateKernelsInProgram_ptr = getFunction("clCreateKernelsInProgram");
 
267
        return (*clCreateKernelsInProgram_ptr)(program, num_kernels, kernels, num_kernels_ret);
 
268
}
 
269
 
 
270
static cl_int (*clRetainKernel_ptr)(cl_kernel) = NULL;
 
271
cl_int CL_API_CALL clRetainKernel (cl_kernel kernel) {
 
272
        if(!clRetainKernel_ptr) clRetainKernel_ptr = getFunction("clRetainKernel");
 
273
        return (*clRetainKernel_ptr)(kernel);
 
274
}
 
275
 
 
276
static cl_int (*clReleaseKernel_ptr)(cl_kernel) = NULL;
 
277
cl_int CL_API_CALL clReleaseKernel (cl_kernel kernel) {
 
278
        if(!clReleaseKernel_ptr) clReleaseKernel_ptr = getFunction("clReleaseKernel");
 
279
        return (*clReleaseKernel_ptr)(kernel);
 
280
}
 
281
 
 
282
static cl_int (*clSetKernelArg_ptr)(cl_kernel, cl_uint, size_t, const void *) = NULL;
 
283
cl_int CL_API_CALL clSetKernelArg (cl_kernel kernel,cl_uint arg_index,size_t arg_size,const void * arg_value) {
 
284
        if(!clSetKernelArg_ptr) clSetKernelArg_ptr = getFunction("clSetKernelArg");
 
285
        return (*clSetKernelArg_ptr)(kernel, arg_index, arg_size, arg_value);
 
286
}
 
287
 
 
288
static cl_int (*clGetKernelInfo_ptr)(cl_kernel, cl_kernel_info, size_t, void *, size_t *) = NULL;
 
289
cl_int CL_API_CALL clGetKernelInfo (cl_kernel kernel,cl_kernel_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret) {
 
290
        if(!clGetKernelInfo_ptr) clGetKernelInfo_ptr = getFunction("clGetKernelInfo");
 
291
        return (*clGetKernelInfo_ptr)(kernel, param_name, param_value_size, param_value, param_value_size_ret);
 
292
}
 
293
 
 
294
static cl_int (*clGetKernelArgInfo_ptr)(cl_kernel, cl_uint, cl_kernel_arg_info, size_t, void *, size_t *) = NULL;
 
295
cl_int CL_API_CALL clGetKernelArgInfo (cl_kernel kernel,cl_uint arg_indx,cl_kernel_arg_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret) {
 
296
        if(!clGetKernelArgInfo_ptr) clGetKernelArgInfo_ptr = getFunction("clGetKernelArgInfo");
 
297
        return (*clGetKernelArgInfo_ptr)(kernel, arg_indx, param_name, param_value_size, param_value, param_value_size_ret);
 
298
}
 
299
 
 
300
static cl_int (*clGetKernelWorkGroupInfo_ptr)(cl_kernel, cl_device_id, cl_kernel_work_group_info, size_t, void *, size_t *) = NULL;
 
301
cl_int CL_API_CALL 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) {
 
302
        if(!clGetKernelWorkGroupInfo_ptr) clGetKernelWorkGroupInfo_ptr = getFunction("clGetKernelWorkGroupInfo");
 
303
        return (*clGetKernelWorkGroupInfo_ptr)(kernel, device, param_name, param_value_size, param_value, param_value_size_ret);
 
304
}
 
305
 
 
306
static cl_int (*clWaitForEvents_ptr)(cl_uint, const cl_event *) = NULL;
 
307
cl_int CL_API_CALL clWaitForEvents (cl_uint num_events,const cl_event * event_list) {
 
308
        if(!clWaitForEvents_ptr) clWaitForEvents_ptr = getFunction("clWaitForEvents");
 
309
        return (*clWaitForEvents_ptr)(num_events, event_list);
 
310
}
 
311
 
 
312
static cl_int (*clGetEventInfo_ptr)(cl_event, cl_event_info, size_t, void *, size_t *) = NULL;
 
313
cl_int CL_API_CALL clGetEventInfo (cl_event event,cl_event_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret) {
 
314
        if(!clGetEventInfo_ptr) clGetEventInfo_ptr = getFunction("clGetEventInfo");
 
315
        return (*clGetEventInfo_ptr)(event, param_name, param_value_size, param_value, param_value_size_ret);
 
316
}
 
317
 
 
318
static cl_event (*clCreateUserEvent_ptr)(cl_context, cl_int *      /* errcode_ret */) = NULL;                                         
 
319
cl_event CL_API_CALL clCreateUserEvent (cl_context context,cl_int *     errcode_ret)
 
320
{
 
321
        if(!clCreateUserEvent_ptr) clCreateUserEvent_ptr = getFunction("clCreateUserEvent");
 
322
        return (*clCreateUserEvent_ptr)(context,errcode_ret);
 
323
}             
 
324
 
 
325
static cl_int (*clRetainEvent_ptr)(cl_event) = NULL;
 
326
cl_int CL_API_CALL clRetainEvent(cl_event event) {
 
327
        if(!clRetainEvent_ptr) clRetainEvent_ptr = getFunction("clRetainEvent");
 
328
        return (*clRetainEvent_ptr)(event);
 
329
}
 
330
 
 
331
static cl_int (*clReleaseEvent_ptr)(cl_event) = NULL;
 
332
cl_int CL_API_CALL clReleaseEvent (cl_event event) {
 
333
        if(!clReleaseEvent_ptr) clReleaseEvent_ptr = getFunction("clReleaseEvent");
 
334
        return (*clReleaseEvent_ptr)(event);
 
335
}
 
336
 
 
337
static cl_int (*clSetUserEventStatus_ptr)(cl_event, cl_int) = NULL;
 
338
cl_int CL_API_CALL clSetUserEventStatus (cl_event event,cl_int execution_status) {
 
339
        if(!clSetUserEventStatus_ptr) clSetUserEventStatus_ptr = getFunction("clSetUserEventStatus");
 
340
        return (*clSetUserEventStatus_ptr)(event, execution_status);
 
341
}
 
342
 
 
343
static cl_int (*clSetEventCallback_ptr)(cl_event, cl_int, void (CL_CALLBACK * /* pfn_notify */)(cl_event, cl_int, void *), void*) = NULL;
 
344
cl_int CL_API_CALL clSetEventCallback (cl_event event,cl_int command_exec_callback_type, void (CL_CALLBACK * pfn_notify)(cl_event, cl_int, void *), void* user_data) {
 
345
        if(!clSetEventCallback_ptr) clSetEventCallback_ptr = getFunction("clSetEventCallback");
 
346
        return (*clSetEventCallback_ptr)(event, command_exec_callback_type, pfn_notify, user_data);
 
347
}
 
348
 
 
349
static cl_int (*clGetEventProfilingInfo_ptr)(cl_event, cl_profiling_info, size_t, void *, size_t *) = NULL;
 
350
cl_int CL_API_CALL clGetEventProfilingInfo (cl_event event,cl_profiling_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret) {
 
351
        if(!clGetEventProfilingInfo_ptr) clGetEventProfilingInfo_ptr = getFunction("clGetEventProfilingInfo");
 
352
        return (*clGetEventProfilingInfo_ptr)(event, param_name, param_value_size, param_value, param_value_size_ret);
 
353
}
 
354
 
 
355
static cl_int (*clFlush_ptr)(cl_command_queue) = NULL;
 
356
cl_int CL_API_CALL clFlush (cl_command_queue command_queue) {
 
357
        if(!clFlush_ptr) clFlush_ptr = getFunction("clFlush");
 
358
        return (*clFlush_ptr)(command_queue);
 
359
}
 
360
 
 
361
static cl_int (*clFinish_ptr)(cl_command_queue) = NULL;
 
362
cl_int CL_API_CALL clFinish (cl_command_queue command_queue) {
 
363
        if(!clFinish_ptr) clFinish_ptr = getFunction("clFinish");
 
364
        return (*clFinish_ptr)(command_queue);
 
365
}
 
366
 
 
367
static cl_int (*clEnqueueReadBuffer_ptr)(cl_command_queue, cl_mem, cl_bool, size_t, size_t, void *, cl_uint, const cl_event *, cl_event *) = NULL;
 
368
cl_int CL_API_CALL 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) {
 
369
        if(!clEnqueueReadBuffer_ptr) clEnqueueReadBuffer_ptr = getFunction("clEnqueueReadBuffer");
 
370
        return (*clEnqueueReadBuffer_ptr)(command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event);
 
371
}
 
372
 
 
373
static cl_int (*clEnqueueReadBufferRect_ptr)(cl_command_queue, cl_mem, cl_bool, const size_t *, const size_t *, const size_t *, size_t, size_t, size_t, size_t, void *, cl_uint, const cl_event *, cl_event *) = NULL;
 
374
cl_int CL_API_CALL clEnqueueReadBufferRect (cl_command_queue command_queue,cl_mem buffer,cl_bool blocking_read,const size_t * buffer_offset,const size_t * host_offset,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) {
 
375
        if(!clEnqueueReadBufferRect_ptr) clEnqueueReadBufferRect_ptr = getFunction("clEnqueueReadBufferRect");
 
376
        return (*clEnqueueReadBufferRect_ptr)(command_queue, buffer, blocking_read, buffer_offset, host_offset, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event);
 
377
}
 
378
 
 
379
static cl_int (*clEnqueueWriteBuffer_ptr)(cl_command_queue, cl_mem, cl_bool, size_t, size_t, const void *, cl_uint, const cl_event *, cl_event *) = NULL;
 
380
cl_int CL_API_CALL 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) {
 
381
        if(!clEnqueueWriteBuffer_ptr) clEnqueueWriteBuffer_ptr = getFunction("clEnqueueWriteBuffer");
 
382
        return (*clEnqueueWriteBuffer_ptr)(command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, event);
 
383
}
 
384
 
 
385
static cl_int (*clEnqueueWriteBufferRect_ptr)(cl_command_queue, cl_mem, cl_bool, const size_t *, const size_t *, const size_t *, size_t, size_t, size_t, size_t, const void *, cl_uint, const cl_event *, cl_event *) = NULL;
 
386
cl_int CL_API_CALL clEnqueueWriteBufferRect (cl_command_queue command_queue,cl_mem buffer,cl_bool blocking_write,const size_t * buffer_offset,const size_t * host_offset,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) {
 
387
        if(!clEnqueueWriteBufferRect_ptr) clEnqueueWriteBufferRect_ptr = getFunction("clEnqueueWriteBufferRect");
 
388
        return (*clEnqueueWriteBufferRect_ptr)(command_queue, buffer, blocking_write, buffer_offset, host_offset, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event);
 
389
}
 
390
 
 
391
static cl_int (*clEnqueueFillBuffer_ptr)(cl_command_queue, cl_mem, const void *, size_t, size_t, size_t, cl_uint, const cl_event *, cl_event *) = NULL;
 
392
cl_int CL_API_CALL 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) {
 
393
        if(!clEnqueueFillBuffer_ptr) clEnqueueFillBuffer_ptr = getFunction("clEnqueueFillBuffer");
 
394
        return (*clEnqueueFillBuffer_ptr)(command_queue, buffer, pattern, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, event);
 
395
}
 
396
 
 
397
static cl_int (*clEnqueueCopyBuffer_ptr)(cl_command_queue, cl_mem, cl_mem, size_t, size_t, size_t, cl_uint, const cl_event *, cl_event *) = NULL;
 
398
cl_int CL_API_CALL 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) {
 
399
        if(!clEnqueueCopyBuffer_ptr) clEnqueueCopyBuffer_ptr = getFunction("clEnqueueCopyBuffer");
 
400
        return (*clEnqueueCopyBuffer_ptr)(command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, event);
 
401
}
 
402
 
 
403
static cl_int (*clEnqueueCopyBufferRect_ptr)(cl_command_queue, cl_mem, cl_mem, const size_t *, const size_t *, const size_t *, size_t, size_t, size_t, size_t, cl_uint, const cl_event *, cl_event *) = NULL;
 
404
cl_int CL_API_CALL 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) {
 
405
        if(!clEnqueueCopyBufferRect_ptr) clEnqueueCopyBufferRect_ptr = getFunction("clEnqueueCopyBufferRect");
 
406
        return (*clEnqueueCopyBufferRect_ptr)(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);
 
407
}
 
408
 
 
409
static cl_int (*clEnqueueReadImage_ptr)(cl_command_queue, cl_mem, cl_bool, const size_t *, const size_t *, size_t, size_t, void *, cl_uint, const cl_event *, cl_event *) = NULL;
 
410
cl_int CL_API_CALL 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) {
 
411
        if(!clEnqueueReadImage_ptr) clEnqueueReadImage_ptr = getFunction("clEnqueueReadImage");
 
412
        return (*clEnqueueReadImage_ptr)(command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event);
 
413
}
 
414
 
 
415
static cl_int (*clEnqueueWriteImage_ptr)(cl_command_queue, cl_mem, cl_bool, const size_t *, const size_t *, size_t, size_t, const void *, cl_uint, const cl_event *, cl_event *) = NULL;
 
416
cl_int CL_API_CALL 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) {
 
417
        if(!clEnqueueWriteImage_ptr) clEnqueueWriteImage_ptr = getFunction("clEnqueueWriteImage");
 
418
        return (*clEnqueueWriteImage_ptr)(command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event);
 
419
}
 
420
 
 
421
static cl_int (*clEnqueueFillImage_ptr)(cl_command_queue, cl_mem, const void *, const size_t *, const size_t *, cl_uint, const cl_event *, cl_event *) = NULL;
 
422
cl_int CL_API_CALL 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) {
 
423
        if(!clEnqueueFillImage_ptr) clEnqueueFillImage_ptr = getFunction("clEnqueueFillImage");
 
424
        return (*clEnqueueFillImage_ptr)(command_queue, image, fill_color, origin, region, num_events_in_wait_list, event_wait_list, event);
 
425
}
 
426
 
 
427
static cl_int (*clEnqueueCopyImage_ptr)(cl_command_queue, cl_mem, cl_mem, const size_t *, const size_t *, const size_t *, cl_uint, const cl_event *, cl_event *) = NULL;
 
428
cl_int CL_API_CALL 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) {
 
429
        if(!clEnqueueCopyImage_ptr) clEnqueueCopyImage_ptr = getFunction("clEnqueueCopyImage");
 
430
        return (*clEnqueueCopyImage_ptr)(command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event);
 
431
}
 
432
 
 
433
static cl_int (*clEnqueueCopyImageToBuffer_ptr)(cl_command_queue, cl_mem, cl_mem, const size_t *, const size_t *, size_t, cl_uint, const cl_event *, cl_event *) = NULL;
 
434
cl_int CL_API_CALL 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) {
 
435
        if(!clEnqueueCopyImageToBuffer_ptr) clEnqueueCopyImageToBuffer_ptr = getFunction("clEnqueueCopyImageToBuffer");
 
436
        return (*clEnqueueCopyImageToBuffer_ptr)(command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event);
 
437
}
 
438
 
 
439
static cl_int (*clEnqueueCopyBufferToImage_ptr)(cl_command_queue, cl_mem, cl_mem, size_t, const size_t *, const size_t *, cl_uint, const cl_event *, cl_event *) = NULL;
 
440
cl_int CL_API_CALL 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) {
 
441
        if(!clEnqueueCopyBufferToImage_ptr) clEnqueueCopyBufferToImage_ptr = getFunction("clEnqueueCopyBufferToImage");
 
442
        return (*clEnqueueCopyBufferToImage_ptr)(command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event);
 
443
}
 
444
 
 
445
static void * (*clEnqueueMapBuffer_ptr)(cl_command_queue, cl_mem, cl_bool, cl_map_flags, size_t, size_t, cl_uint, const cl_event *, cl_event *, cl_int *) = NULL;
 
446
void * CL_API_CALL 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) {
 
447
        if(!clEnqueueMapBuffer_ptr) clEnqueueMapBuffer_ptr = getFunction("clEnqueueMapBuffer");
 
448
        return (*clEnqueueMapBuffer_ptr)(command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list, event, errcode_ret);
 
449
}
 
450
 
 
451
static void * (*clEnqueueMapImage_ptr)(cl_command_queue, cl_mem, cl_bool, cl_map_flags, const size_t *, const size_t *, size_t *, size_t *, cl_uint, const cl_event *, cl_event *, cl_int *) = NULL;
 
452
void * CL_API_CALL 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) {
 
453
        if(!clEnqueueMapImage_ptr) clEnqueueMapImage_ptr = getFunction("clEnqueueMapImage");
 
454
        return (*clEnqueueMapImage_ptr)(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);
 
455
}
 
456
 
 
457
static cl_int (*clEnqueueUnmapMemObject_ptr)(cl_command_queue, cl_mem, void *, cl_uint, const cl_event *, cl_event *) = NULL;
 
458
cl_int CL_API_CALL 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) {
 
459
        if(!clEnqueueUnmapMemObject_ptr) clEnqueueUnmapMemObject_ptr = getFunction("clEnqueueUnmapMemObject");
 
460
        return (*clEnqueueUnmapMemObject_ptr)(command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event);
 
461
}
 
462
 
 
463
static cl_int (*clEnqueueMigrateMemObjects_ptr)(cl_command_queue, cl_uint, const cl_mem *, cl_mem_migration_flags, cl_uint, const cl_event *, cl_event *) = NULL;
 
464
cl_int CL_API_CALL 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) {
 
465
        if(!clEnqueueMigrateMemObjects_ptr) clEnqueueMigrateMemObjects_ptr = getFunction("clEnqueueMigrateMemObjects");
 
466
        return (*clEnqueueMigrateMemObjects_ptr)(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, event);
 
467
}
 
468
 
 
469
static cl_int (*clEnqueueNDRangeKernel_ptr)(cl_command_queue, cl_kernel, cl_uint, const size_t *, const size_t *, const size_t *, cl_uint, const cl_event *, cl_event *) = NULL;
 
470
cl_int CL_API_CALL 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) {
 
471
        if(!clEnqueueNDRangeKernel_ptr) clEnqueueNDRangeKernel_ptr = getFunction("clEnqueueNDRangeKernel");
 
472
        return (*clEnqueueNDRangeKernel_ptr)(command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event);
 
473
}
 
474
 
 
475
static cl_int (*clEnqueueTask_ptr)(cl_command_queue, cl_kernel, cl_uint, const cl_event *, cl_event *) = NULL;
 
476
cl_int CL_API_CALL 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) {
 
477
        if(!clEnqueueTask_ptr) clEnqueueTask_ptr = getFunction("clEnqueueTask");
 
478
        return (*clEnqueueTask_ptr)(command_queue, kernel, num_events_in_wait_list, event_wait_list, event);
 
479
}
 
480
 
 
481
static cl_int (*clEnqueueNativeKernel_ptr)(cl_command_queue, void (CL_CALLBACK * /*user_func*/)(void *), void *, size_t, cl_uint, const cl_mem *, const void **, cl_uint, const cl_event *, cl_event *) = NULL;
 
482
cl_int CL_API_CALL clEnqueueNativeKernel (cl_command_queue command_queue,void (CL_CALLBACK *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) {
 
483
        if(!clEnqueueNativeKernel_ptr) clEnqueueNativeKernel_ptr = getFunction("clEnqueueNativeKernel");
 
484
        return (*clEnqueueNativeKernel_ptr)(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, event);
 
485
}
 
486
 
 
487
static cl_int (*clEnqueueMarkerWithWaitList_ptr)(cl_command_queue, cl_uint, const cl_event *, cl_event *) = NULL;
 
488
cl_int CL_API_CALL clEnqueueMarkerWithWaitList (cl_command_queue command_queue,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event) {
 
489
        if(!clEnqueueMarkerWithWaitList_ptr) clEnqueueMarkerWithWaitList_ptr = getFunction("clEnqueueMarkerWithWaitList");
 
490
        return (*clEnqueueMarkerWithWaitList_ptr)(command_queue, num_events_in_wait_list, event_wait_list, event);
 
491
}
 
492
 
 
493
static cl_int (*clEnqueueBarrierWithWaitList_ptr)(cl_command_queue, cl_uint, const cl_event *, cl_event *) = NULL;
 
494
cl_int CL_API_CALL clEnqueueBarrierWithWaitList (cl_command_queue command_queue,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event) {
 
495
        if(!clEnqueueBarrierWithWaitList_ptr) clEnqueueBarrierWithWaitList_ptr = getFunction("clEnqueueBarrierWithWaitList");
 
496
        return (*clEnqueueBarrierWithWaitList_ptr)(command_queue, num_events_in_wait_list, event_wait_list, event);
 
497
}
 
498
 
 
499
static void * (*clGetExtensionFunctionAddressForPlatform_ptr)(cl_platform_id, const char *) = NULL;
 
500
void * CL_API_CALL clGetExtensionFunctionAddressForPlatform (cl_platform_id platform,const char * func_name) {
 
501
        if(!clGetExtensionFunctionAddressForPlatform_ptr) clGetExtensionFunctionAddressForPlatform_ptr = getFunction("clGetExtensionFunctionAddressForPlatform");
 
502
        return (*clGetExtensionFunctionAddressForPlatform_ptr)(platform, func_name);
 
503
}
 
504
 
 
505
static CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_mem (*clCreateImage2D_ptr)(cl_context, cl_mem_flags, const cl_image_format *, size_t, size_t, size_t, void *, cl_int *) = NULL;
 
506
CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_mem CL_API_CALL 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) {
 
507
        if(!clCreateImage2D_ptr) clCreateImage2D_ptr = getFunction("clCreateImage2D");
 
508
        return (*clCreateImage2D_ptr)(context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret);
 
509
}
 
510
 
 
511
static CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_mem (*clCreateImage3D_ptr)(cl_context, cl_mem_flags, const cl_image_format *, size_t, size_t, size_t, size_t, size_t, void *, cl_int *) = NULL;
 
512
CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_mem CL_API_CALL 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) {
 
513
        if(!clCreateImage3D_ptr) clCreateImage3D_ptr = getFunction("clCreateImage3D");
 
514
        return (*clCreateImage3D_ptr)(context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret);
 
515
}
 
516
 
 
517
static CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_int (*clEnqueueMarker_ptr)(cl_command_queue, cl_event *) = NULL;
 
518
CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_int CL_API_CALL clEnqueueMarker (cl_command_queue command_queue,cl_event * event) {
 
519
        if(!clEnqueueMarker_ptr) clEnqueueMarker_ptr = getFunction("clEnqueueMarker");
 
520
        return (*clEnqueueMarker_ptr)(command_queue, event);
 
521
}
 
522
 
 
523
static CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_int (*clEnqueueWaitForEvents_ptr)(cl_command_queue, cl_uint, const cl_event *) = NULL;
 
524
CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_int CL_API_CALL clEnqueueWaitForEvents (cl_command_queue command_queue,cl_uint num_events,const cl_event * event_list) {
 
525
        if(!clEnqueueWaitForEvents_ptr) clEnqueueWaitForEvents_ptr = getFunction("clEnqueueWaitForEvents");
 
526
        return (*clEnqueueWaitForEvents_ptr)(command_queue, num_events, event_list);
 
527
}
 
528
 
 
529
static CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_int (*clEnqueueBarrier_ptr)(cl_command_queue) = NULL;
 
530
CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_int CL_API_CALL clEnqueueBarrier (cl_command_queue command_queue) {
 
531
        if(!clEnqueueBarrier_ptr) clEnqueueBarrier_ptr = getFunction("clEnqueueBarrier");
 
532
        return (*clEnqueueBarrier_ptr)(command_queue);
 
533
}
 
534
 
 
535
static CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_int (*clUnloadCompiler_ptr)(void) = NULL;
 
536
CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_int CL_API_CALL clUnloadCompiler (void) {
 
537
        if(!clUnloadCompiler_ptr) clUnloadCompiler_ptr = getFunction("clUnloadCompiler");
 
538
        return (*clUnloadCompiler_ptr)();
 
539
}
 
540
 
 
541
static CL_EXT_PREFIX__VERSION_1_1_DEPRECATED void * (*clGetExtensionFunctionAddress_ptr)(const char *) = NULL;
 
542
CL_EXT_PREFIX__VERSION_1_1_DEPRECATED void * CL_API_CALL clGetExtensionFunctionAddress (const char * func_name) {
 
543
        if(!clGetExtensionFunctionAddress_ptr) clGetExtensionFunctionAddress_ptr = getFunction("clGetExtensionFunctionAddress");
 
544
        return (*clGetExtensionFunctionAddress_ptr)(func_name);
 
545
}
 
546