// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from cl.xml.
//
// Copyright 2020 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// libOpenCL_autogen.cpp: Implements the exported CL functions.

//#include "anglebase/no_destructor.h"
//#include "common/system_utils.h"

#include <iostream>
//#include <memory>

#include "cl_loader.h"

namespace
{
bool gLoaded = false;

/* TODO(jplate): uncomment after entry points moved to GLESV2 lib http://anglebug.com/5759
std::unique_ptr<angle::Library> &EntryPointsLib()
{
    static angle::base::NoDestructor<std::unique_ptr<angle::Library>> sEntryPointsLib;
    return *sEntryPointsLib;
}

angle::GenericProc CL_API_ENTRY GlobalLoad(const char *symbol)
{
    return reinterpret_cast<angle::GenericProc>(EntryPointsLib()->getSymbol(symbol));
}
*/

void EnsureCLLoaded()
{
    if (gLoaded)
    {
        return;
    }

    // EntryPointsLib().reset(
    //    angle::OpenSharedLibrary(ANGLE_GLESV2_LIBRARY_NAME, angle::SearchType::ApplicationDir));
    // angle::LoadCL(GlobalLoad);
    angle::LoadCL(nullptr);
    if (!cl_loader.clGetDeviceIDs)
    {
        std::cerr << "Error loading CL entry points." << std::endl;
    }
    else
    {
        gLoaded = true;
    }
}
}  // anonymous namespace

extern "C" {

// CL 1.0
ANGLE_EXPORT cl_int CL_API_ENTRY clGetPlatformIDs(cl_uint num_entries,
                                                  cl_platform_id *platforms,
                                                  cl_uint *num_platforms) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetPlatformIDs(num_entries, platforms, num_platforms);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetPlatformInfo(platform, param_name, param_value_size, param_value,
                                       param_value_size_ret);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clGetDeviceIDs(cl_platform_id platform,
                                                cl_device_type device_type,
                                                cl_uint num_entries,
                                                cl_device_id *devices,
                                                cl_uint *num_devices) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetDeviceIDs(platform, device_type, num_entries, devices, num_devices);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetDeviceInfo(device, param_name, param_value_size, param_value,
                                     param_value_size_ret);
}

ANGLE_EXPORT cl_context CL_API_ENTRY
clCreateContext(const cl_context_properties *properties,
                cl_uint num_devices,
                const cl_device_id *devices,
                void(CL_CALLBACK *pfn_notify)(const char *errinfo,
                                              const void *private_info,
                                              size_t cb,
                                              void *user_data),
                void *user_data,
                cl_int *errcode_ret) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clCreateContext(properties, num_devices, devices, pfn_notify, user_data,
                                     errcode_ret);
}

ANGLE_EXPORT cl_context CL_API_ENTRY
clCreateContextFromType(const cl_context_properties *properties,
                        cl_device_type device_type,
                        void(CL_CALLBACK *pfn_notify)(const char *errinfo,
                                                      const void *private_info,
                                                      size_t cb,
                                                      void *user_data),
                        void *user_data,
                        cl_int *errcode_ret) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clCreateContextFromType(properties, device_type, pfn_notify, user_data,
                                             errcode_ret);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clRetainContext(cl_context context) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clRetainContext(context);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseContext(cl_context context) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clReleaseContext(context);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetContextInfo(context, param_name, param_value_size, param_value,
                                      param_value_size_ret);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clRetainCommandQueue(cl_command_queue command_queue) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clRetainCommandQueue(command_queue);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseCommandQueue(cl_command_queue command_queue) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clReleaseCommandQueue(command_queue);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetCommandQueueInfo(command_queue, param_name, param_value_size, param_value,
                                           param_value_size_ret);
}

ANGLE_EXPORT cl_mem CL_API_ENTRY clCreateBuffer(cl_context context,
                                                cl_mem_flags flags,
                                                size_t size,
                                                void *host_ptr,
                                                cl_int *errcode_ret) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clCreateBuffer(context, flags, size, host_ptr, errcode_ret);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clRetainMemObject(cl_mem memobj) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clRetainMemObject(memobj);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseMemObject(cl_mem memobj) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clReleaseMemObject(memobj);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetSupportedImageFormats(context, flags, image_type, num_entries,
                                                image_formats, num_image_formats);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetMemObjectInfo(memobj, param_name, param_value_size, param_value,
                                        param_value_size_ret);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetImageInfo(image, param_name, param_value_size, param_value,
                                    param_value_size_ret);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clRetainSampler(cl_sampler sampler) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clRetainSampler(sampler);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseSampler(cl_sampler sampler) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clReleaseSampler(sampler);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetSamplerInfo(sampler, param_name, param_value_size, param_value,
                                      param_value_size_ret);
}

ANGLE_EXPORT cl_program CL_API_ENTRY clCreateProgramWithSource(cl_context context,
                                                               cl_uint count,
                                                               const char **strings,
                                                               const size_t *lengths,
                                                               cl_int *errcode_ret) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clCreateProgramWithSource(context, count, strings, lengths, errcode_ret);
}

ANGLE_EXPORT cl_program CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clCreateProgramWithBinary(context, num_devices, device_list, lengths, binaries,
                                               binary_status, errcode_ret);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clRetainProgram(cl_program program) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clRetainProgram(program);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseProgram(cl_program program) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clReleaseProgram(program);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clBuildProgram(program, num_devices, device_list, options, pfn_notify,
                                    user_data);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetProgramInfo(program, param_name, param_value_size, param_value,
                                      param_value_size_ret);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetProgramBuildInfo(program, device, param_name, param_value_size,
                                           param_value, param_value_size_ret);
}

ANGLE_EXPORT cl_kernel CL_API_ENTRY clCreateKernel(cl_program program,
                                                   const char *kernel_name,
                                                   cl_int *errcode_ret) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clCreateKernel(program, kernel_name, errcode_ret);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clCreateKernelsInProgram(cl_program program,
                                                          cl_uint num_kernels,
                                                          cl_kernel *kernels,
                                                          cl_uint *num_kernels_ret) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clCreateKernelsInProgram(program, num_kernels, kernels, num_kernels_ret);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clRetainKernel(cl_kernel kernel) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clRetainKernel(kernel);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseKernel(cl_kernel kernel) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clReleaseKernel(kernel);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clSetKernelArg(cl_kernel kernel,
                                                cl_uint arg_index,
                                                size_t arg_size,
                                                const void *arg_value) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clSetKernelArg(kernel, arg_index, arg_size, arg_value);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetKernelInfo(kernel, param_name, param_value_size, param_value,
                                     param_value_size_ret);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetKernelWorkGroupInfo(kernel, device, param_name, param_value_size,
                                              param_value, param_value_size_ret);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clWaitForEvents(cl_uint num_events,
                                                 const cl_event *event_list) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clWaitForEvents(num_events, event_list);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetEventInfo(event, param_name, param_value_size, param_value,
                                    param_value_size_ret);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clRetainEvent(cl_event event) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clRetainEvent(event);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseEvent(cl_event event) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clReleaseEvent(event);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetEventProfilingInfo(event, param_name, param_value_size, param_value,
                                             param_value_size_ret);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clFlush(cl_command_queue command_queue) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clFlush(command_queue);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clFinish(cl_command_queue command_queue) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clFinish(command_queue);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueReadBuffer(cl_command_queue command_queue,
                                                     cl_mem buffer,
                                                     cl_bool blocking_read,
                                                     size_t offset,
                                                     size_t size,
                                                     void *ptr,
                                                     cl_uint num_events_in_wait_list,
                                                     const cl_event *event_wait_list,
                                                     cl_event *event) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clEnqueueReadBuffer(command_queue, buffer, blocking_read, offset, size, ptr,
                                         num_events_in_wait_list, event_wait_list, event);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueWriteBuffer(cl_command_queue command_queue,
                                                      cl_mem buffer,
                                                      cl_bool blocking_write,
                                                      size_t offset,
                                                      size_t size,
                                                      const void *ptr,
                                                      cl_uint num_events_in_wait_list,
                                                      const cl_event *event_wait_list,
                                                      cl_event *event) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clEnqueueWriteBuffer(command_queue, buffer, blocking_write, offset, size, ptr,
                                          num_events_in_wait_list, event_wait_list, event);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueCopyBuffer(cl_command_queue command_queue,
                                                     cl_mem src_buffer,
                                                     cl_mem dst_buffer,
                                                     size_t src_offset,
                                                     size_t dst_offset,
                                                     size_t size,
                                                     cl_uint num_events_in_wait_list,
                                                     const cl_event *event_wait_list,
                                                     cl_event *event) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clEnqueueCopyBuffer(command_queue, src_buffer, dst_buffer, src_offset,
                                         dst_offset, size, num_events_in_wait_list, event_wait_list,
                                         event);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clEnqueueReadImage(command_queue, image, blocking_read, origin, region,
                                        row_pitch, slice_pitch, ptr, num_events_in_wait_list,
                                        event_wait_list, event);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clEnqueueWriteImage(command_queue, image, blocking_write, origin, region,
                                         input_row_pitch, input_slice_pitch, ptr,
                                         num_events_in_wait_list, event_wait_list, event);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clEnqueueCopyImage(command_queue, src_image, dst_image, src_origin, dst_origin,
                                        region, num_events_in_wait_list, event_wait_list, event);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clEnqueueCopyImageToBuffer(command_queue, src_image, dst_buffer, src_origin,
                                                region, dst_offset, num_events_in_wait_list,
                                                event_wait_list, event);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clEnqueueCopyBufferToImage(command_queue, src_buffer, dst_image, src_offset,
                                                dst_origin, region, num_events_in_wait_list,
                                                event_wait_list, event);
}

ANGLE_EXPORT void *CL_API_ENTRY clEnqueueMapBuffer(cl_command_queue command_queue,
                                                   cl_mem buffer,
                                                   cl_bool blocking_map,
                                                   cl_map_flags map_flags,
                                                   size_t offset,
                                                   size_t size,
                                                   cl_uint num_events_in_wait_list,
                                                   const cl_event *event_wait_list,
                                                   cl_event *event,
                                                   cl_int *errcode_ret) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clEnqueueMapBuffer(command_queue, buffer, blocking_map, map_flags, offset,
                                        size, num_events_in_wait_list, event_wait_list, event,
                                        errcode_ret);
}

ANGLE_EXPORT void *CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.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);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clEnqueueUnmapMemObject(command_queue, memobj, mapped_ptr,
                                             num_events_in_wait_list, event_wait_list, event);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clEnqueueNDRangeKernel(command_queue, kernel, work_dim, global_work_offset,
                                            global_work_size, local_work_size,
                                            num_events_in_wait_list, event_wait_list, event);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.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);
}

ANGLE_EXPORT cl_int CL_API_ENTRY
clSetCommandQueueProperty(cl_command_queue command_queue,
                          cl_command_queue_properties properties,
                          cl_bool enable,
                          cl_command_queue_properties *old_properties) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clSetCommandQueueProperty(command_queue, properties, enable, old_properties);
}

ANGLE_EXPORT cl_mem CL_API_ENTRY 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_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clCreateImage2D(context, flags, image_format, image_width, image_height,
                                     image_row_pitch, host_ptr, errcode_ret);
}

ANGLE_EXPORT cl_mem CL_API_ENTRY 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_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clCreateImage3D(context, flags, image_format, image_width, image_height,
                                     image_depth, image_row_pitch, image_slice_pitch, host_ptr,
                                     errcode_ret);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueMarker(cl_command_queue command_queue,
                                                 cl_event *event) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clEnqueueMarker(command_queue, event);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueWaitForEvents(cl_command_queue command_queue,
                                                        cl_uint num_events,
                                                        const cl_event *event_list) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clEnqueueWaitForEvents(command_queue, num_events, event_list);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueBarrier(cl_command_queue command_queue) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clEnqueueBarrier(command_queue);
}

ANGLE_EXPORT cl_int CL_API_ENTRY clUnloadCompiler() CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clUnloadCompiler();
}

ANGLE_EXPORT void *CL_API_ENTRY clGetExtensionFunctionAddress(const char *func_name) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clGetExtensionFunctionAddress(func_name);
}

ANGLE_EXPORT cl_command_queue CL_API_ENTRY
clCreateCommandQueue(cl_context context,
                     cl_device_id device,
                     cl_command_queue_properties properties,
                     cl_int *errcode_ret) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clCreateCommandQueue(context, device, properties, errcode_ret);
}

ANGLE_EXPORT cl_sampler CL_API_ENTRY clCreateSampler(cl_context context,
                                                     cl_bool normalized_coords,
                                                     cl_addressing_mode addressing_mode,
                                                     cl_filter_mode filter_mode,
                                                     cl_int *errcode_ret) CL_API_CALL
{
    EnsureCLLoaded();
    return cl_loader.clCreateSampler(context, normalized_coords, addressing_mode, filter_mode,
                                     errcode_ret);
}

ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
    EnsureCLLoaded();
    return cl_loader.clEnqueueTask(command_queue, kernel, num_events_in_wait_list, event_wait_list,
                                   event);
}

}  // extern "C"
