/* Modifications Copyright(C) 2022 Advanced Micro Devices, Inc.
 * All rights reserved.
 */

/*
 * Copyright (c) 2012-2020 The Khronos Group Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * OpenCL is a trademark of Apple Inc. used under license by Khronos.
 */

#include "icd_dispatch.h"
#include "icd.h"
#include <stdlib.h>
#include <string.h>

// Platform APIs
CL_API_ENTRY cl_int CL_API_CALL clGetPlatformIDs(cl_uint num_entries, cl_platform_id* platforms,
                                                 cl_uint* num_platforms)
    CL_API_SUFFIX__VERSION_1_0 {
  KHRicdVendor* vendor = NULL;
  cl_uint i;

  // initialize the platforms (in case they have not been already)
  khrIcdInitialize();

  if (!num_entries && platforms) {
    return CL_INVALID_VALUE;
  }
  if (!platforms && !num_platforms) {
    return CL_INVALID_VALUE;
  }
  // set num_platforms to 0 and set all platform pointers to NULL
  if (num_platforms) {
    *num_platforms = 0;
  }
  for (i = 0; i < num_entries && platforms; ++i) {
    platforms[i] = NULL;
  }
  // return error if we have no platforms
  if (!khrIcdVendors) {
    return CL_PLATFORM_NOT_FOUND_KHR;
  }
  // otherwise enumerate all platforms
  for (vendor = khrIcdVendors; vendor; vendor = vendor->next) {
    if (num_entries && platforms) {
      *(platforms++) = vendor->platform;
      --num_entries;
    }
    if (num_platforms) {
      ++(*num_platforms);
    }
  }
  return CL_SUCCESS;
}

CL_API_ENTRY cl_int CL_API_CALL
clGetPlatformInfo(cl_platform_id platform, cl_platform_info param_name, size_t param_value_size,
                  void* param_value, size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 {
  // initialize the platforms (in case they have not been already)
  khrIcdInitialize();
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
  return platform->dispatch->clGetPlatformInfo(platform, param_name, param_value_size, param_value,
                                               param_value_size_ret);
}

// Device APIs
CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDs(cl_platform_id platform, cl_device_type device_type,
                                               cl_uint num_entries, cl_device_id* devices,
                                               cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_0 {
  // initialize the platforms (in case they have not been already)
  khrIcdInitialize();
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
  return platform->dispatch->clGetDeviceIDs(platform, device_type, num_entries, devices,
                                            num_devices);
}

CL_API_ENTRY cl_int CL_API_CALL
clGetDeviceInfo(cl_device_id device, cl_device_info param_name, size_t param_value_size,
                void* param_value, size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
  return device->dispatch->clGetDeviceInfo(device, param_name, param_value_size, param_value,
                                           param_value_size_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevices(
    cl_device_id in_device, const cl_device_partition_property* properties, cl_uint num_entries,
    cl_device_id* out_devices, cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
  return in_device->dispatch->clCreateSubDevices(in_device, properties, num_entries, out_devices,
                                                 num_devices);
}

CL_API_ENTRY cl_int CL_API_CALL clRetainDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
  return device->dispatch->clRetainDevice(device);
}

CL_API_ENTRY cl_int CL_API_CALL clReleaseDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
  return device->dispatch->clReleaseDevice(device);
}

// Context APIs
CL_API_ENTRY cl_context CL_API_CALL clCreateContext(
    const cl_context_properties* properties, cl_uint num_devices, const cl_device_id* devices,
    void(CL_CALLBACK* pfn_notify)(const char*, const void*, size_t, void*), void* user_data,
    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  // initialize the platforms (in case they have not been already)
  khrIcdInitialize();
  if (!num_devices || !devices) {
    if (errcode_ret) {
      *errcode_ret = CL_INVALID_VALUE;
    }
    return NULL;
  }
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(devices[0], CL_INVALID_DEVICE);
  return devices[0]->dispatch->clCreateContext(properties, num_devices, devices, pfn_notify,
                                               user_data, errcode_ret);
}

CL_API_ENTRY cl_context CL_API_CALL
clCreateContextFromType(const cl_context_properties* properties, cl_device_type device_type,
                        void(CL_CALLBACK* pfn_notify)(const char*, const void*, size_t, void*),
                        void* user_data, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  cl_platform_id platform = NULL;

  // initialize the platforms (in case they have not been already)
  khrIcdInitialize();

  // determine the platform to use from the properties specified
  khrIcdContextPropertiesGetPlatform(properties, &platform);

  // validate the platform handle and dispatch
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(platform, CL_INVALID_PLATFORM);
  return platform->dispatch->clCreateContextFromType(properties, device_type, pfn_notify, user_data,
                                                     errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clRetainContext(cl_context context) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
  return context->dispatch->clRetainContext(context);
}

CL_API_ENTRY cl_int CL_API_CALL clReleaseContext(cl_context context) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
  return context->dispatch->clReleaseContext(context);
}

CL_API_ENTRY cl_int CL_API_CALL
clGetContextInfo(cl_context context, cl_context_info param_name, size_t param_value_size,
                 void* param_value, size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
  return context->dispatch->clGetContextInfo(context, param_name, param_value_size, param_value,
                                             param_value_size_ret);
}

// Command Queue APIs
CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueue(
    cl_context context, cl_device_id device, cl_command_queue_properties properties,
    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateCommandQueue(context, device, properties, errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clRetainCommandQueue(cl_command_queue command_queue)
    CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clRetainCommandQueue(command_queue);
}

CL_API_ENTRY cl_int CL_API_CALL clReleaseCommandQueue(cl_command_queue command_queue)
    CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clReleaseCommandQueue(command_queue);
}

CL_API_ENTRY cl_int CL_API_CALL clGetCommandQueueInfo(
    cl_command_queue command_queue, cl_command_queue_info param_name, size_t param_value_size,
    void* param_value, size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clGetCommandQueueInfo(command_queue, param_name, param_value_size,
                                                        param_value, param_value_size_ret);
}

// Memory Object APIs
CL_API_ENTRY cl_mem CL_API_CALL clCreateBuffer(cl_context context, cl_mem_flags flags, size_t size,
                                               void* host_ptr,
                                               cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateBuffer(context, flags, size, host_ptr, errcode_ret);
}

CL_API_ENTRY cl_mem CL_API_CALL clCreateImage(cl_context context, cl_mem_flags flags,
                                              const cl_image_format* image_format,
                                              const cl_image_desc* image_desc, void* host_ptr,
                                              cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateImage(context, flags, image_format, image_desc, host_ptr,
                                          errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clRetainMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
  return memobj->dispatch->clRetainMemObject(memobj);
}


CL_API_ENTRY cl_int CL_API_CALL clReleaseMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
  return memobj->dispatch->clReleaseMemObject(memobj);
}

CL_API_ENTRY cl_int CL_API_CALL clGetSupportedImageFormats(
    cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint num_entries,
    cl_image_format* image_formats, cl_uint* num_image_formats) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
  return context->dispatch->clGetSupportedImageFormats(context, flags, image_type, num_entries,
                                                       image_formats, num_image_formats);
}

CL_API_ENTRY cl_int CL_API_CALL
clGetMemObjectInfo(cl_mem memobj, cl_mem_info param_name, size_t param_value_size,
                   void* param_value, size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
  return memobj->dispatch->clGetMemObjectInfo(memobj, param_name, param_value_size, param_value,
                                              param_value_size_ret);
}

CL_API_ENTRY cl_int CL_API_CALL
clGetImageInfo(cl_mem image, cl_image_info param_name, size_t param_value_size, void* param_value,
               size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(image, CL_INVALID_MEM_OBJECT);
  return image->dispatch->clGetImageInfo(image, param_name, param_value_size, param_value,
                                         param_value_size_ret);
}

// Sampler APIs
CL_API_ENTRY cl_sampler CL_API_CALL
clCreateSampler(cl_context context, cl_bool normalized_coords, cl_addressing_mode addressing_mode,
                cl_filter_mode filter_mode, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateSampler(context, normalized_coords, addressing_mode,
                                            filter_mode, errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clRetainSampler(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
  return sampler->dispatch->clRetainSampler(sampler);
}

CL_API_ENTRY cl_int CL_API_CALL clReleaseSampler(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
  return sampler->dispatch->clReleaseSampler(sampler);
}

CL_API_ENTRY cl_int CL_API_CALL
clGetSamplerInfo(cl_sampler sampler, cl_sampler_info param_name, size_t param_value_size,
                 void* param_value, size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER);
  return sampler->dispatch->clGetSamplerInfo(sampler, param_name, param_value_size, param_value,
                                             param_value_size_ret);
}

// Program Object APIs
CL_API_ENTRY cl_program CL_API_CALL
clCreateProgramWithSource(cl_context context, cl_uint count, const char** strings,
                          const size_t* lengths, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateProgramWithSource(context, count, strings, lengths,
                                                      errcode_ret);
}

CL_API_ENTRY cl_program CL_API_CALL
clCreateProgramWithBinary(cl_context context, cl_uint num_devices, const cl_device_id* device_list,
                          const size_t* lengths, const unsigned char** binaries,
                          cl_int* binary_status, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateProgramWithBinary(context, num_devices, device_list, lengths,
                                                      binaries, binary_status, errcode_ret);
}

CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBuiltInKernels(
    cl_context context, cl_uint num_devices, const cl_device_id* device_list,
    const char* kernel_names, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateProgramWithBuiltInKernels(context, num_devices, device_list,
                                                              kernel_names, errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clRetainProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
  return program->dispatch->clRetainProgram(program);
}

CL_API_ENTRY cl_int CL_API_CALL clReleaseProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
  return program->dispatch->clReleaseProgram(program);
}

CL_API_ENTRY cl_int CL_API_CALL clBuildProgram(cl_program program, cl_uint num_devices,
                                               const cl_device_id* device_list, const char* options,
                                               void(CL_CALLBACK* pfn_notify)(cl_program program,
                                                                             void* user_data),
                                               void* user_data) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
  return program->dispatch->clBuildProgram(program, num_devices, device_list, options, pfn_notify,
                                           user_data);
}

CL_API_ENTRY cl_int CL_API_CALL clCompileProgram(
    cl_program program, cl_uint num_devices, const cl_device_id* device_list, const char* options,
    cl_uint num_input_headers, const cl_program* input_headers, const char** header_include_names,
    void(CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
    void* user_data) CL_API_SUFFIX__VERSION_1_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
  return program->dispatch->clCompileProgram(program, num_devices, device_list, options,
                                             num_input_headers, input_headers, header_include_names,
                                             pfn_notify, user_data);
}

CL_API_ENTRY cl_program CL_API_CALL
clLinkProgram(cl_context context, cl_uint num_devices, const cl_device_id* device_list,
              const char* options, cl_uint num_input_programs, const cl_program* input_programs,
              void(CL_CALLBACK* pfn_notify)(cl_program program, void* user_data), void* user_data,
              cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clLinkProgram(context, num_devices, device_list, options,
                                          num_input_programs, input_programs, pfn_notify, user_data,
                                          errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL
clSetProgramSpecializationConstant(cl_program program, cl_uint spec_id, size_t spec_size,
                                   const void* spec_value) CL_API_SUFFIX__VERSION_2_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
  return program->dispatch->clSetProgramSpecializationConstant(program, spec_id, spec_size,
                                                               spec_value);
}

CL_API_ENTRY cl_int CL_API_CALL clSetProgramReleaseCallback(
    cl_program program, void(CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
    void* user_data) CL_API_SUFFIX__VERSION_2_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
  return program->dispatch->clSetProgramReleaseCallback(program, pfn_notify, user_data);
}

CL_API_ENTRY cl_int CL_API_CALL clUnloadPlatformCompiler(cl_platform_id platform)
    CL_API_SUFFIX__VERSION_1_2 {
  // initialize the platforms (in case they have not been already)
  khrIcdInitialize();
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
  return platform->dispatch->clUnloadPlatformCompiler(platform);
}

CL_API_ENTRY cl_int CL_API_CALL
clGetProgramInfo(cl_program program, cl_program_info param_name, size_t param_value_size,
                 void* param_value, size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
  return program->dispatch->clGetProgramInfo(program, param_name, param_value_size, param_value,
                                             param_value_size_ret);
}

CL_API_ENTRY cl_int CL_API_CALL
clGetProgramBuildInfo(cl_program program, cl_device_id device, cl_program_build_info param_name,
                      size_t param_value_size, void* param_value,
                      size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
  return program->dispatch->clGetProgramBuildInfo(program, device, param_name, param_value_size,
                                                  param_value, param_value_size_ret);
}

// Kernel Object APIs
CL_API_ENTRY cl_kernel CL_API_CALL clCreateKernel(cl_program program, const char* kernel_name,
                                                  cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(program, CL_INVALID_PROGRAM);
  return program->dispatch->clCreateKernel(program, kernel_name, errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL
clCreateKernelsInProgram(cl_program program, cl_uint num_kernels, cl_kernel* kernels,
                         cl_uint* num_kernels_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM);
  return program->dispatch->clCreateKernelsInProgram(program, num_kernels, kernels,
                                                     num_kernels_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clRetainKernel(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
  return kernel->dispatch->clRetainKernel(kernel);
}

CL_API_ENTRY cl_int CL_API_CALL clReleaseKernel(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
  return kernel->dispatch->clReleaseKernel(kernel);
}

CL_API_ENTRY cl_int CL_API_CALL clSetKernelArg(cl_kernel kernel, cl_uint arg_index, size_t arg_size,
                                               const void* arg_value) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
  return kernel->dispatch->clSetKernelArg(kernel, arg_index, arg_size, arg_value);
}

CL_API_ENTRY cl_int CL_API_CALL
clGetKernelInfo(cl_kernel kernel, cl_kernel_info param_name, size_t param_value_size,
                void* param_value, size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
  return kernel->dispatch->clGetKernelInfo(kernel, param_name, param_value_size, param_value,
                                           param_value_size_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clGetKernelArgInfo(
    cl_kernel kernel, cl_uint arg_indx, cl_kernel_arg_info param_name, size_t param_value_size,
    void* param_value, size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
  return kernel->dispatch->clGetKernelArgInfo(kernel, arg_indx, param_name, param_value_size,
                                              param_value, param_value_size_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clGetKernelWorkGroupInfo(
    cl_kernel kernel, cl_device_id device, cl_kernel_work_group_info param_name,
    size_t param_value_size, void* param_value,
    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
  return kernel->dispatch->clGetKernelWorkGroupInfo(kernel, device, param_name, param_value_size,
                                                    param_value, param_value_size_ret);
}

// Event Object APIs
CL_API_ENTRY cl_int CL_API_CALL clWaitForEvents(cl_uint num_events, const cl_event* event_list)
    CL_API_SUFFIX__VERSION_1_0 {
  if (!num_events || !event_list) {
    return CL_INVALID_VALUE;
  }
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event_list[0], CL_INVALID_EVENT);
  return event_list[0]->dispatch->clWaitForEvents(num_events, event_list);
}

CL_API_ENTRY cl_int CL_API_CALL
clGetEventInfo(cl_event event, cl_event_info param_name, size_t param_value_size, void* param_value,
               size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
  return event->dispatch->clGetEventInfo(event, param_name, param_value_size, param_value,
                                         param_value_size_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clRetainEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
  return event->dispatch->clRetainEvent(event);
}

CL_API_ENTRY cl_int CL_API_CALL clReleaseEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
  return event->dispatch->clReleaseEvent(event);
}

// Profiling APIs
CL_API_ENTRY cl_int CL_API_CALL clGetEventProfilingInfo(
    cl_event event, cl_profiling_info param_name, size_t param_value_size, void* param_value,
    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
  return event->dispatch->clGetEventProfilingInfo(event, param_name, param_value_size, param_value,
                                                  param_value_size_ret);
}

// Flush and Finish APIs
CL_API_ENTRY cl_int CL_API_CALL clFlush(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clFlush(command_queue);
}

CL_API_ENTRY cl_int CL_API_CALL clFinish(cl_command_queue command_queue)
    CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clFinish(command_queue);
}

// Enqueued Commands APIs
CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBuffer(cl_command_queue command_queue, cl_mem buffer,
                                                    cl_bool blocking_read, size_t offset, size_t cb,
                                                    void* ptr, cl_uint num_events_in_wait_list,
                                                    const cl_event* event_wait_list,
                                                    cl_event* event) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueReadBuffer(command_queue, buffer, blocking_read, offset,
                                                      cb, ptr, num_events_in_wait_list,
                                                      event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBufferRect(
    cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read,
    const size_t* buffer_origin, const size_t* host_origin, const size_t* region,
    size_t buffer_row_pitch, size_t buffer_slice_pitch, size_t host_row_pitch,
    size_t host_slice_pitch, void* ptr, cl_uint num_events_in_wait_list,
    const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_1_1 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueReadBufferRect(
      command_queue, buffer, blocking_read, buffer_origin, host_origin, region, buffer_row_pitch,
      buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list,
      event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBuffer(cl_command_queue command_queue, cl_mem buffer,
                                                     cl_bool blocking_write, size_t offset,
                                                     size_t cb, const void* ptr,
                                                     cl_uint num_events_in_wait_list,
                                                     const cl_event* event_wait_list,
                                                     cl_event* event) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueWriteBuffer(command_queue, buffer, blocking_write,
                                                       offset, cb, ptr, num_events_in_wait_list,
                                                       event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBufferRect(
    cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read,
    const size_t* buffer_origin, const size_t* host_origin, const size_t* region,
    size_t buffer_row_pitch, size_t buffer_slice_pitch, size_t host_row_pitch,
    size_t host_slice_pitch, const void* ptr, cl_uint num_events_in_wait_list,
    const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_1_1 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueWriteBufferRect(
      command_queue, buffer, blocking_read, buffer_origin, host_origin, region, buffer_row_pitch,
      buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list,
      event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillBuffer(cl_command_queue command_queue, cl_mem buffer,
                                                    const void* pattern, size_t pattern_size,
                                                    size_t offset, size_t cb,
                                                    cl_uint num_events_in_wait_list,
                                                    const cl_event* event_wait_list,
                                                    cl_event* event) CL_API_SUFFIX__VERSION_1_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueFillBuffer(command_queue, buffer, pattern, pattern_size,
                                                      offset, cb, num_events_in_wait_list,
                                                      event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBuffer(cl_command_queue command_queue,
                                                    cl_mem src_buffer, cl_mem dst_buffer,
                                                    size_t src_offset, size_t dst_offset, size_t cb,
                                                    cl_uint num_events_in_wait_list,
                                                    const cl_event* event_wait_list,
                                                    cl_event* event) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueCopyBuffer(
      command_queue, src_buffer, dst_buffer, src_offset, dst_offset, cb, num_events_in_wait_list,
      event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferRect(
    cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer, const size_t* src_origin,
    const size_t* dst_origin, const size_t* region, size_t src_row_pitch, size_t src_slice_pitch,
    size_t dst_row_pitch, size_t dst_slice_pitch, cl_uint num_events_in_wait_list,
    const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_1_1 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueCopyBufferRect(
      command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch,
      src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list,
      event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadImage(cl_command_queue command_queue, cl_mem image,
                                                   cl_bool blocking_read, const size_t* origin,
                                                   const size_t* region, size_t row_pitch,
                                                   size_t slice_pitch, void* ptr,
                                                   cl_uint num_events_in_wait_list,
                                                   const cl_event* event_wait_list,
                                                   cl_event* event) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueReadImage(
      command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr,
      num_events_in_wait_list, event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteImage(cl_command_queue command_queue, cl_mem image,
                                                    cl_bool blocking_write, const size_t* origin,
                                                    const size_t* region, size_t input_row_pitch,
                                                    size_t input_slice_pitch, const void* ptr,
                                                    cl_uint num_events_in_wait_list,
                                                    const cl_event* event_wait_list,
                                                    cl_event* event) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueWriteImage(
      command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr,
      num_events_in_wait_list, event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillImage(cl_command_queue command_queue, cl_mem image,
                                                   const void* fill_color, const size_t origin[3],
                                                   const size_t region[3],
                                                   cl_uint num_events_in_wait_list,
                                                   const cl_event* event_wait_list,
                                                   cl_event* event) CL_API_SUFFIX__VERSION_1_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueFillImage(command_queue, image, fill_color, origin,
                                                     region, num_events_in_wait_list,
                                                     event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImage(cl_command_queue command_queue, cl_mem src_image,
                                                   cl_mem dst_image, const size_t* src_origin,
                                                   const size_t* dst_origin, const size_t* region,
                                                   cl_uint num_events_in_wait_list,
                                                   const cl_event* event_wait_list,
                                                   cl_event* event) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueCopyImage(
      command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list,
      event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImageToBuffer(
    cl_command_queue command_queue, cl_mem src_image, cl_mem dst_buffer, const size_t* src_origin,
    const size_t* region, size_t dst_offset, cl_uint num_events_in_wait_list,
    const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueCopyImageToBuffer(
      command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list,
      event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferToImage(
    cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_image, size_t src_offset,
    const size_t* dst_origin, const size_t* region, cl_uint num_events_in_wait_list,
    const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueCopyBufferToImage(
      command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list,
      event_wait_list, event);
}

CL_API_ENTRY void* CL_API_CALL clEnqueueMapBuffer(cl_command_queue command_queue, cl_mem buffer,
                                                  cl_bool blocking_map, cl_map_flags map_flags,
                                                  size_t offset, size_t cb,
                                                  cl_uint num_events_in_wait_list,
                                                  const cl_event* event_wait_list, cl_event* event,
                                                  cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueMapBuffer(command_queue, buffer, blocking_map, map_flags,
                                                     offset, cb, num_events_in_wait_list,
                                                     event_wait_list, event, errcode_ret);
}

CL_API_ENTRY void* CL_API_CALL clEnqueueMapImage(cl_command_queue command_queue, cl_mem image,
                                                 cl_bool blocking_map, cl_map_flags map_flags,
                                                 const size_t* origin, const size_t* region,
                                                 size_t* image_row_pitch, size_t* image_slice_pitch,
                                                 cl_uint num_events_in_wait_list,
                                                 const cl_event* event_wait_list, cl_event* event,
                                                 cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueMapImage(
      command_queue, image, blocking_map, map_flags, origin, region, image_row_pitch,
      image_slice_pitch, num_events_in_wait_list, event_wait_list, event, errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueUnmapMemObject(cl_command_queue command_queue, cl_mem memobj, void* mapped_ptr,
                        cl_uint num_events_in_wait_list, const cl_event* event_wait_list,
                        cl_event* event) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueUnmapMemObject(
      command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemObjects(
    cl_command_queue command_queue, cl_uint num_mem_objects, const cl_mem* mem_objects,
    cl_mem_migration_flags flags, cl_uint num_events_in_wait_list, const cl_event* event_wait_list,
    cl_event* event) CL_API_SUFFIX__VERSION_1_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueMigrateMemObjects(
      command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list,
      event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueNDRangeKernel(
    cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim,
    const size_t* global_work_offset, const size_t* global_work_size, const size_t* local_work_size,
    cl_uint num_events_in_wait_list, const cl_event* event_wait_list,
    cl_event* event) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueNDRangeKernel(
      command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size,
      num_events_in_wait_list, event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueTask(cl_command_queue command_queue, cl_kernel kernel,
                                              cl_uint num_events_in_wait_list,
                                              const cl_event* event_wait_list,
                                              cl_event* event) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueTask(command_queue, kernel, num_events_in_wait_list,
                                                event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueNativeKernel(cl_command_queue command_queue, void(CL_CALLBACK* user_func)(void*),
                      void* args, size_t cb_args, cl_uint num_mem_objects, const cl_mem* mem_list,
                      const void** args_mem_loc, cl_uint num_events_in_wait_list,
                      const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueNativeKernel(
      command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc,
      num_events_in_wait_list, event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarkerWithWaitList(
    cl_command_queue command_queue, cl_uint num_events_in_wait_list,
    const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_1_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueMarkerWithWaitList(
      command_queue, num_events_in_wait_list, event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrierWithWaitList(
    cl_command_queue command_queue, cl_uint num_events_in_wait_list,
    const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_1_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueBarrierWithWaitList(
      command_queue, num_events_in_wait_list, event_wait_list, event);
}

CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddressForPlatform(
    cl_platform_id platform, const char* function_name) CL_API_SUFFIX__VERSION_1_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL);

  // make sure the ICD is initialized
  khrIcdInitialize();

// return any ICD-aware extensions

// Most extensions, including multi-vendor KHR and EXT extensions,
// do not need to be ICD-aware and do not require any ICD loader
// modifications.  The KHR and EXT extensions below were added for
// backwards compatibility only.
#define CL_COMMON_EXTENSION_ENTRYPOINT_ADD(name)                                                   \
  if (!strcmp(function_name, #name)) return (void*)(size_t)&name

  // Functions supporting the creation of OpenCL Memory Objects
  // from OpenGL Objects (cl_apple_gl_sharing, cl_khr_gl_sharing)
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLBuffer);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture2D);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture3D);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLRenderbuffer);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLObjectInfo);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLTextureInfo);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireGLObjects);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseGLObjects);

  // cl_khr_gl_sharing
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLContextInfoKHR);

  // cl_khr_gl_event
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromGLsyncKHR);

#if defined(_WIN32)
  // cl_khr_d3d10_sharing
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D10KHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10BufferKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture2DKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture3DKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D10ObjectsKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D10ObjectsKHR);
  // cl_khr_d3d11_sharing
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D11KHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11BufferKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture2DKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture3DKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D11ObjectsKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D11ObjectsKHR);
  // cl_khr_dx9_media_sharing
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromDX9MediaAdapterKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromDX9MediaSurfaceKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireDX9MediaSurfacesKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseDX9MediaSurfacesKHR);
#endif

  // cl_ext_device_fission
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateSubDevicesEXT);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clRetainDeviceEXT);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clReleaseDeviceEXT);

  /* cl_khr_egl_image */
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromEGLImageKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireEGLObjectsKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseEGLObjectsKHR);

  /* cl_khr_egl_event */
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromEGLSyncKHR);

  /* cl_khr_sub_groups */
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetKernelSubGroupInfoKHR);

#undef CL_COMMON_EXTENSION_ENTRYPOINT_ADD

  // This is not an ICD-aware extension, so call into the implementation
  // to get the extension function address.

  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, NULL);
  return platform->dispatch->clGetExtensionFunctionAddressForPlatform(platform, function_name);
}

// Deprecated APIs
CL_API_ENTRY cl_int CL_API_CALL clSetCommandQueueProperty(
    cl_command_queue command_queue, cl_command_queue_properties properties, cl_bool enable,
    cl_command_queue_properties* old_properties) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clSetCommandQueueProperty(command_queue, properties, enable,
                                                            old_properties);
}

CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevicesEXT(
    cl_device_id in_device, const cl_device_partition_property_ext* partition_properties,
    cl_uint num_entries, cl_device_id* out_devices,
    cl_uint* num_devices) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE);
  return in_device->dispatch->clCreateSubDevicesEXT(in_device, partition_properties, num_entries,
                                                    out_devices, num_devices);
}

CL_API_ENTRY cl_int CL_API_CALL clRetainDeviceEXT(cl_device_id device)
    CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
  return device->dispatch->clRetainDeviceEXT(device);
}

CL_API_ENTRY cl_int CL_API_CALL clReleaseDeviceEXT(cl_device_id device)
    CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
  return device->dispatch->clReleaseDeviceEXT(device);
}

CL_API_ENTRY cl_mem CL_API_CALL
clCreateImage2D(cl_context context, cl_mem_flags flags, const cl_image_format* image_format,
                size_t image_width, size_t image_height, size_t image_row_pitch, void* host_ptr,
                cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateImage2D(context, flags, image_format, image_width, image_height,
                                            image_row_pitch, host_ptr, errcode_ret);
}

CL_API_ENTRY cl_mem CL_API_CALL clCreateImage3D(
    cl_context context, cl_mem_flags flags, const cl_image_format* image_format, size_t image_width,
    size_t image_height, size_t image_depth, size_t image_row_pitch, size_t image_slice_pitch,
    void* host_ptr, cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateImage3D(context, flags, image_format, image_width, image_height,
                                            image_depth, image_row_pitch, image_slice_pitch,
                                            host_ptr, errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clUnloadCompiler(void) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED {
  return CL_SUCCESS;
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarker(cl_command_queue command_queue, cl_event* event)
    CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueMarker(command_queue, event);
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueWaitForEvents(cl_command_queue command_queue, cl_uint num_events,
                       const cl_event* event_list) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueWaitForEvents(command_queue, num_events, event_list);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrier(cl_command_queue command_queue)
    CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueBarrier(command_queue);
}

CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddress(const char* function_name)
    CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED {
  size_t function_name_length = 0;
  KHRicdVendor* vendor = NULL;

  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL);

  // make sure the ICD is initialized
  khrIcdInitialize();
  function_name_length = strlen(function_name);

// return any ICD-aware extensions

// Most extensions, including multi-vendor KHR and EXT extensions,
// do not need to be ICD-aware and do not require any ICD loader
// modifications.  The KHR and EXT extensions below were added for
// backwards compatibility only.
#define CL_COMMON_EXTENSION_ENTRYPOINT_ADD(name)                                                   \
  if (!strcmp(function_name, #name)) return (void*)(size_t)&name

  // Functions supporting the creation of OpenCL Memory Objects
  // from OpenGL Objects (cl_apple_gl_sharing, cl_khr_gl_sharing)
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLBuffer);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture2D);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture3D);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLRenderbuffer);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLObjectInfo);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLTextureInfo);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireGLObjects);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseGLObjects);

  // cl_khr_gl_sharing
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLContextInfoKHR);

  // cl_khr_gl_event
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromGLsyncKHR);

#if defined(_WIN32)
  // cl_khr_d3d10_sharing
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D10KHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10BufferKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture2DKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture3DKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D10ObjectsKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D10ObjectsKHR);
  // cl_khr_d3d11_sharing
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D11KHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11BufferKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture2DKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture3DKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D11ObjectsKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D11ObjectsKHR);
  // cl_khr_dx9_media_sharing
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromDX9MediaAdapterKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromDX9MediaSurfaceKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireDX9MediaSurfacesKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseDX9MediaSurfacesKHR);
#endif

  // cl_ext_device_fission
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateSubDevicesEXT);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clRetainDeviceEXT);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clReleaseDeviceEXT);

  /* cl_khr_egl_image */
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromEGLImageKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireEGLObjectsKHR);
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseEGLObjectsKHR);

  /* cl_khr_egl_event */
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromEGLSyncKHR);

  /* cl_khr_sub_groups */
  CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetKernelSubGroupInfoKHR);

#undef CL_COMMON_EXTENSION_ENTRYPOINT_ADD

  // fall back to vendor extension detection
  for (vendor = khrIcdVendors; vendor; vendor = vendor->next) {
    size_t vendor_suffix_length = strlen(vendor->suffix);
    if (vendor_suffix_length <= function_name_length && vendor_suffix_length > 0) {
      const char* function_suffix = function_name + function_name_length - vendor_suffix_length;
      if (!strcmp(function_suffix, vendor->suffix)) {
        return vendor->clGetExtensionFunctionAddress(function_name);
      }
    }
  }
  return NULL;
}

// GL and other APIs
CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer(cl_context context, cl_mem_flags flags,
                                                     cl_GLuint bufobj,
                                                     int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateFromGLBuffer(context, flags, bufobj, errcode_ret);
}

CL_API_ENTRY cl_mem CL_API_CALL
clCreateFromGLTexture(cl_context context, cl_mem_flags flags, cl_GLenum target, cl_GLint miplevel,
                      cl_GLuint texture, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateFromGLTexture(context, flags, target, miplevel, texture,
                                                  errcode_ret);
}

CL_API_ENTRY cl_mem CL_API_CALL
clCreateFromGLTexture2D(cl_context context, cl_mem_flags flags, cl_GLenum target, cl_GLint miplevel,
                        cl_GLuint texture, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateFromGLTexture2D(context, flags, target, miplevel, texture,
                                                    errcode_ret);
}

CL_API_ENTRY cl_mem CL_API_CALL
clCreateFromGLTexture3D(cl_context context, cl_mem_flags flags, cl_GLenum target, cl_GLint miplevel,
                        cl_GLuint texture, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateFromGLTexture3D(context, flags, target, miplevel, texture,
                                                    errcode_ret);
}

CL_API_ENTRY cl_mem CL_API_CALL
clCreateFromGLRenderbuffer(cl_context context, cl_mem_flags flags, cl_GLuint renderbuffer,
                           cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateFromGLRenderbuffer(context, flags, renderbuffer, errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo(cl_mem memobj, cl_gl_object_type* gl_object_type,
                                                  cl_GLuint* gl_object_name)
    CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
  return memobj->dispatch->clGetGLObjectInfo(memobj, gl_object_type, gl_object_name);
}

CL_API_ENTRY cl_int CL_API_CALL
clGetGLTextureInfo(cl_mem memobj, cl_gl_texture_info param_name, size_t param_value_size,
                   void* param_value, size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
  return memobj->dispatch->clGetGLTextureInfo(memobj, param_name, param_value_size, param_value,
                                              param_value_size_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects(
    cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects,
    cl_uint num_events_in_wait_list, const cl_event* event_wait_list,
    cl_event* event) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueAcquireGLObjects(
      command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects(
    cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects,
    cl_uint num_events_in_wait_list, const cl_event* event_wait_list,
    cl_event* event) CL_API_SUFFIX__VERSION_1_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueReleaseGLObjects(
      command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clGetGLContextInfoKHR(
    const cl_context_properties* properties, cl_gl_context_info param_name, size_t param_value_size,
    void* param_value, size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 {
  cl_platform_id platform = NULL;

  // initialize the platforms (in case they have not been already)
  khrIcdInitialize();

  // determine the platform to use from the properties specified
  khrIcdContextPropertiesGetPlatform(properties, &platform);

  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
  return platform->dispatch->clGetGLContextInfoKHR(properties, param_name, param_value_size,
                                                   param_value, param_value_size_ret);
}

CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR(
    cl_context context, cl_GLsync sync, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateEventFromGLsyncKHR(context, sync, errcode_ret);
}

#if defined(_WIN32)
/*
 *
 * cl_d3d10_sharing_khr
 *
 */

CL_API_ENTRY cl_int CL_API_CALL
clGetDeviceIDsFromD3D10KHR(cl_platform_id platform, cl_d3d10_device_source_khr d3d_device_source,
                           void* d3d_object, cl_d3d10_device_set_khr d3d_device_set,
                           cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
  return platform->dispatch->clGetDeviceIDsFromD3D10KHR(
      platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, num_devices);
}

CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10BufferKHR(cl_context context, cl_mem_flags flags,
                                                           ID3D10Buffer* resource,
                                                           cl_int* errcode_ret) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateFromD3D10BufferKHR(context, flags, resource, errcode_ret);
}

CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR(cl_context context,
                                                              cl_mem_flags flags,
                                                              ID3D10Texture2D* resource,
                                                              UINT subresource,
                                                              cl_int* errcode_ret) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateFromD3D10Texture2DKHR(context, flags, resource, subresource,
                                                          errcode_ret);
}

CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR(cl_context context,
                                                              cl_mem_flags flags,
                                                              ID3D10Texture3D* resource,
                                                              UINT subresource,
                                                              cl_int* errcode_ret) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateFromD3D10Texture3DKHR(context, flags, resource, subresource,
                                                          errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR(
    cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects,
    cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueAcquireD3D10ObjectsKHR(
      command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR(
    cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects,
    cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueReleaseD3D10ObjectsKHR(
      command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, event);
}

/*
 *
 * cl_d3d11_sharing_khr
 *
 */

CL_API_ENTRY cl_int CL_API_CALL
clGetDeviceIDsFromD3D11KHR(cl_platform_id platform, cl_d3d11_device_source_khr d3d_device_source,
                           void* d3d_object, cl_d3d11_device_set_khr d3d_device_set,
                           cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
  return platform->dispatch->clGetDeviceIDsFromD3D11KHR(
      platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, num_devices);
}

CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11BufferKHR(cl_context context, cl_mem_flags flags,
                                                           ID3D11Buffer* resource,
                                                           cl_int* errcode_ret) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateFromD3D11BufferKHR(context, flags, resource, errcode_ret);
}

CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR(cl_context context,
                                                              cl_mem_flags flags,
                                                              ID3D11Texture2D* resource,
                                                              UINT subresource,
                                                              cl_int* errcode_ret) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateFromD3D11Texture2DKHR(context, flags, resource, subresource,
                                                          errcode_ret);
}

CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR(cl_context context,
                                                              cl_mem_flags flags,
                                                              ID3D11Texture3D* resource,
                                                              UINT subresource,
                                                              cl_int* errcode_ret) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateFromD3D11Texture3DKHR(context, flags, resource, subresource,
                                                          errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR(
    cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects,
    cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueAcquireD3D11ObjectsKHR(
      command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR(
    cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects,
    cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueReleaseD3D11ObjectsKHR(
      command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, event);
}

/*
 *
 * cl_khr_dx9_media_sharing
 *
 */

CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR(
    cl_platform_id platform, cl_uint num_media_adapters,
    cl_dx9_media_adapter_type_khr* media_adapters_type, void* media_adapters,
    cl_dx9_media_adapter_set_khr media_adapter_set, cl_uint num_entries, cl_device_id* devices,
    cl_uint* num_devices) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM);
  return platform->dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR(
      platform, num_media_adapters, media_adapters_type, media_adapters, media_adapter_set,
      num_entries, devices, num_devices);
}

CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR(
    cl_context context, cl_mem_flags flags, cl_dx9_media_adapter_type_khr adapter_type,
    void* surface_info, cl_uint plane, cl_int* errcode_ret) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateFromDX9MediaSurfaceKHR(context, flags, adapter_type,
                                                           surface_info, plane, errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR(
    cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects,
    cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueAcquireDX9MediaSurfacesKHR(
      command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR(
    cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects,
    cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueReleaseDX9MediaSurfacesKHR(
      command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, event);
}

#endif

CL_API_ENTRY cl_int CL_API_CALL clSetEventCallback(cl_event event,
                                                   cl_int command_exec_callback_type,
                                                   void(CL_CALLBACK* pfn_notify)(cl_event, cl_int,
                                                                                 void*),
                                                   void* user_data) CL_API_SUFFIX__VERSION_1_1 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
  return event->dispatch->clSetEventCallback(event, command_exec_callback_type, pfn_notify,
                                             user_data);
}

CL_API_ENTRY cl_mem CL_API_CALL clCreateSubBuffer(cl_mem buffer, cl_mem_flags flags,
                                                  cl_buffer_create_type buffer_create_type,
                                                  const void* buffer_create_info,
                                                  cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(buffer, CL_INVALID_MEM_OBJECT);
  return buffer->dispatch->clCreateSubBuffer(buffer, flags, buffer_create_type, buffer_create_info,
                                             errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL
clSetMemObjectDestructorCallback(cl_mem memobj, void(CL_CALLBACK* pfn_notify)(cl_mem, void*),
                                 void* user_data) CL_API_SUFFIX__VERSION_1_1 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT);
  return memobj->dispatch->clSetMemObjectDestructorCallback(memobj, pfn_notify, user_data);
}

CL_API_ENTRY cl_event CL_API_CALL clCreateUserEvent(cl_context context, cl_int* errcode_ret)
    CL_API_SUFFIX__VERSION_1_1 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateUserEvent(context, errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clSetUserEventStatus(cl_event event, cl_int execution_status)
    CL_API_SUFFIX__VERSION_1_1 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT);
  return event->dispatch->clSetUserEventStatus(event, execution_status);
}

CL_API_ENTRY cl_mem CL_API_CALL clCreateFromEGLImageKHR(
    cl_context context, CLeglDisplayKHR display, CLeglImageKHR image, cl_mem_flags flags,
    const cl_egl_image_properties_khr* properties, cl_int* errcode_ret) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateFromEGLImageKHR(context, display, image, flags, properties,
                                                    errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR(
    cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects,
    cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueAcquireEGLObjectsKHR(
      command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR(
    cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects,
    cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueReleaseEGLObjectsKHR(
      command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, event);
}

/* cl_khr_egl_event */
CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromEGLSyncKHR(cl_context context, CLeglSyncKHR sync,
                                                              CLeglDisplayKHR display,
                                                              cl_int* errcode_ret) {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateEventFromEGLSyncKHR(context, sync, display, errcode_ret);
}

CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(
    cl_context context, cl_device_id device, const cl_queue_properties* properties,
    cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateCommandQueueWithProperties(context, device, properties,
                                                               errcode_ret);
}

CL_API_ENTRY cl_mem CL_API_CALL clCreatePipe(cl_context context, cl_mem_flags flags,
                                             cl_uint pipe_packet_size, cl_uint pipe_max_packets,
                                             const cl_pipe_properties* properties,
                                             cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreatePipe(context, flags, pipe_packet_size, pipe_max_packets,
                                         properties, errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL
clGetPipeInfo(cl_mem pipe, cl_pipe_info param_name, size_t param_value_size, void* param_value,
              size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_2_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(pipe, CL_INVALID_MEM_OBJECT);
  return pipe->dispatch->clGetPipeInfo(pipe, param_name, param_value_size, param_value,
                                       param_value_size_ret);
}

CL_API_ENTRY void* CL_API_CALL clSVMAlloc(cl_context context, cl_svm_mem_flags flags, size_t size,
                                          cl_uint alignment) CL_API_SUFFIX__VERSION_2_0 {
  if (!context) {
    return NULL;
  }
  return context->dispatch->clSVMAlloc(context, flags, size, alignment);
}

CL_API_ENTRY void CL_API_CALL clSVMFree(cl_context context,
                                        void* svm_pointer) CL_API_SUFFIX__VERSION_2_0 {
  if (!context || !svm_pointer) {
    return;
  }
  context->dispatch->clSVMFree(context, svm_pointer);
}

CL_API_ENTRY cl_int CL_API_CALL
clEnqueueSVMFree(cl_command_queue command_queue, cl_uint num_svm_pointers, void* svm_pointers[],
                 void(CL_CALLBACK* pfn_free_func)(cl_command_queue queue, cl_uint num_svm_pointers,
                                                  void* svm_pointers[], void* user_data),
                 void* user_data, cl_uint num_events_in_wait_list, const cl_event* event_wait_list,
                 cl_event* event) CL_API_SUFFIX__VERSION_2_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueSVMFree(command_queue, num_svm_pointers, svm_pointers,
                                                   pfn_free_func, user_data,
                                                   num_events_in_wait_list, event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemcpy(cl_command_queue command_queue,
                                                   cl_bool blocking_copy, void* dst_ptr,
                                                   const void* src_ptr, size_t size,
                                                   cl_uint num_events_in_wait_list,
                                                   const cl_event* event_wait_list,
                                                   cl_event* event) CL_API_SUFFIX__VERSION_2_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueSVMMemcpy(command_queue, blocking_copy, dst_ptr, src_ptr,
                                                     size, num_events_in_wait_list, event_wait_list,
                                                     event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemFill(cl_command_queue command_queue, void* svm_ptr,
                                                    const void* pattern, size_t pattern_size,
                                                    size_t size, cl_uint num_events_in_wait_list,
                                                    const cl_event* event_wait_list,
                                                    cl_event* event) CL_API_SUFFIX__VERSION_2_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueSVMMemFill(command_queue, svm_ptr, pattern, pattern_size,
                                                      size, num_events_in_wait_list,
                                                      event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMap(cl_command_queue command_queue,
                                                cl_bool blocking_map, cl_map_flags flags,
                                                void* svm_ptr, size_t size,
                                                cl_uint num_events_in_wait_list,
                                                const cl_event* event_wait_list,
                                                cl_event* event) CL_API_SUFFIX__VERSION_2_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueSVMMap(command_queue, blocking_map, flags, svm_ptr, size,
                                                  num_events_in_wait_list, event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMUnmap(cl_command_queue command_queue, void* svm_ptr,
                                                  cl_uint num_events_in_wait_list,
                                                  const cl_event* event_wait_list,
                                                  cl_event* event) CL_API_SUFFIX__VERSION_2_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueSVMUnmap(command_queue, svm_ptr, num_events_in_wait_list,
                                                    event_wait_list, event);
}

CL_API_ENTRY cl_sampler CL_API_CALL
clCreateSamplerWithProperties(cl_context context, const cl_sampler_properties* sampler_properties,
                              cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateSamplerWithProperties(context, sampler_properties, errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgSVMPointer(
    cl_kernel kernel, cl_uint arg_index, const void* arg_value) CL_API_SUFFIX__VERSION_2_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
  return kernel->dispatch->clSetKernelArgSVMPointer(kernel, arg_index, arg_value);
}

CL_API_ENTRY cl_int CL_API_CALL
clSetKernelExecInfo(cl_kernel kernel, cl_kernel_exec_info param_name, size_t param_value_size,
                    const void* param_value) CL_API_SUFFIX__VERSION_2_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
  return kernel->dispatch->clSetKernelExecInfo(kernel, param_name, param_value_size, param_value);
}

CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfoKHR(
    cl_kernel in_kernel, cl_device_id in_device, cl_kernel_sub_group_info param_name,
    size_t input_value_size, const void* input_value, size_t param_value_size, void* param_value,
    size_t* param_value_size_ret) CL_EXT_SUFFIX__VERSION_2_0 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_kernel, CL_INVALID_KERNEL);
  return in_kernel->dispatch->clGetKernelSubGroupInfoKHR(
      in_kernel, in_device, param_name, input_value_size, input_value, param_value_size,
      param_value, param_value_size_ret);
}

CL_API_ENTRY cl_int CL_API_CALL
clSetDefaultDeviceCommandQueue(cl_context context, cl_device_id device,
                               cl_command_queue command_queue) CL_API_SUFFIX__VERSION_2_1 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT);
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
  return context->dispatch->clSetDefaultDeviceCommandQueue(context, device, command_queue);
}

CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithIL(cl_context context, const void* il,
                                                          size_t length, cl_int* errcode_ret)
    CL_API_SUFFIX__VERSION_2_1 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT);
  return context->dispatch->clCreateProgramWithIL(context, il, length, errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfo(
    cl_kernel kernel, cl_device_id device, cl_kernel_sub_group_info param_name,
    size_t input_value_size, const void* input_value, size_t param_value_size, void* param_value,
    size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_2_1 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL);
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
  return kernel->dispatch->clGetKernelSubGroupInfo(kernel, device, param_name, input_value_size,
                                                   input_value, param_value_size, param_value,
                                                   param_value_size_ret);
}

CL_API_ENTRY cl_kernel CL_API_CALL clCloneKernel(cl_kernel source_kernel,
                                                 cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(source_kernel, CL_INVALID_KERNEL);
  return source_kernel->dispatch->clCloneKernel(source_kernel, errcode_ret);
}

CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMigrateMem(
    cl_command_queue command_queue, cl_uint num_svm_pointers, const void** svm_pointers,
    const size_t* sizes, cl_mem_migration_flags flags, cl_uint num_events_in_wait_list,
    const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_2_1 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE);
  return command_queue->dispatch->clEnqueueSVMMigrateMem(
      command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list,
      event_wait_list, event);
}

CL_API_ENTRY cl_int CL_API_CALL
clGetDeviceAndHostTimer(cl_device_id device, cl_ulong* device_timestamp,
                        cl_ulong* host_timestamp) CL_API_SUFFIX__VERSION_2_1 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
  return device->dispatch->clGetDeviceAndHostTimer(device, device_timestamp, host_timestamp);
}

CL_API_ENTRY cl_int CL_API_CALL clGetHostTimer(cl_device_id device, cl_ulong* host_timestamp)
    CL_API_SUFFIX__VERSION_2_1 {
  KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE);
  return device->dispatch->clGetHostTimer(device, host_timestamp);
}