loader/icd_dispatch.c

   1 /*
   2  * Copyright (c) 2012-2019 The Khronos Group Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  * OpenCL is a trademark of Apple Inc. used under license by Khronos.
  17  */
  18
  19 #include "icd_dispatch.h"
  20 #include "icd.h"
  21 #include <stdlib.h>
  22 #include <string.h>
  23
  24 // Platform APIs
  25 CL_API_ENTRY cl_int CL_API_CALL
  26 clGetPlatformIDs(cl_uint          num_entries,
  27                  cl_platform_id * platforms,
  28                  cl_uint *        num_platforms) CL_API_SUFFIX__VERSION_1_0
  29 {
  30     KHRicdVendor* vendor = NULL;
  31     cl_uint i;
  32
  33     // initialize the platforms (in case they have not been already)
  34     khrIcdInitialize();
  35
  36     if (!num_entries && platforms)
  37     {
  38         return CL_INVALID_VALUE;
  39     }
  40     if (!platforms && !num_platforms)
  41     {
  42         return CL_INVALID_VALUE;
  43     }
  44     // set num_platforms to 0 and set all platform pointers to NULL
  45     if (num_platforms)
  46     {
  47         *num_platforms = 0;
  48     }
  49     for (i = 0; i < num_entries && platforms; ++i)
  50     {
  51         platforms[i] = NULL;
  52     }
  53     // return error if we have no platforms
  54     if (!khrIcdVendors)
  55     {
  56         return CL_PLATFORM_NOT_FOUND_KHR;
  57     }
  58     // otherwise enumerate all platforms
  59     for (vendor = khrIcdVendors; vendor; vendor = vendor->next)
  60     {
  61         if (num_entries && platforms)
  62         {
  63             *(platforms++) = vendor->platform;
  64             --num_entries;
  65         }
  66         if (num_platforms)
  67         {
  68             ++(*num_platforms);
  69         }
  70     }
  71     return CL_SUCCESS;
  72 }
  73
  74 CL_API_ENTRY cl_int CL_API_CALL
  75 clGetPlatformInfo(cl_platform_id   platform,
  76                   cl_platform_info param_name,
  77                   size_t           param_value_size,
  78                   void *           param_value,
  79                   size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
  80 {
  81     // initialize the platforms (in case they have not been already)
  82     khrIcdInitialize();
  83     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
  84     return platform->dispatch->clGetPlatformInfo(
  85         platform,
  86         param_name,
  87         param_value_size,
  88         param_value,
  89         param_value_size_ret);
  90 }
  91
  92 // Device APIs
  93 CL_API_ENTRY cl_int CL_API_CALL
  94 clGetDeviceIDs(cl_platform_id   platform,
  95                cl_device_type   device_type,
  96                cl_uint          num_entries,
  97                cl_device_id *   devices,
  98                cl_uint *        num_devices) CL_API_SUFFIX__VERSION_1_0
  99 {
 100     // initialize the platforms (in case they have not been already)
 101     khrIcdInitialize();
 102
 103     // determine the platform to use from the device_type specified
 104     if (!platform)
 105     {
 106         khrIcdDeviceTypeGetPlatform(device_type, &platform);
 107     }
 108     if (!platform && khrIcdVendors != NULL)
 109     {
 110         platform = khrIcdVendors[0].platform;
 111     }
 112
 113     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
 114     return platform->dispatch->clGetDeviceIDs(
 115         platform,
 116         device_type,
 117         num_entries,
 118         devices,
 119         num_devices);
 120 }
 121
 122 CL_API_ENTRY cl_int CL_API_CALL
 123 clGetDeviceInfo(
 124     cl_device_id    device,
 125     cl_device_info  param_name,
 126     size_t          param_value_size,
 127     void *          param_value,
 128     size_t *        param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 129 {
 130     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
 131     return device->dispatch->clGetDeviceInfo(
 132         device,
 133         param_name,
 134         param_value_size,
 135         param_value,
 136         param_value_size_ret);
 137 }
 138
 139 CL_API_ENTRY cl_int CL_API_CALL
 140 clCreateSubDevices(cl_device_id                         in_device,
 141                    const cl_device_partition_property * properties,
 142                    cl_uint                              num_entries,
 143                    cl_device_id *                       out_devices,
 144                    cl_uint *                            num_devices) CL_API_SUFFIX__VERSION_1_2
 145 {
 146     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
 147     return in_device->dispatch->clCreateSubDevices(
 148         in_device,
 149         properties,
 150         num_entries,
 151         out_devices,
 152         num_devices);
 153 }
 154
 155 CL_API_ENTRY cl_int CL_API_CALL
 156 clRetainDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2
 157 {
 158     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
 159     return device->dispatch->clRetainDevice(device);
 160 }
 161
 162 CL_API_ENTRY cl_int CL_API_CALL
 163 clReleaseDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2
 164 {
 165     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
 166     return device->dispatch->clReleaseDevice(device);
 167 }
 168
 169 // Context APIs
 170 CL_API_ENTRY cl_context CL_API_CALL
 171 clCreateContext(const cl_context_properties * properties,
 172                 cl_uint                 num_devices,
 173                 const cl_device_id *    devices,
 174                 void (CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *),
 175                 void *                  user_data,
 176                 cl_int *                errcode_ret) CL_API_SUFFIX__VERSION_1_0
 177 {
 178     // initialize the platforms (in case they have not been already)
 179     khrIcdInitialize();
 180     if (!num_devices || !devices)
 181     {
 182         if (errcode_ret)
 183         {
 184             *errcode_ret = CL_INVALID_VALUE;
 185         }
 186         return NULL;
 187     }
 188     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(devices[0], CL_INVALID_DEVICE);
 189     return devices[0]->dispatch->clCreateContext(
 190         properties,
 191         num_devices,
 192         devices,
 193         pfn_notify,
 194         user_data,
 195         errcode_ret);
 196 }
 197
 198 CL_API_ENTRY cl_context CL_API_CALL
 199 clCreateContextFromType(const cl_context_properties * properties,
 200                         cl_device_type          device_type,
 201                         void (CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *),
 202                         void *                  user_data,
 203                         cl_int *                errcode_ret) CL_API_SUFFIX__VERSION_1_0
 204 {
 205     cl_platform_id platform = NULL;
 206
 207     // initialize the platforms (in case they have not been already)
 208     khrIcdInitialize();
 209
 210     // determine the platform to use from the properties and device_type specified
 211     khrIcdContextPropertiesGetPlatform(properties, &platform);
 212     if (!platform)
 213     {
 214         khrIcdDeviceTypeGetPlatform(device_type, &platform);
 215     }
 216     if (!platform && khrIcdVendors != NULL)
 217     {
 218         platform = khrIcdVendors[0].platform;
 219     }
 220
 221     // validate the platform handle and dispatch
 222     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(platform, CL_INVALID_PLATFORM);
 223     return platform->dispatch->clCreateContextFromType(
 224         properties,
 225         device_type,
 226         pfn_notify,
 227         user_data,
 228         errcode_ret);
 229 }
 230
 231 CL_API_ENTRY cl_int CL_API_CALL
 232 clRetainContext(cl_context context) CL_API_SUFFIX__VERSION_1_0
 233 {
 234     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
 235     return context->dispatch->clRetainContext(context);
 236 }
 237
 238 CL_API_ENTRY cl_int CL_API_CALL
 239 clReleaseContext(cl_context context) CL_API_SUFFIX__VERSION_1_0
 240 {
 241     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
 242     return context->dispatch->clReleaseContext(context);
 243 }
 244
 245 CL_API_ENTRY cl_int CL_API_CALL
 246 clGetContextInfo(cl_context         context,
 247                  cl_context_info    param_name,
 248                  size_t             param_value_size,
 249                  void *             param_value,
 250                  size_t *           param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 251 {
 252     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
 253     return context->dispatch->clGetContextInfo(
 254         context,
 255         param_name,
 256         param_value_size,
 257         param_value,
 258         param_value_size_ret);
 259 }
 260
 261 // Command Queue APIs
 262 CL_API_ENTRY cl_command_queue CL_API_CALL
 263 clCreateCommandQueue(cl_context                     context,
 264                      cl_device_id                   device,
 265                      cl_command_queue_properties    properties,
 266                      cl_int *                       errcode_ret) CL_API_SUFFIX__VERSION_1_0
 267 {
 268     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
 269     return context->dispatch->clCreateCommandQueue(
 270         context,
 271         device,
 272         properties,
 273         errcode_ret);
 274 }
 275
 276 CL_API_ENTRY cl_int CL_API_CALL
 277 clRetainCommandQueue(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
 278 {
 279     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 280     return command_queue->dispatch->clRetainCommandQueue(command_queue);
 281 }
 282
 283 CL_API_ENTRY cl_int CL_API_CALL
 284 clReleaseCommandQueue(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
 285 {
 286     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 287     return command_queue->dispatch->clReleaseCommandQueue(command_queue);
 288 }
 289
 290 CL_API_ENTRY cl_int CL_API_CALL
 291 clGetCommandQueueInfo(cl_command_queue      command_queue,
 292                       cl_command_queue_info param_name,
 293                       size_t                param_value_size,
 294                       void *                param_value,
 295                       size_t *              param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 296 {
 297     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 298     return command_queue->dispatch->clGetCommandQueueInfo(
 299         command_queue,
 300         param_name,
 301         param_value_size,
 302         param_value,
 303         param_value_size_ret);
 304 }
 305
 306 // Memory Object APIs
 307 CL_API_ENTRY cl_mem CL_API_CALL
 308 clCreateBuffer(cl_context   context,
 309                cl_mem_flags flags,
 310                size_t       size,
 311                void *       host_ptr,
 312                cl_int *     errcode_ret) CL_API_SUFFIX__VERSION_1_0
 313 {
 314     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
 315     return context->dispatch->clCreateBuffer(
 316         context,
 317         flags,
 318         size,
 319         host_ptr,
 320         errcode_ret);
 321 }
 322
 323 CL_API_ENTRY cl_mem CL_API_CALL
 324 clCreateImage(cl_context              context,
 325                             cl_mem_flags            flags,
 326                             const cl_image_format * image_format,
 327                             const cl_image_desc *   image_desc,
 328                             void *                  host_ptr,
 329                             cl_int *                errcode_ret) CL_API_SUFFIX__VERSION_1_2
 330 {
 331     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
 332     return context->dispatch->clCreateImage(
 333         context,
 334         flags,
 335         image_format,
 336         image_desc,
 337         host_ptr,
 338         errcode_ret);
 339 }
 340
 341 CL_API_ENTRY cl_int CL_API_CALL
 342 clRetainMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
 343 {
 344     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
 345     return memobj->dispatch->clRetainMemObject(memobj);
 346 }
 347
 348
 349 CL_API_ENTRY cl_int CL_API_CALL
 350 clReleaseMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
 351 {
 352     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
 353     return memobj->dispatch->clReleaseMemObject(memobj);
 354 }
 355
 356 CL_API_ENTRY cl_int CL_API_CALL
 357 clGetSupportedImageFormats(cl_context           context,
 358                            cl_mem_flags         flags,
 359                            cl_mem_object_type   image_type,
 360                            cl_uint              num_entries,
 361                            cl_image_format *    image_formats,
 362                            cl_uint *            num_image_formats) CL_API_SUFFIX__VERSION_1_0
 363 {
 364     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
 365     return context->dispatch->clGetSupportedImageFormats(
 366         context,
 367         flags,
 368         image_type,
 369         num_entries,
 370         image_formats,
 371         num_image_formats);
 372 }
 373
 374 CL_API_ENTRY cl_int CL_API_CALL
 375 clGetMemObjectInfo(cl_mem           memobj,
 376                    cl_mem_info      param_name,
 377                    size_t           param_value_size,
 378                    void *           param_value,
 379                    size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 380 {
 381     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
 382     return memobj->dispatch->clGetMemObjectInfo(
 383         memobj,
 384         param_name,
 385         param_value_size,
 386         param_value,
 387         param_value_size_ret);
 388 }
 389
 390 CL_API_ENTRY cl_int CL_API_CALL
 391 clGetImageInfo(cl_mem           image,
 392                cl_image_info    param_name,
 393                size_t           param_value_size,
 394                void *           param_value,
 395                size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 396 {
 397     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(image, CL_INVALID_MEM_OBJECT);
 398     return image->dispatch->clGetImageInfo(
 399         image,
 400         param_name,
 401         param_value_size,
 402         param_value,
 403         param_value_size_ret);
 404 }
 405
 406 // Sampler APIs
 407 CL_API_ENTRY cl_sampler CL_API_CALL
 408 clCreateSampler(cl_context          context,
 409                 cl_bool             normalized_coords,
 410                 cl_addressing_mode  addressing_mode,
 411                 cl_filter_mode      filter_mode,
 412                 cl_int *            errcode_ret) CL_API_SUFFIX__VERSION_1_0
 413 {
 414     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
 415     return context->dispatch->clCreateSampler(
 416         context,
 417         normalized_coords,
 418         addressing_mode,
 419         filter_mode,
 420         errcode_ret);
 421 }
 422
 423 CL_API_ENTRY cl_int CL_API_CALL
 424 clRetainSampler(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
 425 {
 426     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
 427     return sampler->dispatch->clRetainSampler(sampler);
 428 }
 429
 430 CL_API_ENTRY cl_int CL_API_CALL
 431 clReleaseSampler(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
 432 {
 433     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
 434     return sampler->dispatch->clReleaseSampler(sampler);
 435 }
 436
 437 CL_API_ENTRY cl_int CL_API_CALL
 438 clGetSamplerInfo(cl_sampler         sampler,
 439                  cl_sampler_info    param_name,
 440                  size_t             param_value_size,
 441                  void *             param_value,
 442                  size_t *           param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 443 {
 444     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
 445     return sampler->dispatch->clGetSamplerInfo(
 446         sampler,
 447         param_name,
 448         param_value_size,
 449         param_value,
 450         param_value_size_ret);
 451 }
 452
 453 // Program Object APIs
 454 CL_API_ENTRY cl_program CL_API_CALL
 455 clCreateProgramWithSource(cl_context        context,
 456                           cl_uint           count,
 457                           const char **     strings,
 458                           const size_t *    lengths,
 459                           cl_int *          errcode_ret) CL_API_SUFFIX__VERSION_1_0
 460 {
 461     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
 462     return context->dispatch->clCreateProgramWithSource(
 463         context,
 464         count,
 465         strings,
 466         lengths,
 467         errcode_ret);
 468 }
 469
 470 CL_API_ENTRY cl_program CL_API_CALL
 471 clCreateProgramWithBinary(cl_context                     context,
 472                           cl_uint                        num_devices,
 473                           const cl_device_id *           device_list,
 474                           const size_t *                 lengths,
 475                           const unsigned char **         binaries,
 476                           cl_int *                       binary_status,
 477                           cl_int *                       errcode_ret) CL_API_SUFFIX__VERSION_1_0
 478 {
 479     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
 480     return context->dispatch->clCreateProgramWithBinary(
 481         context,
 482         num_devices,
 483         device_list,
 484         lengths,
 485         binaries,
 486         binary_status,
 487         errcode_ret);
 488 }
 489
 490 CL_API_ENTRY cl_program CL_API_CALL
 491 clCreateProgramWithBuiltInKernels(cl_context            context,
 492                                   cl_uint               num_devices,
 493                                   const cl_device_id *  device_list,
 494                                   const char *          kernel_names,
 495                                   cl_int *              errcode_ret) CL_API_SUFFIX__VERSION_1_2
 496 {
 497     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
 498     return context->dispatch->clCreateProgramWithBuiltInKernels(
 499         context,
 500         num_devices,
 501         device_list,
 502         kernel_names,
 503         errcode_ret);
 504 }
 505
 506 CL_API_ENTRY cl_int CL_API_CALL
 507 clRetainProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0
 508 {
 509     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 510     return program->dispatch->clRetainProgram(program);
 511 }
 512
 513 CL_API_ENTRY cl_int CL_API_CALL
 514 clReleaseProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0
 515 {
 516     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 517     return program->dispatch->clReleaseProgram(program);
 518 }
 519
 520 CL_API_ENTRY cl_int CL_API_CALL
 521 clBuildProgram(cl_program           program,
 522                cl_uint              num_devices,
 523                const cl_device_id * device_list,
 524                const char *         options,
 525                void (CL_CALLBACK *pfn_notify)(cl_program program, void * user_data),
 526                void *               user_data) CL_API_SUFFIX__VERSION_1_0
 527 {
 528     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 529     return program->dispatch->clBuildProgram(
 530         program,
 531         num_devices,
 532         device_list,
 533         options,
 534         pfn_notify,
 535         user_data);
 536 }
 537
 538 CL_API_ENTRY cl_int CL_API_CALL
 539 clCompileProgram(cl_program           program,
 540                  cl_uint              num_devices,
 541                  const cl_device_id * device_list,
 542                  const char *         options,
 543                  cl_uint              num_input_headers,
 544                  const cl_program *   input_headers,
 545                  const char **        header_include_names,
 546                  void (CL_CALLBACK *  pfn_notify)(cl_program program, void * user_data),
 547                  void *               user_data) CL_API_SUFFIX__VERSION_1_2
 548 {
 549     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 550     return program->dispatch->clCompileProgram(
 551         program,
 552         num_devices,
 553         device_list,
 554         options,
 555         num_input_headers,
 556         input_headers,
 557         header_include_names,
 558         pfn_notify,
 559         user_data);
 560 }
 561
 562 CL_API_ENTRY cl_program CL_API_CALL
 563 clLinkProgram(cl_context           context,
 564               cl_uint              num_devices,
 565               const cl_device_id * device_list,
 566               const char *         options,
 567               cl_uint              num_input_programs,
 568               const cl_program *   input_programs,
 569               void (CL_CALLBACK *  pfn_notify)(cl_program program, void * user_data),
 570               void *               user_data,
 571               cl_int *             errcode_ret) CL_API_SUFFIX__VERSION_1_2
 572 {
 573     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
 574     return context->dispatch->clLinkProgram(
 575         context,
 576         num_devices,
 577         device_list,
 578         options,
 579         num_input_programs,
 580         input_programs,
 581         pfn_notify,
 582         user_data,
 583         errcode_ret);
 584 }
 585
 586 CL_API_ENTRY cl_int CL_API_CALL
 587 clSetProgramSpecializationConstant(cl_program  program,
 588                                    cl_uint     spec_id,
 589                                    size_t      spec_size,
 590                                    const void* spec_value) CL_API_SUFFIX__VERSION_2_2
 591 {
 592     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 593     return program->dispatch->clSetProgramSpecializationConstant(
 594         program,
 595         spec_id,
 596         spec_size,
 597         spec_value);
 598 }
 599
 600 CL_API_ENTRY cl_int CL_API_CALL
 601 clSetProgramReleaseCallback(cl_program  program,
 602                             void (CL_CALLBACK * pfn_notify)(cl_program program, void * user_data),
 603                             void *              user_data) CL_API_SUFFIX__VERSION_2_2
 604 {
 605     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 606     return program->dispatch->clSetProgramReleaseCallback(
 607         program,
 608         pfn_notify,
 609         user_data);
 610 }
 611
 612 CL_API_ENTRY cl_int CL_API_CALL
 613 clUnloadPlatformCompiler(cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2
 614 {
 615     // initialize the platforms (in case they have not been already)
 616     khrIcdInitialize();
 617     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
 618     return platform->dispatch->clUnloadPlatformCompiler(platform);
 619 }
 620
 621 CL_API_ENTRY cl_int CL_API_CALL
 622 clGetProgramInfo(cl_program         program,
 623                  cl_program_info    param_name,
 624                  size_t             param_value_size,
 625                  void *             param_value,
 626                  size_t *           param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 627 {
 628     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 629     return program->dispatch->clGetProgramInfo(
 630         program,
 631         param_name,
 632         param_value_size,
 633         param_value,
 634         param_value_size_ret);
 635 }
 636
 637 CL_API_ENTRY cl_int CL_API_CALL
 638 clGetProgramBuildInfo(cl_program            program,
 639                       cl_device_id          device,
 640                       cl_program_build_info param_name,
 641                       size_t                param_value_size,
 642                       void *                param_value,
 643                       size_t *              param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 644 {
 645     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 646     return program->dispatch->clGetProgramBuildInfo(
 647         program,
 648         device,
 649         param_name,
 650         param_value_size,
 651         param_value,
 652         param_value_size_ret);
 653 }
 654
 655 // Kernel Object APIs
 656 CL_API_ENTRY cl_kernel CL_API_CALL
 657 clCreateKernel(cl_program      program,
 658                const char *    kernel_name,
 659                cl_int *        errcode_ret) CL_API_SUFFIX__VERSION_1_0
 660 {
 661     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(program, CL_INVALID_PROGRAM);
 662     return program->dispatch->clCreateKernel(
 663         program,
 664         kernel_name,
 665         errcode_ret);
 666 }
 667
 668 CL_API_ENTRY cl_int CL_API_CALL
 669 clCreateKernelsInProgram(cl_program     program,
 670                          cl_uint        num_kernels,
 671                          cl_kernel *    kernels,
 672                          cl_uint *      num_kernels_ret) CL_API_SUFFIX__VERSION_1_0
 673 {
 674     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 675     return program->dispatch->clCreateKernelsInProgram(
 676         program,
 677         num_kernels,
 678         kernels,
 679         num_kernels_ret);
 680 }
 681
 682 CL_API_ENTRY cl_int CL_API_CALL
 683 clRetainKernel(cl_kernel    kernel) CL_API_SUFFIX__VERSION_1_0
 684 {
 685     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
 686     return kernel->dispatch->clRetainKernel(kernel);
 687 }
 688
 689 CL_API_ENTRY cl_int CL_API_CALL
 690 clReleaseKernel(cl_kernel   kernel) CL_API_SUFFIX__VERSION_1_0
 691 {
 692     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
 693     return kernel->dispatch->clReleaseKernel(kernel);
 694 }
 695
 696 CL_API_ENTRY cl_int CL_API_CALL
 697 clSetKernelArg(cl_kernel    kernel,
 698                cl_uint      arg_index,
 699                size_t       arg_size,
 700                const void * arg_value) CL_API_SUFFIX__VERSION_1_0
 701 {
 702     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
 703     return kernel->dispatch->clSetKernelArg(
 704         kernel,
 705         arg_index,
 706         arg_size,
 707         arg_value);
 708 }
 709
 710 CL_API_ENTRY cl_int CL_API_CALL
 711 clGetKernelInfo(cl_kernel       kernel,
 712                 cl_kernel_info  param_name,
 713                 size_t          param_value_size,
 714                 void *          param_value,
 715                 size_t *        param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 716 {
 717     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
 718     return kernel->dispatch->clGetKernelInfo(
 719         kernel,
 720         param_name,
 721         param_value_size,
 722         param_value,
 723         param_value_size_ret);
 724 }
 725
 726 CL_API_ENTRY cl_int CL_API_CALL
 727 clGetKernelArgInfo(cl_kernel       kernel,
 728                    cl_uint         arg_indx,
 729                    cl_kernel_arg_info  param_name,
 730                    size_t          param_value_size,
 731                    void *          param_value,
 732                    size_t *        param_value_size_ret) CL_API_SUFFIX__VERSION_1_2
 733 {
 734     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
 735     return kernel->dispatch->clGetKernelArgInfo(
 736         kernel,
 737         arg_indx,
 738         param_name,
 739         param_value_size,
 740         param_value,
 741         param_value_size_ret);
 742 }
 743
 744 CL_API_ENTRY cl_int CL_API_CALL
 745 clGetKernelWorkGroupInfo(cl_kernel                  kernel,
 746                          cl_device_id               device,
 747                          cl_kernel_work_group_info  param_name,
 748                          size_t                     param_value_size,
 749                          void *                     param_value,
 750                          size_t *                   param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 751 {
 752     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
 753     return kernel->dispatch->clGetKernelWorkGroupInfo(
 754         kernel,
 755         device,
 756         param_name,
 757         param_value_size,
 758         param_value,
 759         param_value_size_ret);
 760 }
 761
 762 // Event Object APIs
 763 CL_API_ENTRY cl_int CL_API_CALL
 764 clWaitForEvents(cl_uint             num_events,
 765                 const cl_event *    event_list) CL_API_SUFFIX__VERSION_1_0
 766 {
 767     if (!num_events || !event_list)
 768     {
 769         return CL_INVALID_VALUE;
 770     }
 771     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event_list[0], CL_INVALID_EVENT);
 772     return event_list[0]->dispatch->clWaitForEvents(
 773         num_events,
 774         event_list);
 775 }
 776
 777 CL_API_ENTRY cl_int CL_API_CALL
 778 clGetEventInfo(cl_event         event,
 779                cl_event_info    param_name,
 780                size_t           param_value_size,
 781                void *           param_value,
 782                size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 783 {
 784     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
 785     return event->dispatch->clGetEventInfo(
 786         event,
 787         param_name,
 788         param_value_size,
 789         param_value,
 790         param_value_size_ret);
 791 }
 792
 793 CL_API_ENTRY cl_int CL_API_CALL
 794 clRetainEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0
 795 {
 796     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
 797     return event->dispatch->clRetainEvent(event);
 798 }
 799
 800 CL_API_ENTRY cl_int CL_API_CALL
 801 clReleaseEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0
 802 {
 803     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
 804     return event->dispatch->clReleaseEvent(event);
 805 }
 806
 807 // Profiling APIs
 808 CL_API_ENTRY cl_int CL_API_CALL
 809 clGetEventProfilingInfo(cl_event            event,
 810                         cl_profiling_info   param_name,
 811                         size_t              param_value_size,
 812                         void *              param_value,
 813                         size_t *            param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 814 {
 815     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
 816     return event->dispatch->clGetEventProfilingInfo(
 817         event,
 818         param_name,
 819         param_value_size,
 820         param_value,
 821         param_value_size_ret);
 822 }
 823
 824 // Flush and Finish APIs
 825 CL_API_ENTRY cl_int CL_API_CALL
 826 clFlush(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
 827 {
 828     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 829     return command_queue->dispatch->clFlush(command_queue);
 830 }
 831
 832 CL_API_ENTRY cl_int CL_API_CALL
 833 clFinish(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
 834 {
 835     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 836     return command_queue->dispatch->clFinish(command_queue);
 837 }
 838
 839 // Enqueued Commands APIs
 840 CL_API_ENTRY cl_int CL_API_CALL
 841 clEnqueueReadBuffer(cl_command_queue    command_queue,
 842                     cl_mem              buffer,
 843                     cl_bool             blocking_read,
 844                     size_t              offset,
 845                     size_t              cb,
 846                     void *              ptr,
 847                     cl_uint             num_events_in_wait_list,
 848                     const cl_event *    event_wait_list,
 849                     cl_event *          event) CL_API_SUFFIX__VERSION_1_0
 850 {
 851     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 852     return command_queue->dispatch->clEnqueueReadBuffer(
 853         command_queue,
 854         buffer,
 855         blocking_read,
 856         offset,
 857         cb,
 858         ptr,
 859         num_events_in_wait_list,
 860         event_wait_list,
 861         event);
 862 }
 863
 864 CL_API_ENTRY cl_int CL_API_CALL
 865 clEnqueueReadBufferRect(
 866     cl_command_queue command_queue,
 867     cl_mem buffer,
 868     cl_bool blocking_read,
 869     const size_t * buffer_origin,
 870     const size_t * host_origin,
 871     const size_t * region,
 872     size_t buffer_row_pitch,
 873     size_t buffer_slice_pitch,
 874     size_t host_row_pitch,
 875     size_t host_slice_pitch,
 876     void * ptr,
 877     cl_uint num_events_in_wait_list,
 878     const cl_event * event_wait_list,
 879     cl_event * event) CL_API_SUFFIX__VERSION_1_1
 880 {
 881     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 882     return command_queue->dispatch->clEnqueueReadBufferRect(
 883         command_queue,
 884         buffer,
 885         blocking_read,
 886         buffer_origin,
 887         host_origin,
 888         region,
 889         buffer_row_pitch,
 890         buffer_slice_pitch,
 891         host_row_pitch,
 892         host_slice_pitch,
 893         ptr,
 894         num_events_in_wait_list,
 895         event_wait_list,
 896         event);
 897 }
 898
 899 CL_API_ENTRY cl_int CL_API_CALL
 900 clEnqueueWriteBuffer(cl_command_queue   command_queue,
 901                      cl_mem             buffer,
 902                      cl_bool            blocking_write,
 903                      size_t             offset,
 904                      size_t             cb,
 905                      const void *       ptr,
 906                      cl_uint            num_events_in_wait_list,
 907                      const cl_event *   event_wait_list,
 908                      cl_event *         event) CL_API_SUFFIX__VERSION_1_0
 909 {
 910     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 911     return command_queue->dispatch->clEnqueueWriteBuffer(
 912         command_queue,
 913         buffer,
 914         blocking_write,
 915         offset,
 916         cb,
 917         ptr,
 918         num_events_in_wait_list,
 919         event_wait_list,
 920         event);
 921 }
 922
 923 CL_API_ENTRY cl_int CL_API_CALL
 924 clEnqueueWriteBufferRect(
 925     cl_command_queue command_queue,
 926     cl_mem buffer,
 927     cl_bool blocking_read,
 928     const size_t * buffer_origin,
 929     const size_t * host_origin,
 930     const size_t * region,
 931     size_t buffer_row_pitch,
 932     size_t buffer_slice_pitch,
 933     size_t host_row_pitch,
 934     size_t host_slice_pitch,
 935     const void * ptr,
 936     cl_uint num_events_in_wait_list,
 937     const cl_event * event_wait_list,
 938     cl_event * event) CL_API_SUFFIX__VERSION_1_1
 939 {
 940     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 941     return command_queue->dispatch->clEnqueueWriteBufferRect(
 942         command_queue,
 943         buffer,
 944         blocking_read,
 945         buffer_origin,
 946         host_origin,
 947         region,
 948         buffer_row_pitch,
 949         buffer_slice_pitch,
 950         host_row_pitch,
 951         host_slice_pitch,
 952         ptr,
 953         num_events_in_wait_list,
 954         event_wait_list,
 955         event);
 956 }
 957
 958 CL_API_ENTRY cl_int CL_API_CALL
 959 clEnqueueFillBuffer(cl_command_queue   command_queue,
 960                     cl_mem             buffer,
 961                     const void *       pattern,
 962                     size_t             pattern_size,
 963                     size_t             offset,
 964                     size_t             cb,
 965                     cl_uint            num_events_in_wait_list,
 966                     const cl_event *   event_wait_list,
 967                     cl_event *         event) CL_API_SUFFIX__VERSION_1_2
 968 {
 969     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 970     return command_queue->dispatch->clEnqueueFillBuffer(
 971         command_queue,
 972         buffer,
 973         pattern,
 974         pattern_size,
 975         offset,
 976         cb,
 977         num_events_in_wait_list,
 978         event_wait_list,
 979         event);
 980 }
 981
 982 CL_API_ENTRY cl_int CL_API_CALL
 983 clEnqueueCopyBuffer(cl_command_queue    command_queue,
 984                     cl_mem              src_buffer,
 985                     cl_mem              dst_buffer,
 986                     size_t              src_offset,
 987                     size_t              dst_offset,
 988                     size_t              cb,
 989                     cl_uint             num_events_in_wait_list,
 990                     const cl_event *    event_wait_list,
 991                     cl_event *          event) CL_API_SUFFIX__VERSION_1_0
 992 {
 993     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 994     return command_queue->dispatch->clEnqueueCopyBuffer(
 995         command_queue,
 996         src_buffer,
 997         dst_buffer,
 998         src_offset,
 999         dst_offset,
1000         cb,
1001         num_events_in_wait_list,
1002         event_wait_list,
1003         event);
1004 }
1005
1006 CL_API_ENTRY cl_int CL_API_CALL
1007 clEnqueueCopyBufferRect(
1008     cl_command_queue command_queue,
1009     cl_mem src_buffer,
1010     cl_mem dst_buffer,
1011     const size_t * src_origin,
1012     const size_t * dst_origin,
1013     const size_t * region,
1014     size_t src_row_pitch,
1015     size_t src_slice_pitch,
1016     size_t dst_row_pitch,
1017     size_t dst_slice_pitch,
1018     cl_uint num_events_in_wait_list,
1019     const cl_event * event_wait_list,
1020     cl_event * event) CL_API_SUFFIX__VERSION_1_1
1021 {
1022     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1023     return command_queue->dispatch->clEnqueueCopyBufferRect(
1024         command_queue,
1025         src_buffer,
1026         dst_buffer,
1027         src_origin,
1028         dst_origin,
1029         region,
1030         src_row_pitch,
1031         src_slice_pitch,
1032         dst_row_pitch,
1033         dst_slice_pitch,
1034         num_events_in_wait_list,
1035         event_wait_list,
1036         event);
1037 }
1038
1039 CL_API_ENTRY cl_int CL_API_CALL
1040 clEnqueueReadImage(cl_command_queue     command_queue,
1041                    cl_mem               image,
1042                    cl_bool              blocking_read,
1043                    const size_t *       origin,
1044                    const size_t *       region,
1045                    size_t               row_pitch,
1046                    size_t               slice_pitch,
1047                    void *               ptr,
1048                    cl_uint              num_events_in_wait_list,
1049                    const cl_event *     event_wait_list,
1050                    cl_event *           event) CL_API_SUFFIX__VERSION_1_0
1051 {
1052     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1053     return command_queue->dispatch->clEnqueueReadImage(
1054         command_queue,
1055         image,
1056         blocking_read,
1057         origin,
1058         region,
1059         row_pitch,
1060         slice_pitch,
1061         ptr,
1062         num_events_in_wait_list,
1063         event_wait_list,
1064         event);
1065 }
1066
1067 CL_API_ENTRY cl_int CL_API_CALL
1068 clEnqueueWriteImage(cl_command_queue    command_queue,
1069                     cl_mem              image,
1070                     cl_bool             blocking_write,
1071                     const size_t *      origin,
1072                     const size_t *      region,
1073                     size_t              input_row_pitch,
1074                     size_t              input_slice_pitch,
1075                     const void *        ptr,
1076                     cl_uint             num_events_in_wait_list,
1077                     const cl_event *    event_wait_list,
1078                     cl_event *          event) CL_API_SUFFIX__VERSION_1_0
1079 {
1080     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1081     return command_queue->dispatch->clEnqueueWriteImage(
1082         command_queue,
1083         image,
1084         blocking_write,
1085         origin,
1086         region,
1087         input_row_pitch,
1088         input_slice_pitch,
1089         ptr,
1090         num_events_in_wait_list,
1091         event_wait_list,
1092         event);
1093 }
1094
1095 CL_API_ENTRY cl_int CL_API_CALL
1096 clEnqueueFillImage(cl_command_queue   command_queue,
1097                    cl_mem             image,
1098                    const void *       fill_color,
1099                    const size_t       origin[3],
1100                    const size_t       region[3],
1101                    cl_uint            num_events_in_wait_list,
1102                    const cl_event *   event_wait_list,
1103                    cl_event *         event) CL_API_SUFFIX__VERSION_1_2
1104 {
1105     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1106     return command_queue->dispatch->clEnqueueFillImage(
1107         command_queue,
1108         image,
1109         fill_color,
1110         origin,
1111         region,
1112         num_events_in_wait_list,
1113         event_wait_list,
1114         event);
1115 }
1116
1117 CL_API_ENTRY cl_int CL_API_CALL
1118 clEnqueueCopyImage(cl_command_queue     command_queue,
1119                    cl_mem               src_image,
1120                    cl_mem               dst_image,
1121                    const size_t *       src_origin,
1122                    const size_t *       dst_origin,
1123                    const size_t *       region,
1124                    cl_uint              num_events_in_wait_list,
1125                    const cl_event *     event_wait_list,
1126                    cl_event *           event) CL_API_SUFFIX__VERSION_1_0
1127 {
1128     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1129     return command_queue->dispatch->clEnqueueCopyImage(
1130         command_queue,
1131         src_image,
1132         dst_image,
1133         src_origin,
1134         dst_origin,
1135         region,
1136         num_events_in_wait_list,
1137         event_wait_list,
1138         event);
1139 }
1140
1141 CL_API_ENTRY cl_int CL_API_CALL
1142 clEnqueueCopyImageToBuffer(cl_command_queue command_queue,
1143                            cl_mem           src_image,
1144                            cl_mem           dst_buffer,
1145                            const size_t *   src_origin,
1146                            const size_t *   region,
1147                            size_t           dst_offset,
1148                            cl_uint          num_events_in_wait_list,
1149                            const cl_event * event_wait_list,
1150                            cl_event *       event) CL_API_SUFFIX__VERSION_1_0
1151 {
1152     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1153     return command_queue->dispatch->clEnqueueCopyImageToBuffer(
1154         command_queue,
1155         src_image,
1156         dst_buffer,
1157         src_origin,
1158         region,
1159         dst_offset,
1160         num_events_in_wait_list,
1161         event_wait_list,
1162         event);
1163 }
1164
1165 CL_API_ENTRY cl_int CL_API_CALL
1166 clEnqueueCopyBufferToImage(cl_command_queue command_queue,
1167                            cl_mem           src_buffer,
1168                            cl_mem           dst_image,
1169                            size_t           src_offset,
1170                            const size_t *   dst_origin,
1171                            const size_t *   region,
1172                            cl_uint          num_events_in_wait_list,
1173                            const cl_event * event_wait_list,
1174                            cl_event *       event) CL_API_SUFFIX__VERSION_1_0
1175 {
1176     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1177     return command_queue->dispatch->clEnqueueCopyBufferToImage(
1178         command_queue,
1179         src_buffer,
1180         dst_image,
1181         src_offset,
1182         dst_origin,
1183         region,
1184         num_events_in_wait_list,
1185         event_wait_list,
1186         event);
1187 }
1188
1189 CL_API_ENTRY void * CL_API_CALL
1190 clEnqueueMapBuffer(cl_command_queue command_queue,
1191                    cl_mem           buffer,
1192                    cl_bool          blocking_map,
1193                    cl_map_flags     map_flags,
1194                    size_t           offset,
1195                    size_t           cb,
1196                    cl_uint          num_events_in_wait_list,
1197                    const cl_event * event_wait_list,
1198                    cl_event *       event,
1199                    cl_int *         errcode_ret) CL_API_SUFFIX__VERSION_1_0
1200 {
1201     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE);
1202     return command_queue->dispatch->clEnqueueMapBuffer(
1203         command_queue,
1204         buffer,
1205         blocking_map,
1206         map_flags,
1207         offset,
1208         cb,
1209         num_events_in_wait_list,
1210         event_wait_list,
1211         event,
1212         errcode_ret);
1213 }
1214
1215 CL_API_ENTRY void * CL_API_CALL
1216 clEnqueueMapImage(cl_command_queue  command_queue,
1217                   cl_mem            image,
1218                   cl_bool           blocking_map,
1219                   cl_map_flags      map_flags,
1220                   const size_t *    origin,
1221                   const size_t *    region,
1222                   size_t *          image_row_pitch,
1223                   size_t *          image_slice_pitch,
1224                   cl_uint           num_events_in_wait_list,
1225                   const cl_event *  event_wait_list,
1226                   cl_event *        event,
1227                   cl_int *          errcode_ret) CL_API_SUFFIX__VERSION_1_0
1228 {
1229     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE);
1230     return command_queue->dispatch->clEnqueueMapImage(
1231         command_queue,
1232         image,
1233         blocking_map,
1234         map_flags,
1235         origin,
1236         region,
1237         image_row_pitch,
1238         image_slice_pitch,
1239         num_events_in_wait_list,
1240         event_wait_list,
1241         event,
1242         errcode_ret);
1243 }
1244
1245 CL_API_ENTRY cl_int CL_API_CALL
1246 clEnqueueUnmapMemObject(cl_command_queue command_queue,
1247                         cl_mem           memobj,
1248                         void *           mapped_ptr,
1249                         cl_uint          num_events_in_wait_list,
1250                         const cl_event *  event_wait_list,
1251                         cl_event *        event) CL_API_SUFFIX__VERSION_1_0
1252 {
1253     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1254     return command_queue->dispatch->clEnqueueUnmapMemObject(
1255         command_queue,
1256         memobj,
1257         mapped_ptr,
1258         num_events_in_wait_list,
1259         event_wait_list,
1260         event);
1261 }
1262
1263 CL_API_ENTRY cl_int CL_API_CALL
1264 clEnqueueMigrateMemObjects(cl_command_queue       command_queue,
1265                            cl_uint                num_mem_objects,
1266                            const cl_mem *         mem_objects,
1267                            cl_mem_migration_flags flags,
1268                            cl_uint                num_events_in_wait_list,
1269                            const cl_event *       event_wait_list,
1270                            cl_event *             event) CL_API_SUFFIX__VERSION_1_2
1271 {
1272     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1273     return command_queue->dispatch->clEnqueueMigrateMemObjects(
1274         command_queue,
1275         num_mem_objects,
1276         mem_objects,
1277         flags,
1278         num_events_in_wait_list,
1279         event_wait_list,
1280         event);
1281 }
1282
1283 CL_API_ENTRY cl_int CL_API_CALL
1284 clEnqueueNDRangeKernel(cl_command_queue command_queue,
1285                        cl_kernel        kernel,
1286                        cl_uint          work_dim,
1287                        const size_t *   global_work_offset,
1288                        const size_t *   global_work_size,
1289                        const size_t *   local_work_size,
1290                        cl_uint          num_events_in_wait_list,
1291                        const cl_event * event_wait_list,
1292                        cl_event *       event) CL_API_SUFFIX__VERSION_1_0
1293 {
1294     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1295     return command_queue->dispatch->clEnqueueNDRangeKernel(
1296         command_queue,
1297         kernel,
1298         work_dim,
1299         global_work_offset,
1300         global_work_size,
1301         local_work_size,
1302         num_events_in_wait_list,
1303         event_wait_list,
1304         event);
1305 }
1306
1307 CL_API_ENTRY cl_int CL_API_CALL
1308 clEnqueueTask(cl_command_queue  command_queue,
1309               cl_kernel         kernel,
1310               cl_uint           num_events_in_wait_list,
1311               const cl_event *  event_wait_list,
1312               cl_event *        event) CL_API_SUFFIX__VERSION_1_0
1313 {
1314     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1315     return command_queue->dispatch->clEnqueueTask(
1316         command_queue,
1317         kernel,
1318         num_events_in_wait_list,
1319         event_wait_list,
1320         event);
1321 }
1322
1323 CL_API_ENTRY cl_int CL_API_CALL
1324 clEnqueueNativeKernel(cl_command_queue  command_queue,
1325                       void (CL_CALLBACK * user_func)(void *),
1326                       void *            args,
1327                       size_t            cb_args,
1328                       cl_uint           num_mem_objects,
1329                       const cl_mem *    mem_list,
1330                       const void **     args_mem_loc,
1331                       cl_uint           num_events_in_wait_list,
1332                       const cl_event *  event_wait_list,
1333                       cl_event *        event) CL_API_SUFFIX__VERSION_1_0
1334 {
1335     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1336     return command_queue->dispatch->clEnqueueNativeKernel(
1337         command_queue,
1338         user_func,
1339         args,
1340         cb_args,
1341         num_mem_objects,
1342         mem_list,
1343         args_mem_loc,
1344         num_events_in_wait_list,
1345         event_wait_list,
1346         event);
1347 }
1348
1349 CL_API_ENTRY cl_int CL_API_CALL
1350 clEnqueueMarkerWithWaitList(cl_command_queue  command_queue,
1351                             cl_uint           num_events_in_wait_list,
1352                             const cl_event *  event_wait_list,
1353                             cl_event *        event) CL_API_SUFFIX__VERSION_1_2
1354 {
1355     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1356     return command_queue->dispatch->clEnqueueMarkerWithWaitList(
1357         command_queue,
1358         num_events_in_wait_list,
1359         event_wait_list,
1360         event);
1361 }
1362
1363 CL_API_ENTRY cl_int CL_API_CALL
1364 clEnqueueBarrierWithWaitList(cl_command_queue  command_queue,
1365                              cl_uint           num_events_in_wait_list,
1366                              const cl_event *  event_wait_list,
1367                              cl_event *        event) CL_API_SUFFIX__VERSION_1_2
1368 {
1369     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1370     return command_queue->dispatch->clEnqueueBarrierWithWaitList(
1371         command_queue,
1372         num_events_in_wait_list,
1373         event_wait_list,
1374         event);
1375 }
1376
1377 CL_API_ENTRY void * CL_API_CALL
1378 clGetExtensionFunctionAddressForPlatform(cl_platform_id platform,
1379                                          const char *   function_name) CL_API_SUFFIX__VERSION_1_2
1380 {
1381     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL);
1382
1383     // make sure the ICD is initialized
1384     khrIcdInitialize();
1385
1386     // return any ICD-aware extensions
1387
1388     // Most extensions, including multi-vendor KHR and EXT extensions,
1389     // do not need to be ICD-aware and do not require any ICD loader
1390     // modifications.  The KHR and EXT extensions below were added for
1391     // backwards compatibility only.
1392     #define CL_COMMON_EXTENSION_ENTRYPOINT_ADD(name) if (!strcmp(function_name, #name) ) return (void *)(size_t)&name
1393
1394     // Functions supporting the creation of OpenCL Memory Objects
1395     // from OpenGL Objects (cl_apple_gl_sharing, cl_khr_gl_sharing)
1396     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLBuffer);
1397     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture);
1398     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture2D);
1399     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture3D);
1400     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLRenderbuffer);
1401     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLObjectInfo);
1402     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLTextureInfo);
1403     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireGLObjects);
1404     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseGLObjects);
1405
1406     // cl_khr_gl_sharing
1407     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLContextInfoKHR);
1408
1409     // cl_khr_gl_event
1410     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromGLsyncKHR);
1411
1412 #if defined(_WIN32)
1413     // cl_khr_d3d10_sharing
1414     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D10KHR);
1415     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10BufferKHR);
1416     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture2DKHR);
1417     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture3DKHR);
1418     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D10ObjectsKHR);
1419     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D10ObjectsKHR);
1420     // cl_khr_d3d11_sharing
1421     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D11KHR);
1422     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11BufferKHR);
1423     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture2DKHR);
1424     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture3DKHR);
1425     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D11ObjectsKHR);
1426     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D11ObjectsKHR);
1427     // cl_khr_dx9_media_sharing
1428     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromDX9MediaAdapterKHR);
1429     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromDX9MediaSurfaceKHR);
1430     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireDX9MediaSurfacesKHR);
1431     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseDX9MediaSurfacesKHR);
1432 #endif
1433
1434     // cl_ext_device_fission
1435     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateSubDevicesEXT);
1436     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clRetainDeviceEXT);
1437     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clReleaseDeviceEXT);
1438
1439     /* cl_khr_egl_image */
1440     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromEGLImageKHR);
1441     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireEGLObjectsKHR);
1442     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseEGLObjectsKHR);
1443
1444     /* cl_khr_egl_event */
1445     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromEGLSyncKHR);
1446
1447     /* cl_khr_sub_groups */
1448     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetKernelSubGroupInfoKHR);
1449
1450     #undef CL_COMMON_EXTENSION_ENTRYPOINT_ADD
1451
1452     // This is not an ICD-aware extension, so call into the implementation
1453     // to get the extension function address.
1454
1455     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, NULL);
1456     return platform->dispatch->clGetExtensionFunctionAddressForPlatform(
1457         platform,
1458         function_name);
1459 }
1460
1461 // Deprecated APIs
1462 CL_API_ENTRY cl_int CL_API_CALL
1463 clSetCommandQueueProperty(cl_command_queue              command_queue,
1464                           cl_command_queue_properties   properties,
1465                           cl_bool                       enable,
1466                           cl_command_queue_properties * old_properties) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED
1467 {
1468     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1469     return command_queue->dispatch->clSetCommandQueueProperty(
1470         command_queue,
1471         properties,
1472         enable,
1473         old_properties);
1474 }
1475
1476 CL_API_ENTRY cl_int CL_API_CALL
1477 clCreateSubDevicesEXT(
1478     cl_device_id in_device,
1479     const cl_device_partition_property_ext * partition_properties,
1480     cl_uint num_entries,
1481     cl_device_id * out_devices,
1482     cl_uint * num_devices) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1483 {
1484     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
1485         return in_device->dispatch->clCreateSubDevicesEXT(
1486         in_device,
1487         partition_properties,
1488         num_entries,
1489         out_devices,
1490         num_devices);
1491 }
1492
1493 CL_API_ENTRY cl_int CL_API_CALL
1494 clRetainDeviceEXT(cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1495 {
1496     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
1497     return device->dispatch->clRetainDeviceEXT(device);
1498 }
1499
1500 CL_API_ENTRY cl_int CL_API_CALL
1501 clReleaseDeviceEXT(cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1502 {
1503     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
1504     return device->dispatch->clReleaseDeviceEXT(device);
1505 }
1506
1507 CL_API_ENTRY cl_mem CL_API_CALL
1508 clCreateImage2D(cl_context              context,
1509                 cl_mem_flags            flags,
1510                 const cl_image_format * image_format,
1511                 size_t                  image_width,
1512                 size_t                  image_height,
1513                 size_t                  image_row_pitch,
1514                 void *                  host_ptr,
1515                 cl_int *                errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1516 {
1517     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1518     return context->dispatch->clCreateImage2D(
1519         context,
1520         flags,
1521         image_format,
1522         image_width,
1523         image_height,
1524         image_row_pitch,
1525         host_ptr,
1526         errcode_ret);
1527 }
1528
1529 CL_API_ENTRY cl_mem CL_API_CALL
1530 clCreateImage3D(cl_context              context,
1531                 cl_mem_flags            flags,
1532                 const cl_image_format * image_format,
1533                 size_t                  image_width,
1534                 size_t                  image_height,
1535                 size_t                  image_depth,
1536                 size_t                  image_row_pitch,
1537                 size_t                  image_slice_pitch,
1538                 void *                  host_ptr,
1539                 cl_int *                errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1540 {
1541     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1542     return context->dispatch->clCreateImage3D(
1543         context,
1544         flags,
1545         image_format,
1546         image_width,
1547         image_height,
1548         image_depth,
1549         image_row_pitch,
1550         image_slice_pitch,
1551         host_ptr,
1552         errcode_ret);
1553 }
1554
1555 CL_API_ENTRY cl_int CL_API_CALL
1556 clUnloadCompiler(void) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1557 {
1558     return CL_SUCCESS;
1559 }
1560
1561 CL_API_ENTRY cl_int CL_API_CALL
1562 clEnqueueMarker(cl_command_queue    command_queue,
1563                 cl_event *          event) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1564 {
1565     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1566     return command_queue->dispatch->clEnqueueMarker(
1567         command_queue,
1568         event);
1569 }
1570
1571 CL_API_ENTRY cl_int CL_API_CALL
1572 clEnqueueWaitForEvents(cl_command_queue command_queue,
1573                        cl_uint          num_events,
1574                        const cl_event * event_list) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1575 {
1576     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1577     return command_queue->dispatch->clEnqueueWaitForEvents(
1578         command_queue,
1579         num_events,
1580         event_list);
1581 }
1582
1583 CL_API_ENTRY cl_int CL_API_CALL
1584 clEnqueueBarrier(cl_command_queue command_queue) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1585 {
1586     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1587     return command_queue->dispatch->clEnqueueBarrier(command_queue);
1588 }
1589
1590 CL_API_ENTRY void * CL_API_CALL
1591 clGetExtensionFunctionAddress(const char *function_name) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1592 {
1593     size_t function_name_length = 0;
1594     KHRicdVendor* vendor = NULL;
1595
1596     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL);
1597
1598     // make sure the ICD is initialized
1599     khrIcdInitialize();
1600     function_name_length = strlen(function_name);
1601
1602     // return any ICD-aware extensions
1603
1604     // Most extensions, including multi-vendor KHR and EXT extensions,
1605     // do not need to be ICD-aware and do not require any ICD loader
1606     // modifications.  The KHR and EXT extensions below were added for
1607     // backwards compatibility only.
1608     #define CL_COMMON_EXTENSION_ENTRYPOINT_ADD(name) if (!strcmp(function_name, #name) ) return (void *)(size_t)&name
1609
1610     // Functions supporting the creation of OpenCL Memory Objects
1611     // from OpenGL Objects (cl_apple_gl_sharing, cl_khr_gl_sharing)
1612     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLBuffer);
1613     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture);
1614     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture2D);
1615     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture3D);
1616     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLRenderbuffer);
1617     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLObjectInfo);
1618     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLTextureInfo);
1619     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireGLObjects);
1620     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseGLObjects);
1621
1622     // cl_khr_gl_sharing
1623     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLContextInfoKHR);
1624
1625     // cl_khr_gl_event
1626     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromGLsyncKHR);
1627
1628 #if defined(_WIN32)
1629     // cl_khr_d3d10_sharing
1630     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D10KHR);
1631     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10BufferKHR);
1632     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture2DKHR);
1633     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture3DKHR);
1634     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D10ObjectsKHR);
1635     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D10ObjectsKHR);
1636     // cl_khr_d3d11_sharing
1637     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D11KHR);
1638     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11BufferKHR);
1639     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture2DKHR);
1640     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture3DKHR);
1641     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D11ObjectsKHR);
1642     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D11ObjectsKHR);
1643     // cl_khr_dx9_media_sharing
1644     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromDX9MediaAdapterKHR);
1645     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromDX9MediaSurfaceKHR);
1646     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireDX9MediaSurfacesKHR);
1647     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseDX9MediaSurfacesKHR);
1648 #endif
1649
1650     // cl_ext_device_fission
1651     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateSubDevicesEXT);
1652     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clRetainDeviceEXT);
1653     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clReleaseDeviceEXT);
1654
1655     /* cl_khr_egl_image */
1656     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromEGLImageKHR);
1657     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireEGLObjectsKHR);
1658     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseEGLObjectsKHR);
1659
1660     /* cl_khr_egl_event */
1661     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromEGLSyncKHR);
1662
1663     /* cl_khr_sub_groups */
1664     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetKernelSubGroupInfoKHR);
1665
1666     #undef CL_COMMON_EXTENSION_ENTRYPOINT_ADD
1667
1668     // fall back to vendor extension detection
1669     for (vendor = khrIcdVendors; vendor; vendor = vendor->next)
1670     {
1671         size_t vendor_suffix_length = strlen(vendor->suffix);
1672         if (vendor_suffix_length <= function_name_length && vendor_suffix_length > 0)
1673         {
1674             const char *function_suffix = function_name+function_name_length-vendor_suffix_length;
1675             if (!strcmp(function_suffix, vendor->suffix) )
1676             {
1677                 return vendor->clGetExtensionFunctionAddress(function_name);
1678             }
1679         }
1680     }
1681     return NULL;
1682 }
1683
1684 // GL and other APIs
1685 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer(
1686     cl_context    context,
1687     cl_mem_flags  flags,
1688     cl_GLuint     bufobj,
1689     int *         errcode_ret) CL_API_SUFFIX__VERSION_1_0
1690 {
1691     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1692     return context->dispatch->clCreateFromGLBuffer(
1693         context,
1694         flags,
1695         bufobj,
1696         errcode_ret);
1697 }
1698
1699 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture(
1700     cl_context      context,
1701     cl_mem_flags    flags,
1702     cl_GLenum       target,
1703     cl_GLint        miplevel,
1704     cl_GLuint       texture,
1705     cl_int *        errcode_ret) CL_API_SUFFIX__VERSION_1_2
1706 {
1707     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1708     return context->dispatch->clCreateFromGLTexture(
1709         context,
1710         flags,
1711         target,
1712         miplevel,
1713         texture,
1714         errcode_ret);
1715 }
1716
1717 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D(
1718     cl_context      context,
1719     cl_mem_flags    flags,
1720     cl_GLenum       target,
1721     cl_GLint        miplevel,
1722     cl_GLuint       texture,
1723     cl_int *        errcode_ret) CL_API_SUFFIX__VERSION_1_0
1724 {
1725     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1726     return context->dispatch->clCreateFromGLTexture2D(
1727         context,
1728         flags,
1729         target,
1730         miplevel,
1731         texture,
1732         errcode_ret);
1733 }
1734
1735 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D(
1736     cl_context      context,
1737     cl_mem_flags    flags,
1738     cl_GLenum       target,
1739     cl_GLint        miplevel,
1740     cl_GLuint       texture,
1741     cl_int *        errcode_ret) CL_API_SUFFIX__VERSION_1_0
1742 {
1743     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1744     return context->dispatch->clCreateFromGLTexture3D(
1745         context,
1746         flags,
1747         target,
1748         miplevel,
1749         texture,
1750         errcode_ret);
1751 }
1752
1753 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer(
1754     cl_context           context,
1755     cl_mem_flags         flags,
1756     cl_GLuint            renderbuffer,
1757     cl_int *             errcode_ret) CL_API_SUFFIX__VERSION_1_0
1758 {
1759     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1760     return context->dispatch->clCreateFromGLRenderbuffer(
1761         context,
1762         flags,
1763         renderbuffer,
1764         errcode_ret);
1765 }
1766
1767 CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo(
1768     cl_mem               memobj,
1769     cl_gl_object_type *  gl_object_type,
1770     cl_GLuint *          gl_object_name) CL_API_SUFFIX__VERSION_1_0
1771 {
1772     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
1773     return memobj->dispatch->clGetGLObjectInfo(
1774         memobj,
1775         gl_object_type,
1776         gl_object_name);
1777 }
1778
1779 CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo(
1780     cl_mem               memobj,
1781     cl_gl_texture_info   param_name,
1782     size_t               param_value_size,
1783     void *               param_value,
1784     size_t *             param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
1785 {
1786     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
1787     return memobj->dispatch->clGetGLTextureInfo(
1788         memobj,
1789         param_name,
1790         param_value_size,
1791         param_value,
1792         param_value_size_ret);
1793 }
1794
1795 CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects(
1796     cl_command_queue     command_queue,
1797     cl_uint              num_objects,
1798     const cl_mem *       mem_objects,
1799     cl_uint              num_events_in_wait_list,
1800     const cl_event *     event_wait_list,
1801     cl_event *           event) CL_API_SUFFIX__VERSION_1_0
1802 {
1803     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1804     return command_queue->dispatch->clEnqueueAcquireGLObjects(
1805         command_queue,
1806         num_objects,
1807         mem_objects,
1808         num_events_in_wait_list,
1809         event_wait_list,
1810         event);
1811 }
1812
1813 CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects(
1814     cl_command_queue     command_queue,
1815     cl_uint              num_objects,
1816     const cl_mem *       mem_objects,
1817     cl_uint              num_events_in_wait_list,
1818     const cl_event *     event_wait_list,
1819     cl_event *           event) CL_API_SUFFIX__VERSION_1_0
1820 {
1821     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1822     return command_queue->dispatch->clEnqueueReleaseGLObjects(
1823         command_queue,
1824         num_objects,
1825         mem_objects,
1826         num_events_in_wait_list,
1827         event_wait_list,
1828         event);
1829 }
1830
1831 CL_API_ENTRY cl_int CL_API_CALL clGetGLContextInfoKHR(
1832     const cl_context_properties *properties,
1833     cl_gl_context_info param_name,
1834     size_t param_value_size,
1835     void *param_value,
1836     size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
1837 {
1838     cl_platform_id platform = NULL;
1839
1840     // initialize the platforms (in case they have not been already)
1841     khrIcdInitialize();
1842
1843     // determine the platform to use from the properties specified
1844     khrIcdContextPropertiesGetPlatform(properties, &platform);
1845     // determine the platform to use from the device_type specified
1846     if (!platform)
1847     {
1848         khrIcdDeviceTypeGetPlatform(device_type, &platform);
1849     }
1850     if (!platform && khrIcdVendors != NULL)
1851     {
1852         platform = khrIcdVendors[0].platform;
1853     }
1854
1855     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
1856     return platform->dispatch->clGetGLContextInfoKHR(
1857         properties,
1858         param_name,
1859         param_value_size,
1860         param_value,
1861         param_value_size_ret);
1862 }
1863
1864 CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR(
1865         cl_context context,
1866         cl_GLsync sync,
1867         cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1
1868 {
1869         KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1870         return context->dispatch->clCreateEventFromGLsyncKHR(
1871                 context,
1872                 sync,
1873                 errcode_ret);
1874 }
1875
1876 #if defined(_WIN32)
1877 /*
1878  *
1879  * cl_d3d10_sharing_khr
1880  *
1881  */
1882
1883 CL_API_ENTRY cl_int CL_API_CALL
1884 clGetDeviceIDsFromD3D10KHR(
1885     cl_platform_id platform,
1886     cl_d3d10_device_source_khr d3d_device_source,
1887     void *d3d_object,
1888     cl_d3d10_device_set_khr d3d_device_set,
1889     cl_uint num_entries,
1890     cl_device_id *devices,
1891     cl_uint *num_devices)
1892 {
1893     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
1894     return platform->dispatch->clGetDeviceIDsFromD3D10KHR(
1895         platform,
1896         d3d_device_source,
1897         d3d_object,
1898         d3d_device_set,
1899         num_entries,
1900         devices,
1901         num_devices);
1902 }
1903
1904 CL_API_ENTRY cl_mem CL_API_CALL
1905 clCreateFromD3D10BufferKHR(
1906     cl_context context,
1907     cl_mem_flags flags,
1908     ID3D10Buffer *resource,
1909     cl_int *errcode_ret)
1910 {
1911     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1912     return context->dispatch->clCreateFromD3D10BufferKHR(
1913         context,
1914         flags,
1915         resource,
1916         errcode_ret);
1917 }
1918
1919 CL_API_ENTRY cl_mem CL_API_CALL
1920 clCreateFromD3D10Texture2DKHR(
1921     cl_context        context,
1922     cl_mem_flags      flags,
1923     ID3D10Texture2D * resource,
1924     UINT              subresource,
1925     cl_int *          errcode_ret)
1926 {
1927     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1928     return context->dispatch->clCreateFromD3D10Texture2DKHR(
1929         context,
1930         flags,
1931         resource,
1932         subresource,
1933         errcode_ret);
1934 }
1935
1936 CL_API_ENTRY cl_mem CL_API_CALL
1937 clCreateFromD3D10Texture3DKHR(
1938     cl_context context,
1939     cl_mem_flags flags,
1940     ID3D10Texture3D *resource,
1941     UINT subresource,
1942     cl_int *errcode_ret)
1943 {
1944     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1945     return context->dispatch->clCreateFromD3D10Texture3DKHR(
1946         context,
1947         flags,
1948         resource,
1949         subresource,
1950         errcode_ret);
1951 }
1952
1953 CL_API_ENTRY cl_int CL_API_CALL
1954 clEnqueueAcquireD3D10ObjectsKHR(
1955     cl_command_queue command_queue,
1956     cl_uint num_objects,
1957     const cl_mem *mem_objects,
1958     cl_uint num_events_in_wait_list,
1959     const cl_event *event_wait_list,
1960     cl_event *event)
1961 {
1962     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1963     return command_queue->dispatch->clEnqueueAcquireD3D10ObjectsKHR(
1964         command_queue,
1965         num_objects,
1966         mem_objects,
1967         num_events_in_wait_list,
1968         event_wait_list,
1969         event);
1970 }
1971
1972 CL_API_ENTRY cl_int CL_API_CALL
1973 clEnqueueReleaseD3D10ObjectsKHR(
1974     cl_command_queue command_queue,
1975     cl_uint num_objects,
1976     const cl_mem *mem_objects,
1977     cl_uint num_events_in_wait_list,
1978     const cl_event *event_wait_list,
1979     cl_event *event)
1980 {
1981     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1982     return command_queue->dispatch->clEnqueueReleaseD3D10ObjectsKHR(
1983         command_queue,
1984         num_objects,
1985         mem_objects,
1986         num_events_in_wait_list,
1987         event_wait_list,
1988         event);
1989 }
1990
1991 /*
1992  *
1993  * cl_d3d11_sharing_khr
1994  *
1995  */
1996
1997 CL_API_ENTRY cl_int CL_API_CALL
1998 clGetDeviceIDsFromD3D11KHR(
1999     cl_platform_id             platform,
2000     cl_d3d11_device_source_khr d3d_device_source,
2001     void *                     d3d_object,
2002     cl_d3d11_device_set_khr    d3d_device_set,
2003     cl_uint                    num_entries,
2004     cl_device_id *             devices,
2005     cl_uint *                  num_devices)
2006 {
2007     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
2008     return platform->dispatch->clGetDeviceIDsFromD3D11KHR(
2009         platform,
2010         d3d_device_source,
2011         d3d_object,
2012         d3d_device_set,
2013         num_entries,
2014         devices,
2015         num_devices);
2016 }
2017
2018 CL_API_ENTRY cl_mem CL_API_CALL
2019 clCreateFromD3D11BufferKHR(
2020     cl_context     context,
2021     cl_mem_flags   flags,
2022     ID3D11Buffer * resource,
2023     cl_int *       errcode_ret)
2024 {
2025     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2026     return context->dispatch->clCreateFromD3D11BufferKHR(
2027         context,
2028         flags,
2029         resource,
2030         errcode_ret);
2031 }
2032
2033 CL_API_ENTRY cl_mem CL_API_CALL
2034 clCreateFromD3D11Texture2DKHR(
2035     cl_context        context,
2036     cl_mem_flags      flags,
2037     ID3D11Texture2D * resource,
2038     UINT              subresource,
2039     cl_int *          errcode_ret)
2040 {
2041     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2042     return context->dispatch->clCreateFromD3D11Texture2DKHR(
2043         context,
2044         flags,
2045         resource,
2046         subresource,
2047         errcode_ret);
2048 }
2049
2050 CL_API_ENTRY cl_mem CL_API_CALL
2051 clCreateFromD3D11Texture3DKHR(
2052     cl_context        context,
2053     cl_mem_flags      flags,
2054     ID3D11Texture3D * resource,
2055     UINT              subresource,
2056     cl_int *          errcode_ret)
2057 {
2058     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2059     return context->dispatch->clCreateFromD3D11Texture3DKHR(
2060         context,
2061         flags,
2062         resource,
2063         subresource,
2064         errcode_ret);
2065 }
2066
2067 CL_API_ENTRY cl_int CL_API_CALL
2068 clEnqueueAcquireD3D11ObjectsKHR(
2069     cl_command_queue command_queue,
2070     cl_uint          num_objects,
2071     const cl_mem *   mem_objects,
2072     cl_uint          num_events_in_wait_list,
2073     const cl_event * event_wait_list,
2074     cl_event *       event)
2075 {
2076     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2077     return command_queue->dispatch->clEnqueueAcquireD3D11ObjectsKHR(
2078         command_queue,
2079         num_objects,
2080         mem_objects,
2081         num_events_in_wait_list,
2082         event_wait_list,
2083         event);
2084 }
2085
2086 CL_API_ENTRY cl_int CL_API_CALL
2087 clEnqueueReleaseD3D11ObjectsKHR(
2088     cl_command_queue command_queue,
2089     cl_uint          num_objects,
2090     const cl_mem *   mem_objects,
2091     cl_uint          num_events_in_wait_list,
2092     const cl_event * event_wait_list,
2093     cl_event *       event)
2094 {
2095     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2096     return command_queue->dispatch->clEnqueueReleaseD3D11ObjectsKHR(
2097         command_queue,
2098         num_objects,
2099         mem_objects,
2100         num_events_in_wait_list,
2101         event_wait_list,
2102         event);
2103 }
2104
2105 /*
2106  *
2107  * cl_khr_dx9_media_sharing
2108  *
2109  */
2110
2111 CL_API_ENTRY cl_int CL_API_CALL
2112 clGetDeviceIDsFromDX9MediaAdapterKHR(
2113     cl_platform_id                  platform,
2114     cl_uint                         num_media_adapters,
2115     cl_dx9_media_adapter_type_khr * media_adapters_type,
2116     void *                          media_adapters,
2117     cl_dx9_media_adapter_set_khr    media_adapter_set,
2118     cl_uint                         num_entries,
2119     cl_device_id *                  devices,
2120     cl_uint *                       num_devices)
2121 {
2122     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
2123     return platform->dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR(
2124         platform,
2125         num_media_adapters,
2126                 media_adapters_type,
2127         media_adapters,
2128         media_adapter_set,
2129         num_entries,
2130         devices,
2131         num_devices);
2132 }
2133
2134 CL_API_ENTRY cl_mem CL_API_CALL
2135 clCreateFromDX9MediaSurfaceKHR(
2136     cl_context                    context,
2137     cl_mem_flags                  flags,
2138     cl_dx9_media_adapter_type_khr adapter_type,
2139     void *                        surface_info,
2140     cl_uint                       plane,
2141     cl_int *                      errcode_ret)
2142 {
2143     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2144     return context->dispatch->clCreateFromDX9MediaSurfaceKHR(
2145         context,
2146         flags,
2147         adapter_type,
2148         surface_info,
2149         plane,
2150         errcode_ret);
2151 }
2152
2153 CL_API_ENTRY cl_int CL_API_CALL
2154 clEnqueueAcquireDX9MediaSurfacesKHR(
2155     cl_command_queue command_queue,
2156     cl_uint          num_objects,
2157     const cl_mem *   mem_objects,
2158     cl_uint          num_events_in_wait_list,
2159     const cl_event * event_wait_list,
2160     cl_event *       event)
2161 {
2162     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2163     return command_queue->dispatch->clEnqueueAcquireDX9MediaSurfacesKHR(
2164         command_queue,
2165         num_objects,
2166         mem_objects,
2167         num_events_in_wait_list,
2168         event_wait_list,
2169         event);
2170 }
2171
2172 CL_API_ENTRY cl_int CL_API_CALL
2173 clEnqueueReleaseDX9MediaSurfacesKHR(
2174     cl_command_queue command_queue,
2175     cl_uint          num_objects,
2176     const cl_mem *   mem_objects,
2177     cl_uint          num_events_in_wait_list,
2178     const cl_event * event_wait_list,
2179     cl_event *       event)
2180 {
2181     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2182     return command_queue->dispatch->clEnqueueReleaseDX9MediaSurfacesKHR(
2183         command_queue,
2184         num_objects,
2185         mem_objects,
2186         num_events_in_wait_list,
2187         event_wait_list,
2188         event);
2189 }
2190
2191 #endif
2192
2193 CL_API_ENTRY cl_int CL_API_CALL
2194 clSetEventCallback(
2195     cl_event event,
2196     cl_int command_exec_callback_type,
2197     void (CL_CALLBACK *pfn_notify)(cl_event, cl_int, void *),
2198     void *user_data) CL_API_SUFFIX__VERSION_1_1
2199 {
2200     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
2201     return event->dispatch->clSetEventCallback(
2202         event,
2203         command_exec_callback_type,
2204         pfn_notify,
2205         user_data);
2206 }
2207
2208 CL_API_ENTRY cl_mem CL_API_CALL
2209 clCreateSubBuffer(
2210     cl_mem buffer,
2211     cl_mem_flags flags,
2212     cl_buffer_create_type buffer_create_type,
2213     const void * buffer_create_info,
2214     cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1
2215 {
2216     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(buffer, CL_INVALID_MEM_OBJECT);
2217     return buffer->dispatch->clCreateSubBuffer(
2218         buffer,
2219         flags,
2220         buffer_create_type,
2221         buffer_create_info,
2222         errcode_ret);
2223 }
2224
2225 CL_API_ENTRY cl_int CL_API_CALL
2226 clSetMemObjectDestructorCallback(
2227     cl_mem memobj,
2228     void (CL_CALLBACK * pfn_notify)( cl_mem, void*),
2229     void * user_data )             CL_API_SUFFIX__VERSION_1_1
2230 {
2231     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
2232     return memobj->dispatch->clSetMemObjectDestructorCallback(
2233         memobj,
2234         pfn_notify,
2235         user_data);
2236 }
2237
2238 CL_API_ENTRY cl_event CL_API_CALL
2239 clCreateUserEvent(
2240     cl_context context,
2241     cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1
2242 {
2243     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2244     return context->dispatch->clCreateUserEvent(
2245         context,
2246         errcode_ret);
2247 }
2248
2249 CL_API_ENTRY cl_int CL_API_CALL
2250 clSetUserEventStatus(
2251     cl_event event,
2252     cl_int execution_status) CL_API_SUFFIX__VERSION_1_1
2253 {
2254     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
2255     return event->dispatch->clSetUserEventStatus(
2256         event,
2257         execution_status);
2258 }
2259
2260 CL_API_ENTRY cl_mem CL_API_CALL
2261 clCreateFromEGLImageKHR(
2262     cl_context context,
2263     CLeglDisplayKHR display,
2264     CLeglImageKHR image,
2265     cl_mem_flags flags,
2266     const cl_egl_image_properties_khr *properties,
2267     cl_int *errcode_ret)
2268 {
2269     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2270     return context->dispatch->clCreateFromEGLImageKHR(
2271         context,
2272         display,
2273         image,
2274         flags,
2275         properties,
2276         errcode_ret);
2277 }
2278
2279 CL_API_ENTRY cl_int CL_API_CALL
2280 clEnqueueAcquireEGLObjectsKHR(
2281     cl_command_queue command_queue,
2282     cl_uint num_objects,
2283     const cl_mem *mem_objects,
2284     cl_uint num_events_in_wait_list,
2285     const cl_event *event_wait_list,
2286     cl_event *event)
2287 {
2288     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2289     return command_queue->dispatch->clEnqueueAcquireEGLObjectsKHR(
2290         command_queue,
2291         num_objects,
2292         mem_objects,
2293         num_events_in_wait_list,
2294         event_wait_list,
2295         event);
2296 }
2297
2298 CL_API_ENTRY cl_int CL_API_CALL
2299 clEnqueueReleaseEGLObjectsKHR(
2300     cl_command_queue command_queue,
2301     cl_uint num_objects,
2302     const cl_mem *mem_objects,
2303     cl_uint num_events_in_wait_list,
2304     const cl_event *event_wait_list,
2305     cl_event *event)
2306 {
2307     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2308     return command_queue->dispatch->clEnqueueReleaseEGLObjectsKHR(
2309         command_queue,
2310         num_objects,
2311         mem_objects,
2312         num_events_in_wait_list,
2313         event_wait_list,
2314         event);
2315 }
2316
2317 /* cl_khr_egl_event */
2318 CL_API_ENTRY cl_event CL_API_CALL
2319 clCreateEventFromEGLSyncKHR(
2320     cl_context context,
2321     CLeglSyncKHR sync,
2322     CLeglDisplayKHR display,
2323     cl_int *errcode_ret)
2324 {
2325     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2326     return context->dispatch->clCreateEventFromEGLSyncKHR(
2327         context,
2328         sync,
2329         display,
2330         errcode_ret);
2331 }
2332
2333 CL_API_ENTRY cl_command_queue CL_API_CALL
2334 clCreateCommandQueueWithProperties(
2335     cl_context                  context,
2336     cl_device_id                device,
2337     const cl_queue_properties * properties,
2338     cl_int *                    errcode_ret) CL_API_SUFFIX__VERSION_2_0
2339 {
2340     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2341     return context->dispatch->clCreateCommandQueueWithProperties(
2342         context,
2343         device,
2344         properties,
2345         errcode_ret);
2346 }
2347
2348 CL_API_ENTRY cl_mem CL_API_CALL
2349 clCreatePipe(
2350     cl_context                 context,
2351     cl_mem_flags               flags,
2352     cl_uint                    pipe_packet_size,
2353     cl_uint                    pipe_max_packets,
2354     const cl_pipe_properties * properties,
2355     cl_int *                   errcode_ret) CL_API_SUFFIX__VERSION_2_0
2356 {
2357     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2358     return context->dispatch->clCreatePipe(
2359         context,
2360         flags,
2361         pipe_packet_size,
2362         pipe_max_packets,
2363         properties,
2364         errcode_ret);
2365 }
2366
2367 CL_API_ENTRY cl_int CL_API_CALL
2368 clGetPipeInfo(
2369     cl_mem       pipe,
2370     cl_pipe_info param_name,
2371     size_t       param_value_size,
2372     void *       param_value,
2373     size_t *     param_value_size_ret) CL_API_SUFFIX__VERSION_2_0
2374 {
2375     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(pipe, CL_INVALID_MEM_OBJECT);
2376     return pipe->dispatch->clGetPipeInfo(
2377         pipe,
2378         param_name,
2379         param_value_size,
2380         param_value,
2381         param_value_size_ret);
2382 }
2383
2384 CL_API_ENTRY void * CL_API_CALL
2385 clSVMAlloc(
2386     cl_context       context,
2387     cl_svm_mem_flags flags,
2388     size_t           size,
2389     cl_uint          alignment) CL_API_SUFFIX__VERSION_2_0
2390 {
2391     if (!context) {
2392         return NULL;
2393     }
2394     return context->dispatch->clSVMAlloc(
2395         context,
2396         flags,
2397         size,
2398         alignment);
2399 }
2400
2401 CL_API_ENTRY void CL_API_CALL
2402 clSVMFree(
2403     cl_context context,
2404     void *     svm_pointer) CL_API_SUFFIX__VERSION_2_0
2405 {
2406     if (!context || !svm_pointer) {
2407         return;
2408     }
2409     context->dispatch->clSVMFree(
2410         context,
2411         svm_pointer);
2412 }
2413
2414 CL_API_ENTRY cl_int CL_API_CALL
2415 clEnqueueSVMFree(
2416     cl_command_queue command_queue,
2417     cl_uint num_svm_pointers,
2418     void* svm_pointers[],
2419     void (CL_CALLBACK* pfn_free_func)(
2420         cl_command_queue queue,
2421         cl_uint num_svm_pointers,
2422         void* svm_pointers[],
2423         void* user_data),
2424     void* user_data,
2425     cl_uint num_events_in_wait_list,
2426     const cl_event* event_wait_list,
2427     cl_event* event) CL_API_SUFFIX__VERSION_2_0
2428 {
2429     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2430     return command_queue->dispatch->clEnqueueSVMFree(
2431         command_queue,
2432         num_svm_pointers,
2433         svm_pointers,
2434         pfn_free_func,
2435         user_data,
2436         num_events_in_wait_list,
2437         event_wait_list,
2438         event);
2439 }
2440
2441 CL_API_ENTRY cl_int CL_API_CALL
2442 clEnqueueSVMMemcpy(
2443     cl_command_queue  command_queue,
2444     cl_bool           blocking_copy,
2445     void *            dst_ptr,
2446     const void *      src_ptr,
2447     size_t            size,
2448     cl_uint           num_events_in_wait_list,
2449     const cl_event *  event_wait_list,
2450     cl_event *        event) CL_API_SUFFIX__VERSION_2_0
2451 {
2452     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2453     return command_queue->dispatch->clEnqueueSVMMemcpy(
2454         command_queue,
2455         blocking_copy,
2456         dst_ptr,
2457         src_ptr,
2458         size,
2459         num_events_in_wait_list,
2460         event_wait_list,
2461         event);
2462 }
2463
2464 CL_API_ENTRY cl_int CL_API_CALL
2465 clEnqueueSVMMemFill(
2466     cl_command_queue command_queue,
2467     void *           svm_ptr,
2468     const void *     pattern,
2469     size_t           pattern_size,
2470     size_t           size,
2471     cl_uint          num_events_in_wait_list,
2472     const cl_event * event_wait_list,
2473     cl_event *       event) CL_API_SUFFIX__VERSION_2_0
2474 {
2475     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2476     return command_queue->dispatch->clEnqueueSVMMemFill(
2477         command_queue,
2478         svm_ptr,
2479         pattern,
2480         pattern_size,
2481         size,
2482         num_events_in_wait_list,
2483         event_wait_list,
2484         event);
2485 }
2486
2487 CL_API_ENTRY cl_int CL_API_CALL
2488 clEnqueueSVMMap(
2489     cl_command_queue  command_queue,
2490     cl_bool           blocking_map,
2491     cl_map_flags      flags,
2492     void *            svm_ptr,
2493     size_t            size,
2494     cl_uint           num_events_in_wait_list,
2495     const cl_event *  event_wait_list,
2496     cl_event *        event) CL_API_SUFFIX__VERSION_2_0
2497 {
2498     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2499     return command_queue->dispatch->clEnqueueSVMMap(
2500         command_queue,
2501         blocking_map,
2502         flags,
2503         svm_ptr,
2504         size,
2505         num_events_in_wait_list,
2506         event_wait_list,
2507         event);
2508 }
2509
2510 CL_API_ENTRY cl_int CL_API_CALL
2511 clEnqueueSVMUnmap(
2512     cl_command_queue command_queue,
2513     void *           svm_ptr,
2514     cl_uint          num_events_in_wait_list,
2515     const cl_event * event_wait_list,
2516     cl_event *       event) CL_API_SUFFIX__VERSION_2_0
2517 {
2518     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2519     return command_queue->dispatch->clEnqueueSVMUnmap(
2520         command_queue,
2521         svm_ptr,
2522         num_events_in_wait_list,
2523         event_wait_list,
2524         event);
2525 }
2526
2527 CL_API_ENTRY cl_sampler CL_API_CALL
2528 clCreateSamplerWithProperties(
2529     cl_context                     context,
2530     const cl_sampler_properties *  sampler_properties,
2531     cl_int *                       errcode_ret) CL_API_SUFFIX__VERSION_2_0
2532 {
2533     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2534     return context->dispatch->clCreateSamplerWithProperties(
2535         context,
2536         sampler_properties,
2537         errcode_ret);
2538 }
2539
2540 CL_API_ENTRY cl_int CL_API_CALL
2541 clSetKernelArgSVMPointer(
2542     cl_kernel    kernel,
2543     cl_uint      arg_index,
2544     const void * arg_value) CL_API_SUFFIX__VERSION_2_0
2545 {
2546     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
2547     return kernel->dispatch->clSetKernelArgSVMPointer(
2548         kernel,
2549         arg_index,
2550         arg_value);
2551 }
2552
2553 CL_API_ENTRY cl_int CL_API_CALL
2554 clSetKernelExecInfo(
2555     cl_kernel            kernel,
2556     cl_kernel_exec_info  param_name,
2557     size_t               param_value_size,
2558     const void *         param_value) CL_API_SUFFIX__VERSION_2_0
2559 {
2560     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
2561     return kernel->dispatch->clSetKernelExecInfo(
2562         kernel,
2563         param_name,
2564         param_value_size,
2565         param_value);
2566 }
2567
2568 CL_API_ENTRY cl_int CL_API_CALL
2569 clGetKernelSubGroupInfoKHR(
2570     cl_kernel                in_kernel,
2571     cl_device_id             in_device,
2572     cl_kernel_sub_group_info param_name,
2573     size_t                   input_value_size,
2574     const void *             input_value,
2575     size_t                   param_value_size,
2576     void *                   param_value,
2577     size_t *                 param_value_size_ret) CL_EXT_SUFFIX__VERSION_2_0
2578 {
2579     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_kernel, CL_INVALID_KERNEL);
2580     return in_kernel->dispatch->clGetKernelSubGroupInfoKHR(
2581             in_kernel,
2582             in_device,
2583             param_name,
2584             input_value_size,
2585             input_value,
2586             param_value_size,
2587             param_value,
2588             param_value_size_ret);
2589 }
2590
2591 CL_API_ENTRY cl_int CL_API_CALL
2592 clSetDefaultDeviceCommandQueue(
2593     cl_context context,
2594     cl_device_id device,
2595     cl_command_queue command_queue) CL_API_SUFFIX__VERSION_2_1
2596 {
2597     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
2598     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
2599     return context->dispatch->clSetDefaultDeviceCommandQueue(
2600             context,
2601             device,
2602             command_queue);
2603 }
2604
2605 CL_API_ENTRY cl_program CL_API_CALL
2606 clCreateProgramWithIL(
2607     cl_context context,
2608     const void * il,
2609     size_t length,
2610     cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_1
2611 {
2612     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2613     return context->dispatch->clCreateProgramWithIL(
2614             context,
2615             il,
2616             length,
2617             errcode_ret);
2618 }
2619
2620 CL_API_ENTRY cl_int CL_API_CALL
2621 clGetKernelSubGroupInfo(
2622     cl_kernel kernel,
2623     cl_device_id device,
2624     cl_kernel_sub_group_info param_name,
2625     size_t input_value_size,
2626     const void * input_value,
2627     size_t param_value_size,
2628     void * param_value,
2629     size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_2_1
2630 {
2631     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
2632     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
2633     return kernel->dispatch->clGetKernelSubGroupInfo(
2634             kernel,
2635             device,
2636             param_name,
2637             input_value_size,
2638             input_value,
2639             param_value_size,
2640             param_value,
2641             param_value_size_ret);
2642 }
2643
2644 CL_API_ENTRY cl_kernel CL_API_CALL
2645 clCloneKernel(
2646     cl_kernel source_kernel,
2647     cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_1
2648 {
2649     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(source_kernel, CL_INVALID_KERNEL);
2650     return source_kernel->dispatch->clCloneKernel(
2651             source_kernel,
2652             errcode_ret);
2653 }
2654
2655 CL_API_ENTRY cl_int CL_API_CALL
2656 clEnqueueSVMMigrateMem(
2657     cl_command_queue command_queue,
2658     cl_uint num_svm_pointers,
2659     const void ** svm_pointers,
2660     const size_t * sizes,
2661     cl_mem_migration_flags flags,
2662     cl_uint num_events_in_wait_list,
2663     const cl_event * event_wait_list,
2664     cl_event * event) CL_API_SUFFIX__VERSION_2_1
2665 {
2666     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2667     return command_queue->dispatch->clEnqueueSVMMigrateMem(
2668             command_queue,
2669             num_svm_pointers,
2670             svm_pointers,
2671             sizes,
2672             flags,
2673             num_events_in_wait_list,
2674             event_wait_list,
2675             event);
2676 }
2677
2678 CL_API_ENTRY cl_int CL_API_CALL
2679 clGetDeviceAndHostTimer(
2680     cl_device_id device,
2681     cl_ulong * device_timestamp,
2682     cl_ulong * host_timestamp) CL_API_SUFFIX__VERSION_2_1
2683 {
2684     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
2685     return device->dispatch->clGetDeviceAndHostTimer(
2686             device,
2687             device_timestamp,
2688             host_timestamp);
2689 }
2690
2691 CL_API_ENTRY cl_int CL_API_CALL
2692 clGetHostTimer(
2693     cl_device_id device,
2694     cl_ulong * host_timestamp) CL_API_SUFFIX__VERSION_2_1
2695 {
2696     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
2697     return device->dispatch->clGetHostTimer(
2698             device,
2699             host_timestamp);
2700 }
2701
2702