Edit

kc3-lang/angle/src/libOpenCL/libOpenCL_autogen.cpp

Branch :

  • Show log

    Commit

  • Author : John Plate
    Date : 2021-03-10 19:02:12
    Hash : 65586746
    Message : add cl entry points loader Bug: angleproject:5743 Change-Id: I61791f412e8dbc54878cd3791519ad1c4ee33399 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2749595 Reviewed-by: Cody Northrop <cnorthrop@google.com> Reviewed-by: Jamie Madill <jmadill@chromium.org> Commit-Queue: John Plate <jplate@google.com>

  • src/libOpenCL/libOpenCL_autogen.cpp
  • // 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"