icd_dispatch.c

   1 /*
   2  * Copyright (c) 2016 The Khronos Group Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software source and associated documentation files (the "Materials"),
   6  * to deal in the Materials without restriction, including without limitation
   7  * the rights to use, copy, modify, compile, merge, publish, distribute,
   8  * sublicense, and/or sell copies of the Materials, and to permit persons to
   9  * whom the Materials are furnished to do so, subject the following terms and
  10  * conditions:
  11  *
  12  * All modifications to the Materials used to create a binary that is
  13  * distributed to third parties shall be provided to Khronos with an
  14  * unrestricted license to use for the purposes of implementing bug fixes and
  15  * enhancements to the Materials;
  16  *
  17  * If the binary is used as part of an OpenCL(TM) implementation, whether binary
  18  * is distributed together with or separately to that implementation, then
  19  * recipient must become an OpenCL Adopter and follow the published OpenCL
  20  * conformance process for that implementation, details at:
  21  * http://www.khronos.org/conformance/;
  22  *
  23  * The above copyright notice, the OpenCL trademark license, and this permission
  24  * notice shall be included in all copies or substantial portions of the
  25  * Materials.
  26  *
  27  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  28  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  29  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  30  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  31  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  32  * OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS IN
  33  * THE MATERIALS.
  34  *
  35  * OpenCL is a trademark of Apple Inc. used under license by Khronos.
  36  */
  37
  38 #include "icd_dispatch.h"
  39 #include "icd.h"
  40 #include <stdlib.h>
  41 #include <string.h>
  42
  43 // Platform APIs
  44 CL_API_ENTRY cl_int CL_API_CALL
  45 clGetPlatformIDs(cl_uint          num_entries,
  46                  cl_platform_id * platforms,
  47                  cl_uint *        num_platforms) CL_API_SUFFIX__VERSION_1_0
  48 {
  49     KHRicdVendor* vendor = NULL;
  50     cl_uint i;
  51
  52     // initialize the platforms (in case they have not been already)
  53     khrIcdInitialize();
  54
  55     if (!num_entries && platforms)
  56     {
  57         return CL_INVALID_VALUE;
  58     }
  59     if (!platforms && !num_platforms)
  60     {
  61         return CL_INVALID_VALUE;
  62     }
  63     // set num_platforms to 0 and set all platform pointers to NULL
  64     if (num_platforms)
  65     {
  66         *num_platforms = 0;
  67     }
  68     for (i = 0; i < num_entries && platforms; ++i)
  69     {
  70         platforms[i] = NULL;
  71     }
  72     // return error if we have no platforms
  73     if (!khrIcdVendors)
  74     {
  75         return CL_PLATFORM_NOT_FOUND_KHR;
  76     }
  77     // otherwise enumerate all platforms
  78     for (vendor = khrIcdVendors; vendor; vendor = vendor->next)
  79     {
  80         if (num_entries && platforms)
  81         {
  82             *(platforms++) = vendor->platform;
  83             --num_entries;
  84         }
  85         if (num_platforms)
  86         {
  87             ++(*num_platforms);
  88         }
  89     }
  90     return CL_SUCCESS;
  91 }
  92
  93 CL_API_ENTRY cl_int CL_API_CALL
  94 clGetPlatformInfo(cl_platform_id   platform,
  95                   cl_platform_info param_name,
  96                   size_t           param_value_size,
  97                   void *           param_value,
  98                   size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
  99 {
 100     // initialize the platforms (in case they have not been already)
 101     khrIcdInitialize();
 102     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
 103     return platform->dispatch->clGetPlatformInfo(
 104         platform,
 105         param_name,
 106         param_value_size,
 107         param_value,
 108         param_value_size_ret);
 109 }
 110
 111 // Device APIs
 112 CL_API_ENTRY cl_int CL_API_CALL
 113 clGetDeviceIDs(cl_platform_id   platform,
 114                cl_device_type   device_type,
 115                cl_uint          num_entries,
 116                cl_device_id *   devices,
 117                cl_uint *        num_devices) CL_API_SUFFIX__VERSION_1_0
 118 {
 119     // initialize the platforms (in case they have not been already)
 120     khrIcdInitialize();
 121     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
 122     return platform->dispatch->clGetDeviceIDs(
 123         platform,
 124         device_type,
 125         num_entries,
 126         devices,
 127         num_devices);
 128 }
 129
 130 CL_API_ENTRY cl_int CL_API_CALL
 131 clGetDeviceInfo(
 132     cl_device_id    device,
 133     cl_device_info  param_name,
 134     size_t          param_value_size,
 135     void *          param_value,
 136     size_t *        param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 137 {
 138     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
 139     return device->dispatch->clGetDeviceInfo(
 140         device,
 141         param_name,
 142         param_value_size,
 143         param_value,
 144         param_value_size_ret);
 145 }
 146
 147 CL_API_ENTRY cl_int CL_API_CALL
 148 clCreateSubDevices(cl_device_id                         in_device,
 149                    const cl_device_partition_property * properties,
 150                    cl_uint                              num_entries,
 151                    cl_device_id *                       out_devices,
 152                    cl_uint *                            num_devices) CL_API_SUFFIX__VERSION_1_2
 153 {
 154     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
 155     return in_device->dispatch->clCreateSubDevices(
 156         in_device,
 157         properties,
 158         num_entries,
 159         out_devices,
 160         num_devices);
 161 }
 162
 163 CL_API_ENTRY cl_int CL_API_CALL
 164 clRetainDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2
 165 {
 166     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
 167     return device->dispatch->clRetainDevice(device);
 168 }
 169
 170 CL_API_ENTRY cl_int CL_API_CALL
 171 clReleaseDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2
 172 {
 173     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
 174     return device->dispatch->clReleaseDevice(device);
 175 }
 176
 177 // Context APIs
 178 CL_API_ENTRY cl_context CL_API_CALL
 179 clCreateContext(const cl_context_properties * properties,
 180                 cl_uint                 num_devices,
 181                 const cl_device_id *    devices,
 182                 void (CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *),
 183                 void *                  user_data,
 184                 cl_int *                errcode_ret) CL_API_SUFFIX__VERSION_1_0
 185 {
 186     // initialize the platforms (in case they have not been already)
 187     khrIcdInitialize();
 188     if (!num_devices || !devices)
 189     {
 190         if (errcode_ret)
 191         {
 192             *errcode_ret = CL_INVALID_VALUE;
 193         }
 194         return NULL;
 195     }
 196     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(devices[0], CL_INVALID_DEVICE);
 197     return devices[0]->dispatch->clCreateContext(
 198         properties,
 199         num_devices,
 200         devices,
 201         pfn_notify,
 202         user_data,
 203         errcode_ret);
 204 }
 205
 206 CL_API_ENTRY cl_context CL_API_CALL
 207 clCreateContextFromType(const cl_context_properties * properties,
 208                         cl_device_type          device_type,
 209                         void (CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *),
 210                         void *                  user_data,
 211                         cl_int *                errcode_ret) CL_API_SUFFIX__VERSION_1_0
 212 {
 213     cl_platform_id platform = NULL;
 214
 215     // initialize the platforms (in case they have not been already)
 216     khrIcdInitialize();
 217
 218     // determine the platform to use from the properties specified
 219     khrIcdContextPropertiesGetPlatform(properties, &platform);
 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     // make sure the ICD is initialized
1382     khrIcdInitialize();
1383
1384     // return any ICD-aware extensions
1385     #define CL_COMMON_EXTENSION_ENTRYPOINT_ADD(name) if (!strcmp(function_name, #name) ) return (void *)(size_t)&name
1386
1387     // Are these core or ext?  This is unclear, but they appear to be
1388     // independent from cl_khr_gl_sharing.
1389     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLBuffer);
1390     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture);
1391     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture2D);
1392     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture3D);
1393     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLRenderbuffer);
1394     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLObjectInfo);
1395     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLTextureInfo);
1396     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireGLObjects);
1397     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseGLObjects);
1398
1399     // cl_khr_gl_sharing
1400     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLContextInfoKHR);
1401
1402     // cl_khr_gl_event
1403     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromGLsyncKHR);
1404
1405 #if defined(_WIN32)
1406     // cl_khr_d3d10_sharing
1407     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D10KHR);
1408     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10BufferKHR);
1409     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture2DKHR);
1410     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture3DKHR);
1411     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D10ObjectsKHR);
1412     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D10ObjectsKHR);
1413     // cl_khr_d3d11_sharing
1414     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D11KHR);
1415     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11BufferKHR);
1416     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture2DKHR);
1417     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture3DKHR);
1418     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D11ObjectsKHR);
1419     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D11ObjectsKHR);
1420     // cl_khr_dx9_media_sharing
1421     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromDX9MediaAdapterKHR);
1422     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromDX9MediaSurfaceKHR);
1423     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireDX9MediaSurfacesKHR);
1424     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseDX9MediaSurfacesKHR);
1425 #endif
1426
1427     // cl_ext_device_fission
1428     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateSubDevicesEXT);
1429     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clRetainDeviceEXT);
1430     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clReleaseDeviceEXT);
1431
1432     /* cl_khr_egl_image */
1433     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromEGLImageKHR);
1434     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireEGLObjectsKHR);
1435     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseEGLObjectsKHR);
1436
1437     /* cl_khr_egl_event */
1438     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromEGLSyncKHR);
1439
1440     /* cl_khr_sub_groups */
1441     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetKernelSubGroupInfoKHR);
1442
1443     // fall back to vendor extension detection
1444
1445     // FIXME Now that we have a platform id here, we need to validate that it isn't NULL, so shouldn't we have an errcode_ret
1446     // KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(platform, CL_INVALID_PLATFORM);
1447     return platform->dispatch->clGetExtensionFunctionAddressForPlatform(
1448         platform,
1449         function_name);
1450 }
1451
1452 // Deprecated APIs
1453 CL_API_ENTRY cl_int CL_API_CALL
1454 clSetCommandQueueProperty(cl_command_queue              command_queue,
1455                           cl_command_queue_properties   properties,
1456                           cl_bool                       enable,
1457                           cl_command_queue_properties * old_properties) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED
1458 {
1459     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1460     return command_queue->dispatch->clSetCommandQueueProperty(
1461         command_queue,
1462         properties,
1463         enable,
1464         old_properties);
1465 }
1466
1467 CL_API_ENTRY cl_int CL_API_CALL
1468 clCreateSubDevicesEXT(
1469     cl_device_id in_device,
1470     const cl_device_partition_property_ext * partition_properties,
1471     cl_uint num_entries,
1472     cl_device_id * out_devices,
1473     cl_uint * num_devices) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1474 {
1475     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
1476         return in_device->dispatch->clCreateSubDevicesEXT(
1477         in_device,
1478         partition_properties,
1479         num_entries,
1480         out_devices,
1481         num_devices);
1482 }
1483
1484 CL_API_ENTRY cl_int CL_API_CALL
1485 clRetainDeviceEXT(cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1486 {
1487     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
1488     return device->dispatch->clRetainDeviceEXT(device);
1489 }
1490
1491 CL_API_ENTRY cl_int CL_API_CALL
1492 clReleaseDeviceEXT(cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1493 {
1494     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
1495     return device->dispatch->clReleaseDeviceEXT(device);
1496 }
1497
1498 CL_API_ENTRY cl_mem CL_API_CALL
1499 clCreateImage2D(cl_context              context,
1500                 cl_mem_flags            flags,
1501                 const cl_image_format * image_format,
1502                 size_t                  image_width,
1503                 size_t                  image_height,
1504                 size_t                  image_row_pitch,
1505                 void *                  host_ptr,
1506                 cl_int *                errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1507 {
1508     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1509     return context->dispatch->clCreateImage2D(
1510         context,
1511         flags,
1512         image_format,
1513         image_width,
1514         image_height,
1515         image_row_pitch,
1516         host_ptr,
1517         errcode_ret);
1518 }
1519
1520 CL_API_ENTRY cl_mem CL_API_CALL
1521 clCreateImage3D(cl_context              context,
1522                 cl_mem_flags            flags,
1523                 const cl_image_format * image_format,
1524                 size_t                  image_width,
1525                 size_t                  image_height,
1526                 size_t                  image_depth,
1527                 size_t                  image_row_pitch,
1528                 size_t                  image_slice_pitch,
1529                 void *                  host_ptr,
1530                 cl_int *                errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1531 {
1532     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1533     return context->dispatch->clCreateImage3D(
1534         context,
1535         flags,
1536         image_format,
1537         image_width,
1538         image_height,
1539         image_depth,
1540         image_row_pitch,
1541         image_slice_pitch,
1542         host_ptr,
1543         errcode_ret);
1544 }
1545
1546 CL_API_ENTRY cl_int CL_API_CALL
1547 clUnloadCompiler(void) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1548 {
1549     return CL_SUCCESS;
1550 }
1551
1552 CL_API_ENTRY cl_int CL_API_CALL
1553 clEnqueueMarker(cl_command_queue    command_queue,
1554                 cl_event *          event) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1555 {
1556     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1557     return command_queue->dispatch->clEnqueueMarker(
1558         command_queue,
1559         event);
1560 }
1561
1562 CL_API_ENTRY cl_int CL_API_CALL
1563 clEnqueueWaitForEvents(cl_command_queue command_queue,
1564                        cl_uint          num_events,
1565                        const cl_event * event_list) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1566 {
1567     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1568     return command_queue->dispatch->clEnqueueWaitForEvents(
1569         command_queue,
1570         num_events,
1571         event_list);
1572 }
1573
1574 CL_API_ENTRY cl_int CL_API_CALL
1575 clEnqueueBarrier(cl_command_queue command_queue) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1576 {
1577     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1578     return command_queue->dispatch->clEnqueueBarrier(command_queue);
1579 }
1580
1581 CL_API_ENTRY void * CL_API_CALL
1582 clGetExtensionFunctionAddress(const char *function_name) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1583 {
1584     size_t function_name_length = strlen(function_name);
1585     KHRicdVendor* vendor = NULL;
1586
1587     // make sure the ICD is initialized
1588     khrIcdInitialize();
1589
1590     // return any ICD-aware extensions
1591     #define CL_COMMON_EXTENSION_ENTRYPOINT_ADD(name) if (!strcmp(function_name, #name) ) return (void *)(size_t)&name
1592
1593     // Are these core or ext?  This is unclear, but they appear to be
1594     // independent from cl_khr_gl_sharing.
1595     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLBuffer);
1596     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture);
1597     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture2D);
1598     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture3D);
1599     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLRenderbuffer);
1600     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLObjectInfo);
1601     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLTextureInfo);
1602     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireGLObjects);
1603     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseGLObjects);
1604
1605     // cl_khr_gl_sharing
1606     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLContextInfoKHR);
1607
1608     // cl_khr_gl_event
1609     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromGLsyncKHR);
1610
1611 #if defined(_WIN32)
1612     // cl_khr_d3d10_sharing
1613     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D10KHR);
1614     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10BufferKHR);
1615     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture2DKHR);
1616     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture3DKHR);
1617     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D10ObjectsKHR);
1618     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D10ObjectsKHR);
1619     // cl_khr_d3d11_sharing
1620     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D11KHR);
1621     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11BufferKHR);
1622     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture2DKHR);
1623     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture3DKHR);
1624     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D11ObjectsKHR);
1625     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D11ObjectsKHR);
1626     // cl_khr_dx9_media_sharing
1627     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromDX9MediaAdapterKHR);
1628     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromDX9MediaSurfaceKHR);
1629     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireDX9MediaSurfacesKHR);
1630     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseDX9MediaSurfacesKHR);
1631 #endif
1632
1633     // cl_ext_device_fission
1634     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateSubDevicesEXT);
1635     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clRetainDeviceEXT);
1636     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clReleaseDeviceEXT);
1637
1638     /* cl_khr_egl_image */
1639     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromEGLImageKHR);
1640     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireEGLObjectsKHR);
1641     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseEGLObjectsKHR);
1642
1643     /* cl_khr_egl_event */
1644     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromEGLSyncKHR);
1645
1646     /* cl_khr_sub_groups */
1647     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetKernelSubGroupInfoKHR);
1648
1649     // fall back to vendor extension detection
1650     for (vendor = khrIcdVendors; vendor; vendor = vendor->next)
1651     {
1652         size_t vendor_suffix_length = strlen(vendor->suffix);
1653         if (vendor_suffix_length <= function_name_length && vendor_suffix_length > 0)
1654         {
1655             const char *function_suffix = function_name+function_name_length-vendor_suffix_length;
1656             if (!strcmp(function_suffix, vendor->suffix) )
1657             {
1658                 return vendor->clGetExtensionFunctionAddress(function_name);
1659             }
1660         }
1661     }
1662     return NULL;
1663 }
1664
1665 // GL and other APIs
1666 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer(
1667     cl_context    context,
1668     cl_mem_flags  flags,
1669     GLuint        bufobj,
1670     int *         errcode_ret) CL_API_SUFFIX__VERSION_1_0
1671 {
1672     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1673     return context->dispatch->clCreateFromGLBuffer(
1674         context,
1675         flags,
1676         bufobj,
1677         errcode_ret);
1678 }
1679
1680 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture(
1681     cl_context      context,
1682     cl_mem_flags    flags,
1683     cl_GLenum       target,
1684     cl_GLint        miplevel,
1685     cl_GLuint       texture,
1686     cl_int *        errcode_ret) CL_API_SUFFIX__VERSION_1_2
1687 {
1688     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1689     return context->dispatch->clCreateFromGLTexture(
1690         context,
1691         flags,
1692         target,
1693         miplevel,
1694         texture,
1695         errcode_ret);
1696 }
1697
1698 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D(
1699     cl_context      context,
1700     cl_mem_flags    flags,
1701     GLenum          target,
1702     GLint           miplevel,
1703     GLuint          texture,
1704     cl_int *        errcode_ret) CL_API_SUFFIX__VERSION_1_0
1705 {
1706     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1707     return context->dispatch->clCreateFromGLTexture2D(
1708         context,
1709         flags,
1710         target,
1711         miplevel,
1712         texture,
1713         errcode_ret);
1714 }
1715
1716 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D(
1717     cl_context      context,
1718     cl_mem_flags    flags,
1719     GLenum          target,
1720     GLint           miplevel,
1721     GLuint          texture,
1722     cl_int *        errcode_ret) CL_API_SUFFIX__VERSION_1_0
1723 {
1724     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1725     return context->dispatch->clCreateFromGLTexture3D(
1726         context,
1727         flags,
1728         target,
1729         miplevel,
1730         texture,
1731         errcode_ret);
1732 }
1733
1734 CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer(
1735     cl_context           context,
1736     cl_mem_flags         flags,
1737     GLuint               renderbuffer,
1738     cl_int *             errcode_ret) CL_API_SUFFIX__VERSION_1_0
1739 {
1740     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1741     return context->dispatch->clCreateFromGLRenderbuffer(
1742         context,
1743         flags,
1744         renderbuffer,
1745         errcode_ret);
1746 }
1747
1748 CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo(
1749     cl_mem               memobj,
1750     cl_gl_object_type *  gl_object_type,
1751     GLuint *             gl_object_name) CL_API_SUFFIX__VERSION_1_0
1752 {
1753     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
1754     return memobj->dispatch->clGetGLObjectInfo(
1755         memobj,
1756         gl_object_type,
1757         gl_object_name);
1758 }
1759
1760 CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo(
1761     cl_mem               memobj,
1762     cl_gl_texture_info   param_name,
1763     size_t               param_value_size,
1764     void *               param_value,
1765     size_t *             param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
1766 {
1767     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
1768     return memobj->dispatch->clGetGLTextureInfo(
1769         memobj,
1770         param_name,
1771         param_value_size,
1772         param_value,
1773         param_value_size_ret);
1774 }
1775
1776 CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects(
1777     cl_command_queue     command_queue,
1778     cl_uint              num_objects,
1779     const cl_mem *       mem_objects,
1780     cl_uint              num_events_in_wait_list,
1781     const cl_event *     event_wait_list,
1782     cl_event *           event) CL_API_SUFFIX__VERSION_1_0
1783 {
1784     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1785     return command_queue->dispatch->clEnqueueAcquireGLObjects(
1786         command_queue,
1787         num_objects,
1788         mem_objects,
1789         num_events_in_wait_list,
1790         event_wait_list,
1791         event);
1792 }
1793
1794 CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects(
1795     cl_command_queue     command_queue,
1796     cl_uint              num_objects,
1797     const cl_mem *       mem_objects,
1798     cl_uint              num_events_in_wait_list,
1799     const cl_event *     event_wait_list,
1800     cl_event *           event) CL_API_SUFFIX__VERSION_1_0
1801 {
1802     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1803     return command_queue->dispatch->clEnqueueReleaseGLObjects(
1804         command_queue,
1805         num_objects,
1806         mem_objects,
1807         num_events_in_wait_list,
1808         event_wait_list,
1809         event);
1810 }
1811
1812 CL_API_ENTRY cl_int CL_API_CALL clGetGLContextInfoKHR(
1813     const cl_context_properties *properties,
1814     cl_gl_context_info param_name,
1815     size_t param_value_size,
1816     void *param_value,
1817     size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
1818 {
1819     cl_platform_id platform = NULL;
1820
1821     // initialize the platforms (in case they have not been already)
1822     khrIcdInitialize();
1823
1824     // determine the platform to use from the properties specified
1825     khrIcdContextPropertiesGetPlatform(properties, &platform);
1826
1827     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
1828     return platform->dispatch->clGetGLContextInfoKHR(
1829         properties,
1830         param_name,
1831         param_value_size,
1832         param_value,
1833         param_value_size_ret);
1834 }
1835
1836 CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR(
1837         cl_context context,
1838         cl_GLsync sync,
1839         cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1
1840 {
1841         KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1842         return context->dispatch->clCreateEventFromGLsyncKHR(
1843                 context,
1844                 sync,
1845                 errcode_ret);
1846 }
1847
1848 #if defined(_WIN32)
1849 /*
1850  *
1851  * cl_d3d10_sharing_khr
1852  *
1853  */
1854
1855 CL_API_ENTRY cl_int CL_API_CALL
1856 clGetDeviceIDsFromD3D10KHR(
1857     cl_platform_id platform,
1858     cl_d3d10_device_source_khr d3d_device_source,
1859     void *d3d_object,
1860     cl_d3d10_device_set_khr d3d_device_set,
1861     cl_uint num_entries,
1862     cl_device_id *devices,
1863     cl_uint *num_devices)
1864 {
1865     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
1866     return platform->dispatch->clGetDeviceIDsFromD3D10KHR(
1867         platform,
1868         d3d_device_source,
1869         d3d_object,
1870         d3d_device_set,
1871         num_entries,
1872         devices,
1873         num_devices);
1874 }
1875
1876 CL_API_ENTRY cl_mem CL_API_CALL
1877 clCreateFromD3D10BufferKHR(
1878     cl_context context,
1879     cl_mem_flags flags,
1880     ID3D10Buffer *resource,
1881     cl_int *errcode_ret)
1882 {
1883     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1884     return context->dispatch->clCreateFromD3D10BufferKHR(
1885         context,
1886         flags,
1887         resource,
1888         errcode_ret);
1889 }
1890
1891 CL_API_ENTRY cl_mem CL_API_CALL
1892 clCreateFromD3D10Texture2DKHR(
1893     cl_context        context,
1894     cl_mem_flags      flags,
1895     ID3D10Texture2D * resource,
1896     UINT              subresource,
1897     cl_int *          errcode_ret)
1898 {
1899     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1900     return context->dispatch->clCreateFromD3D10Texture2DKHR(
1901         context,
1902         flags,
1903         resource,
1904         subresource,
1905         errcode_ret);
1906 }
1907
1908 CL_API_ENTRY cl_mem CL_API_CALL
1909 clCreateFromD3D10Texture3DKHR(
1910     cl_context context,
1911     cl_mem_flags flags,
1912     ID3D10Texture3D *resource,
1913     UINT subresource,
1914     cl_int *errcode_ret)
1915 {
1916     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1917     return context->dispatch->clCreateFromD3D10Texture3DKHR(
1918         context,
1919         flags,
1920         resource,
1921         subresource,
1922         errcode_ret);
1923 }
1924
1925 CL_API_ENTRY cl_int CL_API_CALL
1926 clEnqueueAcquireD3D10ObjectsKHR(
1927     cl_command_queue command_queue,
1928     cl_uint num_objects,
1929     const cl_mem *mem_objects,
1930     cl_uint num_events_in_wait_list,
1931     const cl_event *event_wait_list,
1932     cl_event *event)
1933 {
1934     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1935     return command_queue->dispatch->clEnqueueAcquireD3D10ObjectsKHR(
1936         command_queue,
1937         num_objects,
1938         mem_objects,
1939         num_events_in_wait_list,
1940         event_wait_list,
1941         event);
1942 }
1943
1944 CL_API_ENTRY cl_int CL_API_CALL
1945 clEnqueueReleaseD3D10ObjectsKHR(
1946     cl_command_queue command_queue,
1947     cl_uint num_objects,
1948     const cl_mem *mem_objects,
1949     cl_uint num_events_in_wait_list,
1950     const cl_event *event_wait_list,
1951     cl_event *event)
1952 {
1953     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1954     return command_queue->dispatch->clEnqueueReleaseD3D10ObjectsKHR(
1955         command_queue,
1956         num_objects,
1957         mem_objects,
1958         num_events_in_wait_list,
1959         event_wait_list,
1960         event);
1961 }
1962
1963 /*
1964  *
1965  * cl_d3d11_sharing_khr
1966  *
1967  */
1968
1969 CL_API_ENTRY cl_int CL_API_CALL
1970 clGetDeviceIDsFromD3D11KHR(
1971     cl_platform_id             platform,
1972     cl_d3d11_device_source_khr d3d_device_source,
1973     void *                     d3d_object,
1974     cl_d3d11_device_set_khr    d3d_device_set,
1975     cl_uint                    num_entries,
1976     cl_device_id *             devices,
1977     cl_uint *                  num_devices)
1978 {
1979     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
1980     return platform->dispatch->clGetDeviceIDsFromD3D11KHR(
1981         platform,
1982         d3d_device_source,
1983         d3d_object,
1984         d3d_device_set,
1985         num_entries,
1986         devices,
1987         num_devices);
1988 }
1989
1990 CL_API_ENTRY cl_mem CL_API_CALL
1991 clCreateFromD3D11BufferKHR(
1992     cl_context     context,
1993     cl_mem_flags   flags,
1994     ID3D11Buffer * resource,
1995     cl_int *       errcode_ret)
1996 {
1997     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1998     return context->dispatch->clCreateFromD3D11BufferKHR(
1999         context,
2000         flags,
2001         resource,
2002         errcode_ret);
2003 }
2004
2005 CL_API_ENTRY cl_mem CL_API_CALL
2006 clCreateFromD3D11Texture2DKHR(
2007     cl_context        context,
2008     cl_mem_flags      flags,
2009     ID3D11Texture2D * resource,
2010     UINT              subresource,
2011     cl_int *          errcode_ret)
2012 {
2013     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2014     return context->dispatch->clCreateFromD3D11Texture2DKHR(
2015         context,
2016         flags,
2017         resource,
2018         subresource,
2019         errcode_ret);
2020 }
2021
2022 CL_API_ENTRY cl_mem CL_API_CALL
2023 clCreateFromD3D11Texture3DKHR(
2024     cl_context        context,
2025     cl_mem_flags      flags,
2026     ID3D11Texture3D * resource,
2027     UINT              subresource,
2028     cl_int *          errcode_ret)
2029 {
2030     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2031     return context->dispatch->clCreateFromD3D11Texture3DKHR(
2032         context,
2033         flags,
2034         resource,
2035         subresource,
2036         errcode_ret);
2037 }
2038
2039 CL_API_ENTRY cl_int CL_API_CALL
2040 clEnqueueAcquireD3D11ObjectsKHR(
2041     cl_command_queue command_queue,
2042     cl_uint          num_objects,
2043     const cl_mem *   mem_objects,
2044     cl_uint          num_events_in_wait_list,
2045     const cl_event * event_wait_list,
2046     cl_event *       event)
2047 {
2048     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2049     return command_queue->dispatch->clEnqueueAcquireD3D11ObjectsKHR(
2050         command_queue,
2051         num_objects,
2052         mem_objects,
2053         num_events_in_wait_list,
2054         event_wait_list,
2055         event);
2056 }
2057
2058 CL_API_ENTRY cl_int CL_API_CALL
2059 clEnqueueReleaseD3D11ObjectsKHR(
2060     cl_command_queue command_queue,
2061     cl_uint          num_objects,
2062     const cl_mem *   mem_objects,
2063     cl_uint          num_events_in_wait_list,
2064     const cl_event * event_wait_list,
2065     cl_event *       event)
2066 {
2067     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2068     return command_queue->dispatch->clEnqueueReleaseD3D11ObjectsKHR(
2069         command_queue,
2070         num_objects,
2071         mem_objects,
2072         num_events_in_wait_list,
2073         event_wait_list,
2074         event);
2075 }
2076
2077 /*
2078  *
2079  * cl_khr_dx9_media_sharing
2080  *
2081  */
2082
2083 CL_API_ENTRY cl_int CL_API_CALL
2084 clGetDeviceIDsFromDX9MediaAdapterKHR(
2085     cl_platform_id                  platform,
2086     cl_uint                         num_media_adapters,
2087     cl_dx9_media_adapter_type_khr * media_adapters_type,
2088     void *                          media_adapters,
2089     cl_dx9_media_adapter_set_khr    media_adapter_set,
2090     cl_uint                         num_entries,
2091     cl_device_id *                  devices,
2092     cl_uint *                       num_devices)
2093 {
2094     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
2095     return platform->dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR(
2096         platform,
2097         num_media_adapters,
2098                 media_adapters_type,
2099         media_adapters,
2100         media_adapter_set,
2101         num_entries,
2102         devices,
2103         num_devices);
2104 }
2105
2106 CL_API_ENTRY cl_mem CL_API_CALL
2107 clCreateFromDX9MediaSurfaceKHR(
2108     cl_context                    context,
2109     cl_mem_flags                  flags,
2110     cl_dx9_media_adapter_type_khr adapter_type,
2111     void *                        surface_info,
2112     cl_uint                       plane,
2113     cl_int *                      errcode_ret)
2114 {
2115     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2116     return context->dispatch->clCreateFromDX9MediaSurfaceKHR(
2117         context,
2118         flags,
2119         adapter_type,
2120         surface_info,
2121         plane,
2122         errcode_ret);
2123 }
2124
2125 CL_API_ENTRY cl_int CL_API_CALL
2126 clEnqueueAcquireDX9MediaSurfacesKHR(
2127     cl_command_queue command_queue,
2128     cl_uint          num_objects,
2129     const cl_mem *   mem_objects,
2130     cl_uint          num_events_in_wait_list,
2131     const cl_event * event_wait_list,
2132     cl_event *       event)
2133 {
2134     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2135     return command_queue->dispatch->clEnqueueAcquireDX9MediaSurfacesKHR(
2136         command_queue,
2137         num_objects,
2138         mem_objects,
2139         num_events_in_wait_list,
2140         event_wait_list,
2141         event);
2142 }
2143
2144 CL_API_ENTRY cl_int CL_API_CALL
2145 clEnqueueReleaseDX9MediaSurfacesKHR(
2146     cl_command_queue command_queue,
2147     cl_uint          num_objects,
2148     const cl_mem *   mem_objects,
2149     cl_uint          num_events_in_wait_list,
2150     const cl_event * event_wait_list,
2151     cl_event *       event)
2152 {
2153     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2154     return command_queue->dispatch->clEnqueueReleaseDX9MediaSurfacesKHR(
2155         command_queue,
2156         num_objects,
2157         mem_objects,
2158         num_events_in_wait_list,
2159         event_wait_list,
2160         event);
2161 }
2162
2163 #endif
2164
2165 CL_API_ENTRY cl_int CL_API_CALL
2166 clSetEventCallback(
2167     cl_event event,
2168     cl_int command_exec_callback_type,
2169     void (CL_CALLBACK *pfn_notify)(cl_event, cl_int, void *),
2170     void *user_data) CL_API_SUFFIX__VERSION_1_1
2171 {
2172     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
2173     return event->dispatch->clSetEventCallback(
2174         event,
2175         command_exec_callback_type,
2176         pfn_notify,
2177         user_data);
2178 }
2179
2180 CL_API_ENTRY cl_mem CL_API_CALL
2181 clCreateSubBuffer(
2182     cl_mem buffer,
2183     cl_mem_flags flags,
2184     cl_buffer_create_type buffer_create_type,
2185     const void * buffer_create_info,
2186     cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1
2187 {
2188     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(buffer, CL_INVALID_MEM_OBJECT);
2189     return buffer->dispatch->clCreateSubBuffer(
2190         buffer,
2191         flags,
2192         buffer_create_type,
2193         buffer_create_info,
2194         errcode_ret);
2195 }
2196
2197 CL_API_ENTRY cl_int CL_API_CALL
2198 clSetMemObjectDestructorCallback(
2199     cl_mem memobj,
2200     void (CL_CALLBACK * pfn_notify)( cl_mem, void*),
2201     void * user_data )             CL_API_SUFFIX__VERSION_1_1
2202 {
2203     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
2204     return memobj->dispatch->clSetMemObjectDestructorCallback(
2205         memobj,
2206         pfn_notify,
2207         user_data);
2208 }
2209
2210 CL_API_ENTRY cl_event CL_API_CALL
2211 clCreateUserEvent(
2212     cl_context context,
2213     cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1
2214 {
2215     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2216     return context->dispatch->clCreateUserEvent(
2217         context,
2218         errcode_ret);
2219 }
2220
2221 CL_API_ENTRY cl_int CL_API_CALL
2222 clSetUserEventStatus(
2223     cl_event event,
2224     cl_int execution_status) CL_API_SUFFIX__VERSION_1_1
2225 {
2226     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
2227     return event->dispatch->clSetUserEventStatus(
2228         event,
2229         execution_status);
2230 }
2231
2232 CL_API_ENTRY cl_mem CL_API_CALL
2233 clCreateFromEGLImageKHR(
2234     cl_context context,
2235     CLeglDisplayKHR display,
2236     CLeglImageKHR image,
2237     cl_mem_flags flags,
2238     const cl_egl_image_properties_khr *properties,
2239     cl_int *errcode_ret)
2240 {
2241     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2242     return context->dispatch->clCreateFromEGLImageKHR(
2243         context,
2244         display,
2245         image,
2246         flags,
2247         properties,
2248         errcode_ret);
2249 }
2250
2251 CL_API_ENTRY cl_int CL_API_CALL
2252 clEnqueueAcquireEGLObjectsKHR(
2253     cl_command_queue command_queue,
2254     cl_uint num_objects,
2255     const cl_mem *mem_objects,
2256     cl_uint num_events_in_wait_list,
2257     const cl_event *event_wait_list,
2258     cl_event *event)
2259 {
2260     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2261     return command_queue->dispatch->clEnqueueAcquireEGLObjectsKHR(
2262         command_queue,
2263         num_objects,
2264         mem_objects,
2265         num_events_in_wait_list,
2266         event_wait_list,
2267         event);
2268 }
2269
2270 CL_API_ENTRY cl_int CL_API_CALL
2271 clEnqueueReleaseEGLObjectsKHR(
2272     cl_command_queue command_queue,
2273     cl_uint num_objects,
2274     const cl_mem *mem_objects,
2275     cl_uint num_events_in_wait_list,
2276     const cl_event *event_wait_list,
2277     cl_event *event)
2278 {
2279     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2280     return command_queue->dispatch->clEnqueueReleaseEGLObjectsKHR(
2281         command_queue,
2282         num_objects,
2283         mem_objects,
2284         num_events_in_wait_list,
2285         event_wait_list,
2286         event);
2287 }
2288
2289 /* cl_khr_egl_event */
2290 CL_API_ENTRY cl_event CL_API_CALL
2291 clCreateEventFromEGLSyncKHR(
2292     cl_context context,
2293     CLeglSyncKHR sync,
2294     CLeglDisplayKHR display,
2295     cl_int *errcode_ret)
2296 {
2297     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2298     return context->dispatch->clCreateEventFromEGLSyncKHR(
2299         context,
2300         sync,
2301         display,
2302         errcode_ret);
2303 }
2304
2305 CL_API_ENTRY cl_command_queue CL_API_CALL
2306 clCreateCommandQueueWithProperties(
2307     cl_context                  context,
2308     cl_device_id                device,
2309     const cl_queue_properties * properties,
2310     cl_int *                    errcode_ret) CL_API_SUFFIX__VERSION_2_0
2311 {
2312     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2313     return context->dispatch->clCreateCommandQueueWithProperties(
2314         context,
2315         device,
2316         properties,
2317         errcode_ret);
2318 }
2319
2320 CL_API_ENTRY cl_mem CL_API_CALL
2321 clCreatePipe(
2322     cl_context                 context,
2323     cl_mem_flags               flags,
2324     cl_uint                    pipe_packet_size,
2325     cl_uint                    pipe_max_packets,
2326     const cl_pipe_properties * properties,
2327     cl_int *                   errcode_ret) CL_API_SUFFIX__VERSION_2_0
2328 {
2329     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2330     return context->dispatch->clCreatePipe(
2331         context,
2332         flags,
2333         pipe_packet_size,
2334         pipe_max_packets,
2335         properties,
2336         errcode_ret);
2337 }
2338
2339 CL_API_ENTRY cl_int CL_API_CALL
2340 clGetPipeInfo(
2341     cl_mem       pipe,
2342     cl_pipe_info param_name,
2343     size_t       param_value_size,
2344     void *       param_value,
2345     size_t *     param_value_size_ret) CL_API_SUFFIX__VERSION_2_0
2346 {
2347     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(pipe, CL_INVALID_MEM_OBJECT);
2348     return pipe->dispatch->clGetPipeInfo(
2349         pipe,
2350         param_name,
2351         param_value_size,
2352         param_value,
2353         param_value_size_ret);
2354 }
2355
2356 CL_API_ENTRY void * CL_API_CALL
2357 clSVMAlloc(
2358     cl_context       context,
2359     cl_svm_mem_flags flags,
2360     size_t           size,
2361     cl_uint          alignment) CL_API_SUFFIX__VERSION_2_0
2362 {
2363     if (!context) {
2364         return NULL;
2365     }
2366     return context->dispatch->clSVMAlloc(
2367         context,
2368         flags,
2369         size,
2370         alignment);
2371 }
2372
2373 CL_API_ENTRY void CL_API_CALL
2374 clSVMFree(
2375     cl_context context,
2376     void *     svm_pointer) CL_API_SUFFIX__VERSION_2_0
2377 {
2378     if (!context || !svm_pointer) {
2379         return;
2380     }
2381     context->dispatch->clSVMFree(
2382         context,
2383         svm_pointer);
2384 }
2385
2386 CL_API_ENTRY cl_int CL_API_CALL
2387 clEnqueueSVMFree(
2388     cl_command_queue command_queue,
2389     cl_uint num_svm_pointers,
2390     void* svm_pointers[],
2391     void (CL_CALLBACK* pfn_free_func)(
2392         cl_command_queue queue,
2393         cl_uint num_svm_pointers,
2394         void* svm_pointers[],
2395         void* user_data),
2396     void* user_data,
2397     cl_uint num_events_in_wait_list,
2398     const cl_event* event_wait_list,
2399     cl_event* event) CL_API_SUFFIX__VERSION_2_0
2400 {
2401     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2402     return command_queue->dispatch->clEnqueueSVMFree(
2403         command_queue,
2404         num_svm_pointers,
2405         svm_pointers,
2406         pfn_free_func,
2407         user_data,
2408         num_events_in_wait_list,
2409         event_wait_list,
2410         event);
2411 }
2412
2413 CL_API_ENTRY cl_int CL_API_CALL
2414 clEnqueueSVMMemcpy(
2415     cl_command_queue  command_queue,
2416     cl_bool           blocking_copy,
2417     void *            dst_ptr,
2418     const void *      src_ptr,
2419     size_t            size,
2420     cl_uint           num_events_in_wait_list,
2421     const cl_event *  event_wait_list,
2422     cl_event *        event) CL_API_SUFFIX__VERSION_2_0
2423 {
2424     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2425     return command_queue->dispatch->clEnqueueSVMMemcpy(
2426         command_queue,
2427         blocking_copy,
2428         dst_ptr,
2429         src_ptr,
2430         size,
2431         num_events_in_wait_list,
2432         event_wait_list,
2433         event);
2434 }
2435
2436 CL_API_ENTRY cl_int CL_API_CALL
2437 clEnqueueSVMMemFill(
2438     cl_command_queue command_queue,
2439     void *           svm_ptr,
2440     const void *     pattern,
2441     size_t           pattern_size,
2442     size_t           size,
2443     cl_uint          num_events_in_wait_list,
2444     const cl_event * event_wait_list,
2445     cl_event *       event) CL_API_SUFFIX__VERSION_2_0
2446 {
2447     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2448     return command_queue->dispatch->clEnqueueSVMMemFill(
2449         command_queue,
2450         svm_ptr,
2451         pattern,
2452         pattern_size,
2453         size,
2454         num_events_in_wait_list,
2455         event_wait_list,
2456         event);
2457 }
2458
2459 CL_API_ENTRY cl_int CL_API_CALL
2460 clEnqueueSVMMap(
2461     cl_command_queue  command_queue,
2462     cl_bool           blocking_map,
2463     cl_map_flags      flags,
2464     void *            svm_ptr,
2465     size_t            size,
2466     cl_uint           num_events_in_wait_list,
2467     const cl_event *  event_wait_list,
2468     cl_event *        event) CL_API_SUFFIX__VERSION_2_0
2469 {
2470     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2471     return command_queue->dispatch->clEnqueueSVMMap(
2472         command_queue,
2473         blocking_map,
2474         flags,
2475         svm_ptr,
2476         size,
2477         num_events_in_wait_list,
2478         event_wait_list,
2479         event);
2480 }
2481
2482 CL_API_ENTRY cl_int CL_API_CALL
2483 clEnqueueSVMUnmap(
2484     cl_command_queue command_queue,
2485     void *           svm_ptr,
2486     cl_uint          num_events_in_wait_list,
2487     const cl_event * event_wait_list,
2488     cl_event *       event) CL_API_SUFFIX__VERSION_2_0
2489 {
2490     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2491     return command_queue->dispatch->clEnqueueSVMUnmap(
2492         command_queue,
2493         svm_ptr,
2494         num_events_in_wait_list,
2495         event_wait_list,
2496         event);
2497 }
2498
2499 CL_API_ENTRY cl_sampler CL_API_CALL
2500 clCreateSamplerWithProperties(
2501     cl_context                     context,
2502     const cl_sampler_properties *  sampler_properties,
2503     cl_int *                       errcode_ret) CL_API_SUFFIX__VERSION_2_0
2504 {
2505     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2506     return context->dispatch->clCreateSamplerWithProperties(
2507         context,
2508         sampler_properties,
2509         errcode_ret);
2510 }
2511
2512 CL_API_ENTRY cl_int CL_API_CALL
2513 clSetKernelArgSVMPointer(
2514     cl_kernel    kernel,
2515     cl_uint      arg_index,
2516     const void * arg_value) CL_API_SUFFIX__VERSION_2_0
2517 {
2518     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
2519     return kernel->dispatch->clSetKernelArgSVMPointer(
2520         kernel,
2521         arg_index,
2522         arg_value);
2523 }
2524
2525 CL_API_ENTRY cl_int CL_API_CALL
2526 clSetKernelExecInfo(
2527     cl_kernel            kernel,
2528     cl_kernel_exec_info  param_name,
2529     size_t               param_value_size,
2530     const void *         param_value) CL_API_SUFFIX__VERSION_2_0
2531 {
2532     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
2533     return kernel->dispatch->clSetKernelExecInfo(
2534         kernel,
2535         param_name,
2536         param_value_size,
2537         param_value);
2538 }
2539
2540 CL_API_ENTRY cl_int CL_API_CALL
2541 clGetKernelSubGroupInfoKHR(
2542     cl_kernel                in_kernel,
2543     cl_device_id             in_device,
2544     cl_kernel_sub_group_info param_name,
2545     size_t                   input_value_size,
2546     const void *             input_value,
2547     size_t                   param_value_size,
2548     void *                   param_value,
2549     size_t *                 param_value_size_ret) CL_EXT_SUFFIX__VERSION_2_0
2550 {
2551     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_kernel, CL_INVALID_KERNEL);
2552     return in_kernel->dispatch->clGetKernelSubGroupInfoKHR(
2553             in_kernel,
2554             in_device,
2555             param_name,
2556             input_value_size,
2557             input_value,
2558             param_value_size,
2559             param_value,
2560             param_value_size_ret);
2561 }
2562
2563 CL_API_ENTRY cl_int CL_API_CALL
2564 clSetDefaultDeviceCommandQueue(
2565     cl_context context,
2566     cl_device_id device,
2567     cl_command_queue command_queue) CL_API_SUFFIX__VERSION_2_1
2568 {
2569     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
2570     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
2571     return context->dispatch->clSetDefaultDeviceCommandQueue(
2572             context,
2573             device,
2574             command_queue);
2575 }
2576
2577 CL_API_ENTRY cl_program CL_API_CALL
2578 clCreateProgramWithIL(
2579     cl_context context,
2580     const void * il,
2581     size_t length,
2582     cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_1
2583 {
2584     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
2585     return context->dispatch->clCreateProgramWithIL(
2586             context,
2587             il,
2588             length,
2589             errcode_ret);
2590 }
2591
2592 CL_API_ENTRY cl_int CL_API_CALL
2593 clGetKernelSubGroupInfo(
2594     cl_kernel kernel,
2595     cl_device_id device,
2596     cl_kernel_sub_group_info param_name,
2597     size_t input_value_size,
2598     const void * input_value,
2599     size_t param_value_size,
2600     void * param_value,
2601     size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_2_1
2602 {
2603     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
2604     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
2605     return kernel->dispatch->clGetKernelSubGroupInfo(
2606             kernel,
2607             device,
2608             param_name,
2609             input_value_size,
2610             input_value,
2611             param_value_size,
2612             param_value,
2613             param_value_size_ret);
2614 }
2615
2616 CL_API_ENTRY cl_kernel CL_API_CALL
2617 clCloneKernel(
2618     cl_kernel source_kernel,
2619     cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_1
2620 {
2621     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(source_kernel, CL_INVALID_KERNEL);
2622     return source_kernel->dispatch->clCloneKernel(
2623             source_kernel,
2624             errcode_ret);
2625 }
2626
2627 CL_API_ENTRY cl_int CL_API_CALL
2628 clEnqueueSVMMigrateMem(
2629     cl_command_queue command_queue,
2630     cl_uint num_svm_pointers,
2631     const void ** svm_pointers,
2632     const size_t * sizes,
2633     cl_mem_migration_flags flags,
2634     cl_uint num_events_in_wait_list,
2635     const cl_event * event_wait_list,
2636     cl_event * event) CL_API_SUFFIX__VERSION_2_1
2637 {
2638     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
2639     return command_queue->dispatch->clEnqueueSVMMigrateMem(
2640             command_queue,
2641             num_svm_pointers,
2642             svm_pointers,
2643             sizes,
2644             flags,
2645             num_events_in_wait_list,
2646             event_wait_list,
2647             event);
2648 }
2649
2650 CL_API_ENTRY cl_int CL_API_CALL
2651 clGetDeviceAndHostTimer(
2652     cl_device_id device,
2653     cl_ulong * device_timestamp,
2654     cl_ulong * host_timestamp) CL_API_SUFFIX__VERSION_2_1
2655 {
2656     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
2657     return device->dispatch->clGetDeviceAndHostTimer(
2658             device,
2659             device_timestamp,
2660             host_timestamp);
2661 }
2662
2663 CL_API_ENTRY cl_int CL_API_CALL
2664 clGetHostTimer(
2665     cl_device_id device,
2666     cl_ulong * host_timestamp) CL_API_SUFFIX__VERSION_2_1
2667 {
2668     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
2669     return device->dispatch->clGetHostTimer(
2670             device,
2671             host_timestamp);
2672 }
2673
2674