loader/icd_dispatch.c

   1 /*
   2  * Copyright (c) 2012-2019 The Khronos Group Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  * OpenCL is a trademark of Apple Inc. used under license by Khronos.
  17  */
  18
  19 #include "icd_dispatch.h"
  20 #include "icd.h"
  21 #include <stdlib.h>
  22 #include <string.h>
  23
  24 // Platform APIs
  25 CL_API_ENTRY cl_int CL_API_CALL
  26 clGetPlatformIDs(cl_uint          num_entries,
  27                  cl_platform_id * platforms,
  28                  cl_uint *        num_platforms) CL_API_SUFFIX__VERSION_1_0
  29 {
  30     KHRicdVendor* vendor = NULL;
  31     cl_uint i;
  32
  33     // initialize the platforms (in case they have not been already)
  34     khrIcdInitialize();
  35
  36     if (!num_entries && platforms)
  37     {
  38         return CL_INVALID_VALUE;
  39     }
  40     if (!platforms && !num_platforms)
  41     {
  42         return CL_INVALID_VALUE;
  43     }
  44     // set num_platforms to 0 and set all platform pointers to NULL
  45     if (num_platforms)
  46     {
  47         *num_platforms = 0;
  48     }
  49     for (i = 0; i < num_entries && platforms; ++i)
  50     {
  51         platforms[i] = NULL;
  52     }
  53     // return error if we have no platforms
  54     if (!khrIcdVendors)
  55     {
  56         return CL_PLATFORM_NOT_FOUND_KHR;
  57     }
  58     // otherwise enumerate all platforms
  59     for (vendor = khrIcdVendors; vendor; vendor = vendor->next)
  60     {
  61         if (num_entries && platforms)
  62         {
  63             *(platforms++) = vendor->platform;
  64             --num_entries;
  65         }
  66         if (num_platforms)
  67         {
  68             ++(*num_platforms);
  69         }
  70     }
  71     return CL_SUCCESS;
  72 }
  73
  74 CL_API_ENTRY cl_int CL_API_CALL
  75 clGetPlatformInfo(cl_platform_id   platform,
  76                   cl_platform_info param_name,
  77                   size_t           param_value_size,
  78                   void *           param_value,
  79                   size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
  80 {
  81     // initialize the platforms (in case they have not been already)
  82     khrIcdInitialize();
  83     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
  84     return platform->dispatch->clGetPlatformInfo(
  85         platform,
  86         param_name,
  87         param_value_size,
  88         param_value,
  89         param_value_size_ret);
  90 }
  91
  92 // Device APIs
  93 CL_API_ENTRY cl_int CL_API_CALL
  94 clGetDeviceIDs(cl_platform_id   platform,
  95                cl_device_type   device_type,
  96                cl_uint          num_entries,
  97                cl_device_id *   devices,
  98                cl_uint *        num_devices) CL_API_SUFFIX__VERSION_1_0
  99 {
 100     // initialize the platforms (in case they have not been already)
 101     khrIcdInitialize();
 102     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
 103     return platform->dispatch->clGetDeviceIDs(
 104         platform,
 105         device_type,
 106         num_entries,
 107         devices,
 108         num_devices);
 109 }
 110
 111 CL_API_ENTRY cl_int CL_API_CALL
 112 clGetDeviceInfo(
 113     cl_device_id    device,
 114     cl_device_info  param_name,
 115     size_t          param_value_size,
 116     void *          param_value,
 117     size_t *        param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 118 {
 119     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
 120     return device->dispatch->clGetDeviceInfo(
 121         device,
 122         param_name,
 123         param_value_size,
 124         param_value,
 125         param_value_size_ret);
 126 }
 127
 128 CL_API_ENTRY cl_int CL_API_CALL
 129 clCreateSubDevices(cl_device_id                         in_device,
 130                    const cl_device_partition_property * properties,
 131                    cl_uint                              num_entries,
 132                    cl_device_id *                       out_devices,
 133                    cl_uint *                            num_devices) CL_API_SUFFIX__VERSION_1_2
 134 {
 135     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
 136     return in_device->dispatch->clCreateSubDevices(
 137         in_device,
 138         properties,
 139         num_entries,
 140         out_devices,
 141         num_devices);
 142 }
 143
 144 CL_API_ENTRY cl_int CL_API_CALL
 145 clRetainDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2
 146 {
 147     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
 148     return device->dispatch->clRetainDevice(device);
 149 }
 150
 151 CL_API_ENTRY cl_int CL_API_CALL
 152 clReleaseDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2
 153 {
 154     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
 155     return device->dispatch->clReleaseDevice(device);
 156 }
 157
 158 // Context APIs
 159 CL_API_ENTRY cl_context CL_API_CALL
 160 clCreateContext(const cl_context_properties * properties,
 161                 cl_uint                 num_devices,
 162                 const cl_device_id *    devices,
 163                 void (CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *),
 164                 void *                  user_data,
 165                 cl_int *                errcode_ret) CL_API_SUFFIX__VERSION_1_0
 166 {
 167     // initialize the platforms (in case they have not been already)
 168     khrIcdInitialize();
 169     if (!num_devices || !devices)
 170     {
 171         if (errcode_ret)
 172         {
 173             *errcode_ret = CL_INVALID_VALUE;
 174         }
 175         return NULL;
 176     }
 177     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(devices[0], CL_INVALID_DEVICE);
 178     return devices[0]->dispatch->clCreateContext(
 179         properties,
 180         num_devices,
 181         devices,
 182         pfn_notify,
 183         user_data,
 184         errcode_ret);
 185 }
 186
 187 CL_API_ENTRY cl_context CL_API_CALL
 188 clCreateContextFromType(const cl_context_properties * properties,
 189                         cl_device_type          device_type,
 190                         void (CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *),
 191                         void *                  user_data,
 192                         cl_int *                errcode_ret) CL_API_SUFFIX__VERSION_1_0
 193 {
 194     cl_platform_id platform = NULL;
 195
 196     // initialize the platforms (in case they have not been already)
 197     khrIcdInitialize();
 198
 199     // determine the platform to use from the properties specified
 200     khrIcdContextPropertiesGetPlatform(properties, &platform);
 201
 202     // validate the platform handle and dispatch
 203     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(platform, CL_INVALID_PLATFORM);
 204     return platform->dispatch->clCreateContextFromType(
 205         properties,
 206         device_type,
 207         pfn_notify,
 208         user_data,
 209         errcode_ret);
 210 }
 211
 212 CL_API_ENTRY cl_int CL_API_CALL
 213 clRetainContext(cl_context context) CL_API_SUFFIX__VERSION_1_0
 214 {
 215     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
 216     return context->dispatch->clRetainContext(context);
 217 }
 218
 219 CL_API_ENTRY cl_int CL_API_CALL
 220 clReleaseContext(cl_context context) CL_API_SUFFIX__VERSION_1_0
 221 {
 222     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
 223     return context->dispatch->clReleaseContext(context);
 224 }
 225
 226 CL_API_ENTRY cl_int CL_API_CALL
 227 clGetContextInfo(cl_context         context,
 228                  cl_context_info    param_name,
 229                  size_t             param_value_size,
 230                  void *             param_value,
 231                  size_t *           param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 232 {
 233     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
 234     return context->dispatch->clGetContextInfo(
 235         context,
 236         param_name,
 237         param_value_size,
 238         param_value,
 239         param_value_size_ret);
 240 }
 241
 242 // Command Queue APIs
 243 CL_API_ENTRY cl_command_queue CL_API_CALL
 244 clCreateCommandQueue(cl_context                     context,
 245                      cl_device_id                   device,
 246                      cl_command_queue_properties    properties,
 247                      cl_int *                       errcode_ret) CL_API_SUFFIX__VERSION_1_0
 248 {
 249     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
 250     return context->dispatch->clCreateCommandQueue(
 251         context,
 252         device,
 253         properties,
 254         errcode_ret);
 255 }
 256
 257 CL_API_ENTRY cl_int CL_API_CALL
 258 clRetainCommandQueue(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
 259 {
 260     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 261     return command_queue->dispatch->clRetainCommandQueue(command_queue);
 262 }
 263
 264 CL_API_ENTRY cl_int CL_API_CALL
 265 clReleaseCommandQueue(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
 266 {
 267     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 268     return command_queue->dispatch->clReleaseCommandQueue(command_queue);
 269 }
 270
 271 CL_API_ENTRY cl_int CL_API_CALL
 272 clGetCommandQueueInfo(cl_command_queue      command_queue,
 273                       cl_command_queue_info param_name,
 274                       size_t                param_value_size,
 275                       void *                param_value,
 276                       size_t *              param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 277 {
 278     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 279     return command_queue->dispatch->clGetCommandQueueInfo(
 280         command_queue,
 281         param_name,
 282         param_value_size,
 283         param_value,
 284         param_value_size_ret);
 285 }
 286
 287 // Memory Object APIs
 288 CL_API_ENTRY cl_mem CL_API_CALL
 289 clCreateBuffer(cl_context   context,
 290                cl_mem_flags flags,
 291                size_t       size,
 292                void *       host_ptr,
 293                cl_int *     errcode_ret) CL_API_SUFFIX__VERSION_1_0
 294 {
 295     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
 296     return context->dispatch->clCreateBuffer(
 297         context,
 298         flags,
 299         size,
 300         host_ptr,
 301         errcode_ret);
 302 }
 303
 304 CL_API_ENTRY cl_mem CL_API_CALL
 305 clCreateImage(cl_context              context,
 306                             cl_mem_flags            flags,
 307                             const cl_image_format * image_format,
 308                             const cl_image_desc *   image_desc,
 309                             void *                  host_ptr,
 310                             cl_int *                errcode_ret) CL_API_SUFFIX__VERSION_1_2
 311 {
 312     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
 313     return context->dispatch->clCreateImage(
 314         context,
 315         flags,
 316         image_format,
 317         image_desc,
 318         host_ptr,
 319         errcode_ret);
 320 }
 321
 322 CL_API_ENTRY cl_int CL_API_CALL
 323 clRetainMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
 324 {
 325     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
 326     return memobj->dispatch->clRetainMemObject(memobj);
 327 }
 328
 329
 330 CL_API_ENTRY cl_int CL_API_CALL
 331 clReleaseMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0
 332 {
 333     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
 334     return memobj->dispatch->clReleaseMemObject(memobj);
 335 }
 336
 337 CL_API_ENTRY cl_int CL_API_CALL
 338 clGetSupportedImageFormats(cl_context           context,
 339                            cl_mem_flags         flags,
 340                            cl_mem_object_type   image_type,
 341                            cl_uint              num_entries,
 342                            cl_image_format *    image_formats,
 343                            cl_uint *            num_image_formats) CL_API_SUFFIX__VERSION_1_0
 344 {
 345     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
 346     return context->dispatch->clGetSupportedImageFormats(
 347         context,
 348         flags,
 349         image_type,
 350         num_entries,
 351         image_formats,
 352         num_image_formats);
 353 }
 354
 355 CL_API_ENTRY cl_int CL_API_CALL
 356 clGetMemObjectInfo(cl_mem           memobj,
 357                    cl_mem_info      param_name,
 358                    size_t           param_value_size,
 359                    void *           param_value,
 360                    size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 361 {
 362     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
 363     return memobj->dispatch->clGetMemObjectInfo(
 364         memobj,
 365         param_name,
 366         param_value_size,
 367         param_value,
 368         param_value_size_ret);
 369 }
 370
 371 CL_API_ENTRY cl_int CL_API_CALL
 372 clGetImageInfo(cl_mem           image,
 373                cl_image_info    param_name,
 374                size_t           param_value_size,
 375                void *           param_value,
 376                size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 377 {
 378     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(image, CL_INVALID_MEM_OBJECT);
 379     return image->dispatch->clGetImageInfo(
 380         image,
 381         param_name,
 382         param_value_size,
 383         param_value,
 384         param_value_size_ret);
 385 }
 386
 387 // Sampler APIs
 388 CL_API_ENTRY cl_sampler CL_API_CALL
 389 clCreateSampler(cl_context          context,
 390                 cl_bool             normalized_coords,
 391                 cl_addressing_mode  addressing_mode,
 392                 cl_filter_mode      filter_mode,
 393                 cl_int *            errcode_ret) CL_API_SUFFIX__VERSION_1_0
 394 {
 395     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
 396     return context->dispatch->clCreateSampler(
 397         context,
 398         normalized_coords,
 399         addressing_mode,
 400         filter_mode,
 401         errcode_ret);
 402 }
 403
 404 CL_API_ENTRY cl_int CL_API_CALL
 405 clRetainSampler(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
 406 {
 407     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
 408     return sampler->dispatch->clRetainSampler(sampler);
 409 }
 410
 411 CL_API_ENTRY cl_int CL_API_CALL
 412 clReleaseSampler(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0
 413 {
 414     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
 415     return sampler->dispatch->clReleaseSampler(sampler);
 416 }
 417
 418 CL_API_ENTRY cl_int CL_API_CALL
 419 clGetSamplerInfo(cl_sampler         sampler,
 420                  cl_sampler_info    param_name,
 421                  size_t             param_value_size,
 422                  void *             param_value,
 423                  size_t *           param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 424 {
 425     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
 426     return sampler->dispatch->clGetSamplerInfo(
 427         sampler,
 428         param_name,
 429         param_value_size,
 430         param_value,
 431         param_value_size_ret);
 432 }
 433
 434 // Program Object APIs
 435 CL_API_ENTRY cl_program CL_API_CALL
 436 clCreateProgramWithSource(cl_context        context,
 437                           cl_uint           count,
 438                           const char **     strings,
 439                           const size_t *    lengths,
 440                           cl_int *          errcode_ret) CL_API_SUFFIX__VERSION_1_0
 441 {
 442     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
 443     return context->dispatch->clCreateProgramWithSource(
 444         context,
 445         count,
 446         strings,
 447         lengths,
 448         errcode_ret);
 449 }
 450
 451 CL_API_ENTRY cl_program CL_API_CALL
 452 clCreateProgramWithBinary(cl_context                     context,
 453                           cl_uint                        num_devices,
 454                           const cl_device_id *           device_list,
 455                           const size_t *                 lengths,
 456                           const unsigned char **         binaries,
 457                           cl_int *                       binary_status,
 458                           cl_int *                       errcode_ret) CL_API_SUFFIX__VERSION_1_0
 459 {
 460     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
 461     return context->dispatch->clCreateProgramWithBinary(
 462         context,
 463         num_devices,
 464         device_list,
 465         lengths,
 466         binaries,
 467         binary_status,
 468         errcode_ret);
 469 }
 470
 471 CL_API_ENTRY cl_program CL_API_CALL
 472 clCreateProgramWithBuiltInKernels(cl_context            context,
 473                                   cl_uint               num_devices,
 474                                   const cl_device_id *  device_list,
 475                                   const char *          kernel_names,
 476                                   cl_int *              errcode_ret) CL_API_SUFFIX__VERSION_1_2
 477 {
 478     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
 479     return context->dispatch->clCreateProgramWithBuiltInKernels(
 480         context,
 481         num_devices,
 482         device_list,
 483         kernel_names,
 484         errcode_ret);
 485 }
 486
 487 CL_API_ENTRY cl_int CL_API_CALL
 488 clRetainProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0
 489 {
 490     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 491     return program->dispatch->clRetainProgram(program);
 492 }
 493
 494 CL_API_ENTRY cl_int CL_API_CALL
 495 clReleaseProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0
 496 {
 497     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 498     return program->dispatch->clReleaseProgram(program);
 499 }
 500
 501 CL_API_ENTRY cl_int CL_API_CALL
 502 clBuildProgram(cl_program           program,
 503                cl_uint              num_devices,
 504                const cl_device_id * device_list,
 505                const char *         options,
 506                void (CL_CALLBACK *pfn_notify)(cl_program program, void * user_data),
 507                void *               user_data) CL_API_SUFFIX__VERSION_1_0
 508 {
 509     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 510     return program->dispatch->clBuildProgram(
 511         program,
 512         num_devices,
 513         device_list,
 514         options,
 515         pfn_notify,
 516         user_data);
 517 }
 518
 519 CL_API_ENTRY cl_int CL_API_CALL
 520 clCompileProgram(cl_program           program,
 521                  cl_uint              num_devices,
 522                  const cl_device_id * device_list,
 523                  const char *         options,
 524                  cl_uint              num_input_headers,
 525                  const cl_program *   input_headers,
 526                  const char **        header_include_names,
 527                  void (CL_CALLBACK *  pfn_notify)(cl_program program, void * user_data),
 528                  void *               user_data) CL_API_SUFFIX__VERSION_1_2
 529 {
 530     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 531     return program->dispatch->clCompileProgram(
 532         program,
 533         num_devices,
 534         device_list,
 535         options,
 536         num_input_headers,
 537         input_headers,
 538         header_include_names,
 539         pfn_notify,
 540         user_data);
 541 }
 542
 543 CL_API_ENTRY cl_program CL_API_CALL
 544 clLinkProgram(cl_context           context,
 545               cl_uint              num_devices,
 546               const cl_device_id * device_list,
 547               const char *         options,
 548               cl_uint              num_input_programs,
 549               const cl_program *   input_programs,
 550               void (CL_CALLBACK *  pfn_notify)(cl_program program, void * user_data),
 551               void *               user_data,
 552               cl_int *             errcode_ret) CL_API_SUFFIX__VERSION_1_2
 553 {
 554     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
 555     return context->dispatch->clLinkProgram(
 556         context,
 557         num_devices,
 558         device_list,
 559         options,
 560         num_input_programs,
 561         input_programs,
 562         pfn_notify,
 563         user_data,
 564         errcode_ret);
 565 }
 566
 567 CL_API_ENTRY cl_int CL_API_CALL
 568 clSetProgramSpecializationConstant(cl_program  program,
 569                                    cl_uint     spec_id,
 570                                    size_t      spec_size,
 571                                    const void* spec_value) CL_API_SUFFIX__VERSION_2_2
 572 {
 573     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 574     return program->dispatch->clSetProgramSpecializationConstant(
 575         program,
 576         spec_id,
 577         spec_size,
 578         spec_value);
 579 }
 580
 581 CL_API_ENTRY cl_int CL_API_CALL
 582 clSetProgramReleaseCallback(cl_program  program,
 583                             void (CL_CALLBACK * pfn_notify)(cl_program program, void * user_data),
 584                             void *              user_data) CL_API_SUFFIX__VERSION_2_2
 585 {
 586     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 587     return program->dispatch->clSetProgramReleaseCallback(
 588         program,
 589         pfn_notify,
 590         user_data);
 591 }
 592
 593 CL_API_ENTRY cl_int CL_API_CALL
 594 clUnloadPlatformCompiler(cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2
 595 {
 596     // initialize the platforms (in case they have not been already)
 597     khrIcdInitialize();
 598     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
 599     return platform->dispatch->clUnloadPlatformCompiler(platform);
 600 }
 601
 602 CL_API_ENTRY cl_int CL_API_CALL
 603 clGetProgramInfo(cl_program         program,
 604                  cl_program_info    param_name,
 605                  size_t             param_value_size,
 606                  void *             param_value,
 607                  size_t *           param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 608 {
 609     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 610     return program->dispatch->clGetProgramInfo(
 611         program,
 612         param_name,
 613         param_value_size,
 614         param_value,
 615         param_value_size_ret);
 616 }
 617
 618 CL_API_ENTRY cl_int CL_API_CALL
 619 clGetProgramBuildInfo(cl_program            program,
 620                       cl_device_id          device,
 621                       cl_program_build_info param_name,
 622                       size_t                param_value_size,
 623                       void *                param_value,
 624                       size_t *              param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 625 {
 626     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 627     return program->dispatch->clGetProgramBuildInfo(
 628         program,
 629         device,
 630         param_name,
 631         param_value_size,
 632         param_value,
 633         param_value_size_ret);
 634 }
 635
 636 // Kernel Object APIs
 637 CL_API_ENTRY cl_kernel CL_API_CALL
 638 clCreateKernel(cl_program      program,
 639                const char *    kernel_name,
 640                cl_int *        errcode_ret) CL_API_SUFFIX__VERSION_1_0
 641 {
 642     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(program, CL_INVALID_PROGRAM);
 643     return program->dispatch->clCreateKernel(
 644         program,
 645         kernel_name,
 646         errcode_ret);
 647 }
 648
 649 CL_API_ENTRY cl_int CL_API_CALL
 650 clCreateKernelsInProgram(cl_program     program,
 651                          cl_uint        num_kernels,
 652                          cl_kernel *    kernels,
 653                          cl_uint *      num_kernels_ret) CL_API_SUFFIX__VERSION_1_0
 654 {
 655     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
 656     return program->dispatch->clCreateKernelsInProgram(
 657         program,
 658         num_kernels,
 659         kernels,
 660         num_kernels_ret);
 661 }
 662
 663 CL_API_ENTRY cl_int CL_API_CALL
 664 clRetainKernel(cl_kernel    kernel) CL_API_SUFFIX__VERSION_1_0
 665 {
 666     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
 667     return kernel->dispatch->clRetainKernel(kernel);
 668 }
 669
 670 CL_API_ENTRY cl_int CL_API_CALL
 671 clReleaseKernel(cl_kernel   kernel) CL_API_SUFFIX__VERSION_1_0
 672 {
 673     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
 674     return kernel->dispatch->clReleaseKernel(kernel);
 675 }
 676
 677 CL_API_ENTRY cl_int CL_API_CALL
 678 clSetKernelArg(cl_kernel    kernel,
 679                cl_uint      arg_index,
 680                size_t       arg_size,
 681                const void * arg_value) CL_API_SUFFIX__VERSION_1_0
 682 {
 683     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
 684     return kernel->dispatch->clSetKernelArg(
 685         kernel,
 686         arg_index,
 687         arg_size,
 688         arg_value);
 689 }
 690
 691 CL_API_ENTRY cl_int CL_API_CALL
 692 clGetKernelInfo(cl_kernel       kernel,
 693                 cl_kernel_info  param_name,
 694                 size_t          param_value_size,
 695                 void *          param_value,
 696                 size_t *        param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 697 {
 698     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
 699     return kernel->dispatch->clGetKernelInfo(
 700         kernel,
 701         param_name,
 702         param_value_size,
 703         param_value,
 704         param_value_size_ret);
 705 }
 706
 707 CL_API_ENTRY cl_int CL_API_CALL
 708 clGetKernelArgInfo(cl_kernel       kernel,
 709                    cl_uint         arg_indx,
 710                    cl_kernel_arg_info  param_name,
 711                    size_t          param_value_size,
 712                    void *          param_value,
 713                    size_t *        param_value_size_ret) CL_API_SUFFIX__VERSION_1_2
 714 {
 715     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
 716     return kernel->dispatch->clGetKernelArgInfo(
 717         kernel,
 718         arg_indx,
 719         param_name,
 720         param_value_size,
 721         param_value,
 722         param_value_size_ret);
 723 }
 724
 725 CL_API_ENTRY cl_int CL_API_CALL
 726 clGetKernelWorkGroupInfo(cl_kernel                  kernel,
 727                          cl_device_id               device,
 728                          cl_kernel_work_group_info  param_name,
 729                          size_t                     param_value_size,
 730                          void *                     param_value,
 731                          size_t *                   param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 732 {
 733     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
 734     return kernel->dispatch->clGetKernelWorkGroupInfo(
 735         kernel,
 736         device,
 737         param_name,
 738         param_value_size,
 739         param_value,
 740         param_value_size_ret);
 741 }
 742
 743 // Event Object APIs
 744 CL_API_ENTRY cl_int CL_API_CALL
 745 clWaitForEvents(cl_uint             num_events,
 746                 const cl_event *    event_list) CL_API_SUFFIX__VERSION_1_0
 747 {
 748     if (!num_events || !event_list)
 749     {
 750         return CL_INVALID_VALUE;
 751     }
 752     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event_list[0], CL_INVALID_EVENT);
 753     return event_list[0]->dispatch->clWaitForEvents(
 754         num_events,
 755         event_list);
 756 }
 757
 758 CL_API_ENTRY cl_int CL_API_CALL
 759 clGetEventInfo(cl_event         event,
 760                cl_event_info    param_name,
 761                size_t           param_value_size,
 762                void *           param_value,
 763                size_t *         param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 764 {
 765     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
 766     return event->dispatch->clGetEventInfo(
 767         event,
 768         param_name,
 769         param_value_size,
 770         param_value,
 771         param_value_size_ret);
 772 }
 773
 774 CL_API_ENTRY cl_int CL_API_CALL
 775 clRetainEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0
 776 {
 777     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
 778     return event->dispatch->clRetainEvent(event);
 779 }
 780
 781 CL_API_ENTRY cl_int CL_API_CALL
 782 clReleaseEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0
 783 {
 784     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
 785     return event->dispatch->clReleaseEvent(event);
 786 }
 787
 788 // Profiling APIs
 789 CL_API_ENTRY cl_int CL_API_CALL
 790 clGetEventProfilingInfo(cl_event            event,
 791                         cl_profiling_info   param_name,
 792                         size_t              param_value_size,
 793                         void *              param_value,
 794                         size_t *            param_value_size_ret) CL_API_SUFFIX__VERSION_1_0
 795 {
 796     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
 797     return event->dispatch->clGetEventProfilingInfo(
 798         event,
 799         param_name,
 800         param_value_size,
 801         param_value,
 802         param_value_size_ret);
 803 }
 804
 805 // Flush and Finish APIs
 806 CL_API_ENTRY cl_int CL_API_CALL
 807 clFlush(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
 808 {
 809     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 810     return command_queue->dispatch->clFlush(command_queue);
 811 }
 812
 813 CL_API_ENTRY cl_int CL_API_CALL
 814 clFinish(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0
 815 {
 816     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 817     return command_queue->dispatch->clFinish(command_queue);
 818 }
 819
 820 // Enqueued Commands APIs
 821 CL_API_ENTRY cl_int CL_API_CALL
 822 clEnqueueReadBuffer(cl_command_queue    command_queue,
 823                     cl_mem              buffer,
 824                     cl_bool             blocking_read,
 825                     size_t              offset,
 826                     size_t              cb,
 827                     void *              ptr,
 828                     cl_uint             num_events_in_wait_list,
 829                     const cl_event *    event_wait_list,
 830                     cl_event *          event) CL_API_SUFFIX__VERSION_1_0
 831 {
 832     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 833     return command_queue->dispatch->clEnqueueReadBuffer(
 834         command_queue,
 835         buffer,
 836         blocking_read,
 837         offset,
 838         cb,
 839         ptr,
 840         num_events_in_wait_list,
 841         event_wait_list,
 842         event);
 843 }
 844
 845 CL_API_ENTRY cl_int CL_API_CALL
 846 clEnqueueReadBufferRect(
 847     cl_command_queue command_queue,
 848     cl_mem buffer,
 849     cl_bool blocking_read,
 850     const size_t * buffer_origin,
 851     const size_t * host_origin,
 852     const size_t * region,
 853     size_t buffer_row_pitch,
 854     size_t buffer_slice_pitch,
 855     size_t host_row_pitch,
 856     size_t host_slice_pitch,
 857     void * ptr,
 858     cl_uint num_events_in_wait_list,
 859     const cl_event * event_wait_list,
 860     cl_event * event) CL_API_SUFFIX__VERSION_1_1
 861 {
 862     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 863     return command_queue->dispatch->clEnqueueReadBufferRect(
 864         command_queue,
 865         buffer,
 866         blocking_read,
 867         buffer_origin,
 868         host_origin,
 869         region,
 870         buffer_row_pitch,
 871         buffer_slice_pitch,
 872         host_row_pitch,
 873         host_slice_pitch,
 874         ptr,
 875         num_events_in_wait_list,
 876         event_wait_list,
 877         event);
 878 }
 879
 880 CL_API_ENTRY cl_int CL_API_CALL
 881 clEnqueueWriteBuffer(cl_command_queue   command_queue,
 882                      cl_mem             buffer,
 883                      cl_bool            blocking_write,
 884                      size_t             offset,
 885                      size_t             cb,
 886                      const void *       ptr,
 887                      cl_uint            num_events_in_wait_list,
 888                      const cl_event *   event_wait_list,
 889                      cl_event *         event) CL_API_SUFFIX__VERSION_1_0
 890 {
 891     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 892     return command_queue->dispatch->clEnqueueWriteBuffer(
 893         command_queue,
 894         buffer,
 895         blocking_write,
 896         offset,
 897         cb,
 898         ptr,
 899         num_events_in_wait_list,
 900         event_wait_list,
 901         event);
 902 }
 903
 904 CL_API_ENTRY cl_int CL_API_CALL
 905 clEnqueueWriteBufferRect(
 906     cl_command_queue command_queue,
 907     cl_mem buffer,
 908     cl_bool blocking_read,
 909     const size_t * buffer_origin,
 910     const size_t * host_origin,
 911     const size_t * region,
 912     size_t buffer_row_pitch,
 913     size_t buffer_slice_pitch,
 914     size_t host_row_pitch,
 915     size_t host_slice_pitch,
 916     const void * ptr,
 917     cl_uint num_events_in_wait_list,
 918     const cl_event * event_wait_list,
 919     cl_event * event) CL_API_SUFFIX__VERSION_1_1
 920 {
 921     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 922     return command_queue->dispatch->clEnqueueWriteBufferRect(
 923         command_queue,
 924         buffer,
 925         blocking_read,
 926         buffer_origin,
 927         host_origin,
 928         region,
 929         buffer_row_pitch,
 930         buffer_slice_pitch,
 931         host_row_pitch,
 932         host_slice_pitch,
 933         ptr,
 934         num_events_in_wait_list,
 935         event_wait_list,
 936         event);
 937 }
 938
 939 CL_API_ENTRY cl_int CL_API_CALL
 940 clEnqueueFillBuffer(cl_command_queue   command_queue,
 941                     cl_mem             buffer,
 942                     const void *       pattern,
 943                     size_t             pattern_size,
 944                     size_t             offset,
 945                     size_t             cb,
 946                     cl_uint            num_events_in_wait_list,
 947                     const cl_event *   event_wait_list,
 948                     cl_event *         event) CL_API_SUFFIX__VERSION_1_2
 949 {
 950     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 951     return command_queue->dispatch->clEnqueueFillBuffer(
 952         command_queue,
 953         buffer,
 954         pattern,
 955         pattern_size,
 956         offset,
 957         cb,
 958         num_events_in_wait_list,
 959         event_wait_list,
 960         event);
 961 }
 962
 963 CL_API_ENTRY cl_int CL_API_CALL
 964 clEnqueueCopyBuffer(cl_command_queue    command_queue,
 965                     cl_mem              src_buffer,
 966                     cl_mem              dst_buffer,
 967                     size_t              src_offset,
 968                     size_t              dst_offset,
 969                     size_t              cb,
 970                     cl_uint             num_events_in_wait_list,
 971                     const cl_event *    event_wait_list,
 972                     cl_event *          event) CL_API_SUFFIX__VERSION_1_0
 973 {
 974     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
 975     return command_queue->dispatch->clEnqueueCopyBuffer(
 976         command_queue,
 977         src_buffer,
 978         dst_buffer,
 979         src_offset,
 980         dst_offset,
 981         cb,
 982         num_events_in_wait_list,
 983         event_wait_list,
 984         event);
 985 }
 986
 987 CL_API_ENTRY cl_int CL_API_CALL
 988 clEnqueueCopyBufferRect(
 989     cl_command_queue command_queue,
 990     cl_mem src_buffer,
 991     cl_mem dst_buffer,
 992     const size_t * src_origin,
 993     const size_t * dst_origin,
 994     const size_t * region,
 995     size_t src_row_pitch,
 996     size_t src_slice_pitch,
 997     size_t dst_row_pitch,
 998     size_t dst_slice_pitch,
 999     cl_uint num_events_in_wait_list,
1000     const cl_event * event_wait_list,
1001     cl_event * event) CL_API_SUFFIX__VERSION_1_1
1002 {
1003     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1004     return command_queue->dispatch->clEnqueueCopyBufferRect(
1005         command_queue,
1006         src_buffer,
1007         dst_buffer,
1008         src_origin,
1009         dst_origin,
1010         region,
1011         src_row_pitch,
1012         src_slice_pitch,
1013         dst_row_pitch,
1014         dst_slice_pitch,
1015         num_events_in_wait_list,
1016         event_wait_list,
1017         event);
1018 }
1019
1020 CL_API_ENTRY cl_int CL_API_CALL
1021 clEnqueueReadImage(cl_command_queue     command_queue,
1022                    cl_mem               image,
1023                    cl_bool              blocking_read,
1024                    const size_t *       origin,
1025                    const size_t *       region,
1026                    size_t               row_pitch,
1027                    size_t               slice_pitch,
1028                    void *               ptr,
1029                    cl_uint              num_events_in_wait_list,
1030                    const cl_event *     event_wait_list,
1031                    cl_event *           event) CL_API_SUFFIX__VERSION_1_0
1032 {
1033     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1034     return command_queue->dispatch->clEnqueueReadImage(
1035         command_queue,
1036         image,
1037         blocking_read,
1038         origin,
1039         region,
1040         row_pitch,
1041         slice_pitch,
1042         ptr,
1043         num_events_in_wait_list,
1044         event_wait_list,
1045         event);
1046 }
1047
1048 CL_API_ENTRY cl_int CL_API_CALL
1049 clEnqueueWriteImage(cl_command_queue    command_queue,
1050                     cl_mem              image,
1051                     cl_bool             blocking_write,
1052                     const size_t *      origin,
1053                     const size_t *      region,
1054                     size_t              input_row_pitch,
1055                     size_t              input_slice_pitch,
1056                     const void *        ptr,
1057                     cl_uint             num_events_in_wait_list,
1058                     const cl_event *    event_wait_list,
1059                     cl_event *          event) CL_API_SUFFIX__VERSION_1_0
1060 {
1061     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1062     return command_queue->dispatch->clEnqueueWriteImage(
1063         command_queue,
1064         image,
1065         blocking_write,
1066         origin,
1067         region,
1068         input_row_pitch,
1069         input_slice_pitch,
1070         ptr,
1071         num_events_in_wait_list,
1072         event_wait_list,
1073         event);
1074 }
1075
1076 CL_API_ENTRY cl_int CL_API_CALL
1077 clEnqueueFillImage(cl_command_queue   command_queue,
1078                    cl_mem             image,
1079                    const void *       fill_color,
1080                    const size_t       origin[3],
1081                    const size_t       region[3],
1082                    cl_uint            num_events_in_wait_list,
1083                    const cl_event *   event_wait_list,
1084                    cl_event *         event) CL_API_SUFFIX__VERSION_1_2
1085 {
1086     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1087     return command_queue->dispatch->clEnqueueFillImage(
1088         command_queue,
1089         image,
1090         fill_color,
1091         origin,
1092         region,
1093         num_events_in_wait_list,
1094         event_wait_list,
1095         event);
1096 }
1097
1098 CL_API_ENTRY cl_int CL_API_CALL
1099 clEnqueueCopyImage(cl_command_queue     command_queue,
1100                    cl_mem               src_image,
1101                    cl_mem               dst_image,
1102                    const size_t *       src_origin,
1103                    const size_t *       dst_origin,
1104                    const size_t *       region,
1105                    cl_uint              num_events_in_wait_list,
1106                    const cl_event *     event_wait_list,
1107                    cl_event *           event) CL_API_SUFFIX__VERSION_1_0
1108 {
1109     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1110     return command_queue->dispatch->clEnqueueCopyImage(
1111         command_queue,
1112         src_image,
1113         dst_image,
1114         src_origin,
1115         dst_origin,
1116         region,
1117         num_events_in_wait_list,
1118         event_wait_list,
1119         event);
1120 }
1121
1122 CL_API_ENTRY cl_int CL_API_CALL
1123 clEnqueueCopyImageToBuffer(cl_command_queue command_queue,
1124                            cl_mem           src_image,
1125                            cl_mem           dst_buffer,
1126                            const size_t *   src_origin,
1127                            const size_t *   region,
1128                            size_t           dst_offset,
1129                            cl_uint          num_events_in_wait_list,
1130                            const cl_event * event_wait_list,
1131                            cl_event *       event) CL_API_SUFFIX__VERSION_1_0
1132 {
1133     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1134     return command_queue->dispatch->clEnqueueCopyImageToBuffer(
1135         command_queue,
1136         src_image,
1137         dst_buffer,
1138         src_origin,
1139         region,
1140         dst_offset,
1141         num_events_in_wait_list,
1142         event_wait_list,
1143         event);
1144 }
1145
1146 CL_API_ENTRY cl_int CL_API_CALL
1147 clEnqueueCopyBufferToImage(cl_command_queue command_queue,
1148                            cl_mem           src_buffer,
1149                            cl_mem           dst_image,
1150                            size_t           src_offset,
1151                            const size_t *   dst_origin,
1152                            const size_t *   region,
1153                            cl_uint          num_events_in_wait_list,
1154                            const cl_event * event_wait_list,
1155                            cl_event *       event) CL_API_SUFFIX__VERSION_1_0
1156 {
1157     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1158     return command_queue->dispatch->clEnqueueCopyBufferToImage(
1159         command_queue,
1160         src_buffer,
1161         dst_image,
1162         src_offset,
1163         dst_origin,
1164         region,
1165         num_events_in_wait_list,
1166         event_wait_list,
1167         event);
1168 }
1169
1170 CL_API_ENTRY void * CL_API_CALL
1171 clEnqueueMapBuffer(cl_command_queue command_queue,
1172                    cl_mem           buffer,
1173                    cl_bool          blocking_map,
1174                    cl_map_flags     map_flags,
1175                    size_t           offset,
1176                    size_t           cb,
1177                    cl_uint          num_events_in_wait_list,
1178                    const cl_event * event_wait_list,
1179                    cl_event *       event,
1180                    cl_int *         errcode_ret) CL_API_SUFFIX__VERSION_1_0
1181 {
1182     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE);
1183     return command_queue->dispatch->clEnqueueMapBuffer(
1184         command_queue,
1185         buffer,
1186         blocking_map,
1187         map_flags,
1188         offset,
1189         cb,
1190         num_events_in_wait_list,
1191         event_wait_list,
1192         event,
1193         errcode_ret);
1194 }
1195
1196 CL_API_ENTRY void * CL_API_CALL
1197 clEnqueueMapImage(cl_command_queue  command_queue,
1198                   cl_mem            image,
1199                   cl_bool           blocking_map,
1200                   cl_map_flags      map_flags,
1201                   const size_t *    origin,
1202                   const size_t *    region,
1203                   size_t *          image_row_pitch,
1204                   size_t *          image_slice_pitch,
1205                   cl_uint           num_events_in_wait_list,
1206                   const cl_event *  event_wait_list,
1207                   cl_event *        event,
1208                   cl_int *          errcode_ret) CL_API_SUFFIX__VERSION_1_0
1209 {
1210     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE);
1211     return command_queue->dispatch->clEnqueueMapImage(
1212         command_queue,
1213         image,
1214         blocking_map,
1215         map_flags,
1216         origin,
1217         region,
1218         image_row_pitch,
1219         image_slice_pitch,
1220         num_events_in_wait_list,
1221         event_wait_list,
1222         event,
1223         errcode_ret);
1224 }
1225
1226 CL_API_ENTRY cl_int CL_API_CALL
1227 clEnqueueUnmapMemObject(cl_command_queue command_queue,
1228                         cl_mem           memobj,
1229                         void *           mapped_ptr,
1230                         cl_uint          num_events_in_wait_list,
1231                         const cl_event *  event_wait_list,
1232                         cl_event *        event) CL_API_SUFFIX__VERSION_1_0
1233 {
1234     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1235     return command_queue->dispatch->clEnqueueUnmapMemObject(
1236         command_queue,
1237         memobj,
1238         mapped_ptr,
1239         num_events_in_wait_list,
1240         event_wait_list,
1241         event);
1242 }
1243
1244 CL_API_ENTRY cl_int CL_API_CALL
1245 clEnqueueMigrateMemObjects(cl_command_queue       command_queue,
1246                            cl_uint                num_mem_objects,
1247                            const cl_mem *         mem_objects,
1248                            cl_mem_migration_flags flags,
1249                            cl_uint                num_events_in_wait_list,
1250                            const cl_event *       event_wait_list,
1251                            cl_event *             event) CL_API_SUFFIX__VERSION_1_2
1252 {
1253     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1254     return command_queue->dispatch->clEnqueueMigrateMemObjects(
1255         command_queue,
1256         num_mem_objects,
1257         mem_objects,
1258         flags,
1259         num_events_in_wait_list,
1260         event_wait_list,
1261         event);
1262 }
1263
1264 CL_API_ENTRY cl_int CL_API_CALL
1265 clEnqueueNDRangeKernel(cl_command_queue command_queue,
1266                        cl_kernel        kernel,
1267                        cl_uint          work_dim,
1268                        const size_t *   global_work_offset,
1269                        const size_t *   global_work_size,
1270                        const size_t *   local_work_size,
1271                        cl_uint          num_events_in_wait_list,
1272                        const cl_event * event_wait_list,
1273                        cl_event *       event) CL_API_SUFFIX__VERSION_1_0
1274 {
1275     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1276     return command_queue->dispatch->clEnqueueNDRangeKernel(
1277         command_queue,
1278         kernel,
1279         work_dim,
1280         global_work_offset,
1281         global_work_size,
1282         local_work_size,
1283         num_events_in_wait_list,
1284         event_wait_list,
1285         event);
1286 }
1287
1288 CL_API_ENTRY cl_int CL_API_CALL
1289 clEnqueueTask(cl_command_queue  command_queue,
1290               cl_kernel         kernel,
1291               cl_uint           num_events_in_wait_list,
1292               const cl_event *  event_wait_list,
1293               cl_event *        event) CL_API_SUFFIX__VERSION_1_0
1294 {
1295     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1296     return command_queue->dispatch->clEnqueueTask(
1297         command_queue,
1298         kernel,
1299         num_events_in_wait_list,
1300         event_wait_list,
1301         event);
1302 }
1303
1304 CL_API_ENTRY cl_int CL_API_CALL
1305 clEnqueueNativeKernel(cl_command_queue  command_queue,
1306                       void (CL_CALLBACK * user_func)(void *),
1307                       void *            args,
1308                       size_t            cb_args,
1309                       cl_uint           num_mem_objects,
1310                       const cl_mem *    mem_list,
1311                       const void **     args_mem_loc,
1312                       cl_uint           num_events_in_wait_list,
1313                       const cl_event *  event_wait_list,
1314                       cl_event *        event) CL_API_SUFFIX__VERSION_1_0
1315 {
1316     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1317     return command_queue->dispatch->clEnqueueNativeKernel(
1318         command_queue,
1319         user_func,
1320         args,
1321         cb_args,
1322         num_mem_objects,
1323         mem_list,
1324         args_mem_loc,
1325         num_events_in_wait_list,
1326         event_wait_list,
1327         event);
1328 }
1329
1330 CL_API_ENTRY cl_int CL_API_CALL
1331 clEnqueueMarkerWithWaitList(cl_command_queue  command_queue,
1332                             cl_uint           num_events_in_wait_list,
1333                             const cl_event *  event_wait_list,
1334                             cl_event *        event) CL_API_SUFFIX__VERSION_1_2
1335 {
1336     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1337     return command_queue->dispatch->clEnqueueMarkerWithWaitList(
1338         command_queue,
1339         num_events_in_wait_list,
1340         event_wait_list,
1341         event);
1342 }
1343
1344 CL_API_ENTRY cl_int CL_API_CALL
1345 clEnqueueBarrierWithWaitList(cl_command_queue  command_queue,
1346                              cl_uint           num_events_in_wait_list,
1347                              const cl_event *  event_wait_list,
1348                              cl_event *        event) CL_API_SUFFIX__VERSION_1_2
1349 {
1350     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1351     return command_queue->dispatch->clEnqueueBarrierWithWaitList(
1352         command_queue,
1353         num_events_in_wait_list,
1354         event_wait_list,
1355         event);
1356 }
1357
1358 CL_API_ENTRY void * CL_API_CALL
1359 clGetExtensionFunctionAddressForPlatform(cl_platform_id platform,
1360                                          const char *   function_name) CL_API_SUFFIX__VERSION_1_2
1361 {
1362     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL);
1363
1364     // make sure the ICD is initialized
1365     khrIcdInitialize();
1366
1367     // return any ICD-aware extensions
1368
1369     // Most extensions, including multi-vendor KHR and EXT extensions,
1370     // do not need to be ICD-aware and do not require any ICD loader
1371     // modifications.  The KHR and EXT extensions below were added for
1372     // backwards compatibility only.
1373     #define CL_COMMON_EXTENSION_ENTRYPOINT_ADD(name) if (!strcmp(function_name, #name) ) return (void *)(size_t)&name
1374
1375     // Functions supporting the creation of OpenCL Memory Objects
1376     // from OpenGL Objects (cl_apple_gl_sharing, cl_khr_gl_sharing)
1377     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLBuffer);
1378     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture);
1379     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture2D);
1380     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture3D);
1381     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLRenderbuffer);
1382     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLObjectInfo);
1383     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLTextureInfo);
1384     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireGLObjects);
1385     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseGLObjects);
1386
1387     // cl_khr_gl_sharing
1388     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLContextInfoKHR);
1389
1390     // cl_khr_gl_event
1391     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromGLsyncKHR);
1392
1393 #if defined(_WIN32)
1394     // cl_khr_d3d10_sharing
1395     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D10KHR);
1396     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10BufferKHR);
1397     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture2DKHR);
1398     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture3DKHR);
1399     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D10ObjectsKHR);
1400     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D10ObjectsKHR);
1401     // cl_khr_d3d11_sharing
1402     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D11KHR);
1403     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11BufferKHR);
1404     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture2DKHR);
1405     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture3DKHR);
1406     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D11ObjectsKHR);
1407     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D11ObjectsKHR);
1408     // cl_khr_dx9_media_sharing
1409     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromDX9MediaAdapterKHR);
1410     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromDX9MediaSurfaceKHR);
1411     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireDX9MediaSurfacesKHR);
1412     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseDX9MediaSurfacesKHR);
1413 #endif
1414
1415     // cl_ext_device_fission
1416     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateSubDevicesEXT);
1417     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clRetainDeviceEXT);
1418     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clReleaseDeviceEXT);
1419
1420     /* cl_khr_egl_image */
1421     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromEGLImageKHR);
1422     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireEGLObjectsKHR);
1423     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseEGLObjectsKHR);
1424
1425     /* cl_khr_egl_event */
1426     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromEGLSyncKHR);
1427
1428     /* cl_khr_sub_groups */
1429     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetKernelSubGroupInfoKHR);
1430
1431     #undef CL_COMMON_EXTENSION_ENTRYPOINT_ADD
1432
1433     // This is not an ICD-aware extension, so call into the implementation
1434     // to get the extension function address.
1435
1436     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, NULL);
1437     return platform->dispatch->clGetExtensionFunctionAddressForPlatform(
1438         platform,
1439         function_name);
1440 }
1441
1442 // Deprecated APIs
1443 CL_API_ENTRY cl_int CL_API_CALL
1444 clSetCommandQueueProperty(cl_command_queue              command_queue,
1445                           cl_command_queue_properties   properties,
1446                           cl_bool                       enable,
1447                           cl_command_queue_properties * old_properties) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED
1448 {
1449     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1450     return command_queue->dispatch->clSetCommandQueueProperty(
1451         command_queue,
1452         properties,
1453         enable,
1454         old_properties);
1455 }
1456
1457 CL_API_ENTRY cl_int CL_API_CALL
1458 clCreateSubDevicesEXT(
1459     cl_device_id in_device,
1460     const cl_device_partition_property_ext * partition_properties,
1461     cl_uint num_entries,
1462     cl_device_id * out_devices,
1463     cl_uint * num_devices) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1464 {
1465     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
1466         return in_device->dispatch->clCreateSubDevicesEXT(
1467         in_device,
1468         partition_properties,
1469         num_entries,
1470         out_devices,
1471         num_devices);
1472 }
1473
1474 CL_API_ENTRY cl_int CL_API_CALL
1475 clRetainDeviceEXT(cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1476 {
1477     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
1478     return device->dispatch->clRetainDeviceEXT(device);
1479 }
1480
1481 CL_API_ENTRY cl_int CL_API_CALL
1482 clReleaseDeviceEXT(cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1483 {
1484     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
1485     return device->dispatch->clReleaseDeviceEXT(device);
1486 }
1487
1488 CL_API_ENTRY cl_mem CL_API_CALL
1489 clCreateImage2D(cl_context              context,
1490                 cl_mem_flags            flags,
1491                 const cl_image_format * image_format,
1492                 size_t                  image_width,
1493                 size_t                  image_height,
1494                 size_t                  image_row_pitch,
1495                 void *                  host_ptr,
1496                 cl_int *                errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1497 {
1498     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1499     return context->dispatch->clCreateImage2D(
1500         context,
1501         flags,
1502         image_format,
1503         image_width,
1504         image_height,
1505         image_row_pitch,
1506         host_ptr,
1507         errcode_ret);
1508 }
1509
1510 CL_API_ENTRY cl_mem CL_API_CALL
1511 clCreateImage3D(cl_context              context,
1512                 cl_mem_flags            flags,
1513                 const cl_image_format * image_format,
1514                 size_t                  image_width,
1515                 size_t                  image_height,
1516                 size_t                  image_depth,
1517                 size_t                  image_row_pitch,
1518                 size_t                  image_slice_pitch,
1519                 void *                  host_ptr,
1520                 cl_int *                errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1521 {
1522     KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
1523     return context->dispatch->clCreateImage3D(
1524         context,
1525         flags,
1526         image_format,
1527         image_width,
1528         image_height,
1529         image_depth,
1530         image_row_pitch,
1531         image_slice_pitch,
1532         host_ptr,
1533         errcode_ret);
1534 }
1535
1536 CL_API_ENTRY cl_int CL_API_CALL
1537 clUnloadCompiler(void) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1538 {
1539     return CL_SUCCESS;
1540 }
1541
1542 CL_API_ENTRY cl_int CL_API_CALL
1543 clEnqueueMarker(cl_command_queue    command_queue,
1544                 cl_event *          event) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1545 {
1546     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1547     return command_queue->dispatch->clEnqueueMarker(
1548         command_queue,
1549         event);
1550 }
1551
1552 CL_API_ENTRY cl_int CL_API_CALL
1553 clEnqueueWaitForEvents(cl_command_queue command_queue,
1554                        cl_uint          num_events,
1555                        const cl_event * event_list) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1556 {
1557     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
1558     return command_queue->dispatch->clEnqueueWaitForEvents(
1559         command_queue,
1560         num_events,
1561         event_list);
1562 }
1563
1564 CL_API_ENTRY cl_int CL_API_CALL
1565 clEnqueueBarrier(cl_command_queue command_queue) 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->clEnqueueBarrier(command_queue);
1569 }
1570
1571 CL_API_ENTRY void * CL_API_CALL
1572 clGetExtensionFunctionAddress(const char *function_name) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED
1573 {
1574     size_t function_name_length = 0;
1575     KHRicdVendor* vendor = NULL;
1576
1577     KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL);
1578
1579     // make sure the ICD is initialized
1580     khrIcdInitialize();
1581     function_name_length = strlen(function_name);
1582
1583     // return any ICD-aware extensions
1584
1585     // Most extensions, including multi-vendor KHR and EXT extensions,
1586     // do not need to be ICD-aware and do not require any ICD loader
1587     // modifications.  The KHR and EXT extensions below were added for
1588     // backwards compatibility only.
1589     #define CL_COMMON_EXTENSION_ENTRYPOINT_ADD(name) if (!strcmp(function_name, #name) ) return (void *)(size_t)&name
1590
1591     // Functions supporting the creation of OpenCL Memory Objects
1592     // from OpenGL Objects (cl_apple_gl_sharing, cl_khr_gl_sharing)
1593     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLBuffer);
1594     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture);
1595     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture2D);
1596     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture3D);
1597     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLRenderbuffer);
1598     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLObjectInfo);
1599     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLTextureInfo);
1600     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireGLObjects);
1601     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseGLObjects);
1602
1603     // cl_khr_gl_sharing
1604     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLContextInfoKHR);
1605
1606     // cl_khr_gl_event
1607     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromGLsyncKHR);
1608
1609 #if defined(_WIN32)
1610     // cl_khr_d3d10_sharing
1611     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D10KHR);
1612     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10BufferKHR);
1613     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture2DKHR);
1614     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture3DKHR);
1615     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D10ObjectsKHR);
1616     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D10ObjectsKHR);
1617     // cl_khr_d3d11_sharing
1618     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D11KHR);
1619     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11BufferKHR);
1620     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture2DKHR);
1621     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture3DKHR);
1622     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D11ObjectsKHR);
1623     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D11ObjectsKHR);
1624     // cl_khr_dx9_media_sharing
1625     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromDX9MediaAdapterKHR);
1626     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromDX9MediaSurfaceKHR);
1627     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireDX9MediaSurfacesKHR);
1628     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseDX9MediaSurfacesKHR);
1629 #endif
1630
1631     // cl_ext_device_fission
1632     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateSubDevicesEXT);
1633     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clRetainDeviceEXT);
1634     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clReleaseDeviceEXT);
1635
1636     /* cl_khr_egl_image */
1637     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromEGLImageKHR);
1638     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireEGLObjectsKHR);
1639     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseEGLObjectsKHR);
1640
1641     /* cl_khr_egl_event */
1642     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromEGLSyncKHR);
1643
1644     /* cl_khr_sub_groups */
1645     CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetKernelSubGroupInfoKHR);
1646
1647     #undef CL_COMMON_EXTENSION_ENTRYPOINT_ADD
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     cl_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     cl_GLenum       target,
1702     cl_GLint        miplevel,
1703     cl_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     cl_GLenum       target,
1720     cl_GLint        miplevel,
1721     cl_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     cl_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     cl_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