Add warning messages for not (yet) supported CL commands

src/libGLESv2/cl_stubs.cpp

@@ -22,6 +22,17 @@
 
 #include <cstring>
 
+#define WARN_NOT_SUPPORTED(command)                                         \
+    do                                                                      \
+    {                                                                       \
+        static bool sWarned = false;                                        \
+        if (!sWarned)                                                       \
+        {                                                                   \
+            sWarned = true;                                                 \
+            WARN() << "OpenCL command " #command " is not (yet) supported"; \
+        }                                                                   \
+    } while (0)
+
 namespace cl
 {
 
@@ -168,6 +179,7 @@ cl_int GetDeviceIDs(Platform *platform,
                     Device **devices,
                     cl_uint *num_devices)
 {
+    WARN_NOT_SUPPORTED(GetDeviceIDs);
     return 0;
 }
 
@@ -177,6 +189,7 @@ cl_int GetDeviceInfo(Device *device,
                      void *param_value,
                      size_t *param_value_size_ret)
 {
+    WARN_NOT_SUPPORTED(GetDeviceInfo);
     return 0;
 }
 
@@ -186,31 +199,37 @@ cl_int CreateSubDevices(Device *in_device,
                         Device **out_devices,
                         cl_uint *num_devices_ret)
 {
+    WARN_NOT_SUPPORTED(CreateSubDevices);
     return 0;
 }
 
 cl_int RetainDevice(Device *device)
 {
+    WARN_NOT_SUPPORTED(RetainDevice);
     return 0;
 }
 
 cl_int ReleaseDevice(Device *device)
 {
+    WARN_NOT_SUPPORTED(ReleaseDevice);
     return 0;
 }
 
 cl_int SetDefaultDeviceCommandQueue(Context *context, Device *device, CommandQueue *command_queue)
 {
+    WARN_NOT_SUPPORTED(SetDefaultDeviceCommandQueue);
     return 0;
 }
 
 cl_int GetDeviceAndHostTimer(Device *device, cl_ulong *device_timestamp, cl_ulong *host_timestamp)
 {
+    WARN_NOT_SUPPORTED(GetDeviceAndHostTimer);
     return 0;
 }
 
 cl_int GetHostTimer(Device *device, cl_ulong *host_timestamp)
 {
+    WARN_NOT_SUPPORTED(GetHostTimer);
     return 0;
 }
 
@@ -224,6 +243,7 @@ Context *CreateContext(const cl_context_properties *properties,
                        void *user_data,
                        cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateContext);
     return 0;
 }
 
@@ -236,16 +256,19 @@ Context *CreateContextFromType(const cl_context_properties *properties,
                                void *user_data,
                                cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateContextFromType);
     return 0;
 }
 
 cl_int RetainContext(Context *context)
 {
+    WARN_NOT_SUPPORTED(RetainContext);
     return 0;
 }
 
 cl_int ReleaseContext(Context *context)
 {
+    WARN_NOT_SUPPORTED(ReleaseContext);
     return 0;
 }
 
@@ -255,6 +278,7 @@ cl_int GetContextInfo(Context *context,
                       void *param_value,
                       size_t *param_value_size_ret)
 {
+    WARN_NOT_SUPPORTED(GetContextInfo);
     return 0;
 }
 
@@ -263,6 +287,7 @@ cl_int SetContextDestructorCallback(Context *context,
                                                                   void *user_data),
                                     void *user_data)
 {
+    WARN_NOT_SUPPORTED(SetContextDestructorCallback);
     return 0;
 }
 
@@ -271,16 +296,19 @@ CommandQueue *CreateCommandQueueWithProperties(Context *context,
                                                const cl_queue_properties *properties,
                                                cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateCommandQueueWithProperties);
     return 0;
 }
 
 cl_int RetainCommandQueue(CommandQueue *command_queue)
 {
+    WARN_NOT_SUPPORTED(RetainCommandQueue);
     return 0;
 }
 
 cl_int ReleaseCommandQueue(CommandQueue *command_queue)
 {
+    WARN_NOT_SUPPORTED(ReleaseCommandQueue);
     return 0;
 }
 
@@ -290,6 +318,7 @@ cl_int GetCommandQueueInfo(CommandQueue *command_queue,
                            void *param_value,
                            size_t *param_value_size_ret)
 {
+    WARN_NOT_SUPPORTED(GetCommandQueueInfo);
     return 0;
 }
 
@@ -299,6 +328,7 @@ Memory *CreateBuffer(Context *context,
                      void *host_ptr,
                      cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateBuffer);
     return 0;
 }
 
@@ -309,6 +339,7 @@ Memory *CreateBufferWithProperties(Context *context,
                                    void *host_ptr,
                                    cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateBufferWithProperties);
     return 0;
 }
 
@@ -318,6 +349,7 @@ Memory *CreateSubBuffer(Memory *buffer,
                         const void *buffer_create_info,
                         cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateSubBuffer);
     return 0;
 }
 
@@ -328,6 +360,7 @@ Memory *CreateImage(Context *context,
                     void *host_ptr,
                     cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateImage);
     return 0;
 }
 
@@ -339,6 +372,7 @@ Memory *CreateImageWithProperties(Context *context,
                                   void *host_ptr,
                                   cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateImageWithProperties);
     return 0;
 }
 
@@ -349,16 +383,19 @@ Memory *CreatePipe(Context *context,
                    const cl_pipe_properties *properties,
                    cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreatePipe);
     return 0;
 }
 
 cl_int RetainMemObject(Memory *memobj)
 {
+    WARN_NOT_SUPPORTED(RetainMemObject);
     return 0;
 }
 
 cl_int ReleaseMemObject(Memory *memobj)
 {
+    WARN_NOT_SUPPORTED(ReleaseMemObject);
     return 0;
 }
 
@@ -369,6 +406,7 @@ cl_int GetSupportedImageFormats(Context *context,
                                 cl_image_format *image_formats,
                                 cl_uint *num_image_formats)
 {
+    WARN_NOT_SUPPORTED(GetSupportedImageFormats);
     return 0;
 }
 
@@ -378,6 +416,7 @@ cl_int GetMemObjectInfo(Memory *memobj,
                         void *param_value,
                         size_t *param_value_size_ret)
 {
+    WARN_NOT_SUPPORTED(GetMemObjectInfo);
     return 0;
 }
 
@@ -387,6 +426,7 @@ cl_int GetImageInfo(Memory *image,
                     void *param_value,
                     size_t *param_value_size_ret)
 {
+    WARN_NOT_SUPPORTED(GetImageInfo);
     return 0;
 }
 
@@ -396,6 +436,7 @@ cl_int GetPipeInfo(Memory *pipe,
                    void *param_value,
                    size_t *param_value_size_ret)
 {
+    WARN_NOT_SUPPORTED(GetPipeInfo);
     return 0;
 }
 
@@ -403,30 +444,38 @@ cl_int SetMemObjectDestructorCallback(Memory *memobj,
                                       void(CL_CALLBACK *pfn_notify)(cl_mem memobj, void *user_data),
                                       void *user_data)
 {
+    WARN_NOT_SUPPORTED(SetMemObjectDestructorCallback);
     return 0;
 }
 
 void *SVMAlloc(Context *context, cl_svm_mem_flags flags, size_t size, cl_uint alignment)
 {
+    WARN_NOT_SUPPORTED(SVMAlloc);
     return 0;
 }
 
-void SVMFree(Context *context, void *svm_pointer) {}
+void SVMFree(Context *context, void *svm_pointer)
+{
+    WARN_NOT_SUPPORTED(SVMFree);
+}
 
 Sampler *CreateSamplerWithProperties(Context *context,
                                      const cl_sampler_properties *sampler_properties,
                                      cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateSamplerWithProperties);
     return 0;
 }
 
 cl_int RetainSampler(Sampler *sampler)
 {
+    WARN_NOT_SUPPORTED(RetainSampler);
     return 0;
 }
 
 cl_int ReleaseSampler(Sampler *sampler)
 {
+    WARN_NOT_SUPPORTED(ReleaseSampler);
     return 0;
 }
 
@@ -436,6 +485,7 @@ cl_int GetSamplerInfo(Sampler *sampler,
                       void *param_value,
                       size_t *param_value_size_ret)
 {
+    WARN_NOT_SUPPORTED(GetSamplerInfo);
     return 0;
 }
 
@@ -445,6 +495,7 @@ Program *CreateProgramWithSource(Context *context,
                                  const size_t *lengths,
                                  cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateProgramWithSource);
     return 0;
 }
 
@@ -456,6 +507,7 @@ Program *CreateProgramWithBinary(Context *context,
                                  cl_int *binary_status,
                                  cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateProgramWithBinary);
     return 0;
 }
 
@@ -465,21 +517,25 @@ Program *CreateProgramWithBuiltInKernels(Context *context,
                                          const char *kernel_names,
                                          cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateProgramWithBuiltInKernels);
     return 0;
 }
 
 Program *CreateProgramWithIL(Context *context, const void *il, size_t length, cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateProgramWithIL);
     return 0;
 }
 
 cl_int RetainProgram(Program *program)
 {
+    WARN_NOT_SUPPORTED(RetainProgram);
     return 0;
 }
 
 cl_int ReleaseProgram(Program *program)
 {
+    WARN_NOT_SUPPORTED(ReleaseProgram);
     return 0;
 }
 
@@ -490,6 +546,7 @@ cl_int BuildProgram(Program *program,
                     void(CL_CALLBACK *pfn_notify)(cl_program program, void *user_data),
                     void *user_data)
 {
+    WARN_NOT_SUPPORTED(BuildProgram);
     return 0;
 }
 
@@ -503,6 +560,7 @@ cl_int CompileProgram(Program *program,
                       void(CL_CALLBACK *pfn_notify)(cl_program program, void *user_data),
                       void *user_data)
 {
+    WARN_NOT_SUPPORTED(CompileProgram);
     return 0;
 }
 
@@ -516,6 +574,7 @@ Program *LinkProgram(Context *context,
                      void *user_data,
                      cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(LinkProgram);
     return 0;
 }
 
@@ -523,6 +582,7 @@ cl_int SetProgramReleaseCallback(Program *program,
                                  void(CL_CALLBACK *pfn_notify)(cl_program program, void *user_data),
                                  void *user_data)
 {
+    WARN_NOT_SUPPORTED(SetProgramReleaseCallback);
     return 0;
 }
 
@@ -531,11 +591,13 @@ cl_int SetProgramSpecializationConstant(Program *program,
                                         size_t spec_size,
                                         const void *spec_value)
 {
+    WARN_NOT_SUPPORTED(SetProgramSpecializationConstant);
     return 0;
 }
 
 cl_int UnloadPlatformCompiler(Platform *platform)
 {
+    WARN_NOT_SUPPORTED(UnloadPlatformCompiler);
     return 0;
 }
 
@@ -545,6 +607,7 @@ cl_int GetProgramInfo(Program *program,
                       void *param_value,
                       size_t *param_value_size_ret)
 {
+    WARN_NOT_SUPPORTED(GetProgramInfo);
     return 0;
 }
 
@@ -555,11 +618,13 @@ cl_int GetProgramBuildInfo(Program *program,
                            void *param_value,
                            size_t *param_value_size_ret)
 {
+    WARN_NOT_SUPPORTED(GetProgramBuildInfo);
     return 0;
 }
 
 Kernel *CreateKernel(Program *program, const char *kernel_name, cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateKernel);
     return 0;
 }
 
@@ -568,31 +633,37 @@ cl_int CreateKernelsInProgram(Program *program,
                               Kernel **kernels,
                               cl_uint *num_kernels_ret)
 {
+    WARN_NOT_SUPPORTED(CreateKernelsInProgram);
     return 0;
 }
 
 Kernel *CloneKernel(Kernel *source_kernel, cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CloneKernel);
     return 0;
 }
 
 cl_int RetainKernel(Kernel *kernel)
 {
+    WARN_NOT_SUPPORTED(RetainKernel);
     return 0;
 }
 
 cl_int ReleaseKernel(Kernel *kernel)
 {
+    WARN_NOT_SUPPORTED(ReleaseKernel);
     return 0;
 }
 
 cl_int SetKernelArg(Kernel *kernel, cl_uint arg_index, size_t arg_size, const void *arg_value)
 {
+    WARN_NOT_SUPPORTED(SetKernelArg);
     return 0;
 }
 
 cl_int SetKernelArgSVMPointer(Kernel *kernel, cl_uint arg_index, const void *arg_value)
 {
+    WARN_NOT_SUPPORTED(SetKernelArgSVMPointer);
     return 0;
 }
 
@@ -601,6 +672,7 @@ cl_int SetKernelExecInfo(Kernel *kernel,
                          size_t param_value_size,
                          const void *param_value)
 {
+    WARN_NOT_SUPPORTED(SetKernelExecInfo);
     return 0;
 }
 
@@ -610,6 +682,7 @@ cl_int GetKernelInfo(Kernel *kernel,
                      void *param_value,
                      size_t *param_value_size_ret)
 {
+    WARN_NOT_SUPPORTED(GetKernelInfo);
     return 0;
 }
 
@@ -620,6 +693,7 @@ cl_int GetKernelArgInfo(Kernel *kernel,
                         void *param_value,
                         size_t *param_value_size_ret)
 {
+    WARN_NOT_SUPPORTED(GetKernelArgInfo);
     return 0;
 }
 
@@ -630,6 +704,7 @@ cl_int GetKernelWorkGroupInfo(Kernel *kernel,
                               void *param_value,
                               size_t *param_value_size_ret)
 {
+    WARN_NOT_SUPPORTED(GetKernelWorkGroupInfo);
     return 0;
 }
 
@@ -642,11 +717,13 @@ cl_int GetKernelSubGroupInfo(Kernel *kernel,
                              void *param_value,
                              size_t *param_value_size_ret)
 {
+    WARN_NOT_SUPPORTED(GetKernelSubGroupInfo);
     return 0;
 }
 
 cl_int WaitForEvents(cl_uint num_events, Event *const *event_list)
 {
+    WARN_NOT_SUPPORTED(WaitForEvents);
     return 0;
 }
 
@@ -656,26 +733,31 @@ cl_int GetEventInfo(Event *event,
                     void *param_value,
                     size_t *param_value_size_ret)
 {
+    WARN_NOT_SUPPORTED(GetEventInfo);
     return 0;
 }
 
 Event *CreateUserEvent(Context *context, cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateUserEvent);
     return 0;
 }
 
 cl_int RetainEvent(Event *event)
 {
+    WARN_NOT_SUPPORTED(RetainEvent);
     return 0;
 }
 
 cl_int ReleaseEvent(Event *event)
 {
+    WARN_NOT_SUPPORTED(ReleaseEvent);
     return 0;
 }
 
 cl_int SetUserEventStatus(Event *event, cl_int execution_status)
 {
+    WARN_NOT_SUPPORTED(SetUserEventStatus);
     return 0;
 }
 
@@ -686,6 +768,7 @@ cl_int SetEventCallback(Event *event,
                                                       void *user_data),
                         void *user_data)
 {
+    WARN_NOT_SUPPORTED(SetEventCallback);
     return 0;
 }
 
@@ -695,16 +778,19 @@ cl_int GetEventProfilingInfo(Event *event,
                              void *param_value,
                              size_t *param_value_size_ret)
 {
+    WARN_NOT_SUPPORTED(GetEventProfilingInfo);
     return 0;
 }
 
 cl_int Flush(CommandQueue *command_queue)
 {
+    WARN_NOT_SUPPORTED(Flush);
     return 0;
 }
 
 cl_int Finish(CommandQueue *command_queue)
 {
+    WARN_NOT_SUPPORTED(Finish);
     return 0;
 }
 
@@ -718,6 +804,7 @@ cl_int EnqueueReadBuffer(CommandQueue *command_queue,
                          Event *const *event_wait_list,
                          Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueReadBuffer);
     return 0;
 }
 
@@ -736,6 +823,7 @@ cl_int EnqueueReadBufferRect(CommandQueue *command_queue,
                              Event *const *event_wait_list,
                              Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueReadBufferRect);
     return 0;
 }
 
@@ -749,6 +837,7 @@ cl_int EnqueueWriteBuffer(CommandQueue *command_queue,
                           Event *const *event_wait_list,
                           Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueWriteBuffer);
     return 0;
 }
 
@@ -767,6 +856,7 @@ cl_int EnqueueWriteBufferRect(CommandQueue *command_queue,
                               Event *const *event_wait_list,
                               Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueWriteBufferRect);
     return 0;
 }
 
@@ -780,6 +870,7 @@ cl_int EnqueueFillBuffer(CommandQueue *command_queue,
                          Event *const *event_wait_list,
                          Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueFillBuffer);
     return 0;
 }
 
@@ -793,6 +884,7 @@ cl_int EnqueueCopyBuffer(CommandQueue *command_queue,
                          Event *const *event_wait_list,
                          Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueCopyBuffer);
     return 0;
 }
 
@@ -810,6 +902,7 @@ cl_int EnqueueCopyBufferRect(CommandQueue *command_queue,
                              Event *const *event_wait_list,
                              Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueCopyBufferRect);
     return 0;
 }
 
@@ -825,6 +918,7 @@ cl_int EnqueueReadImage(CommandQueue *command_queue,
                         Event *const *event_wait_list,
                         Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueReadImage);
     return 0;
 }
 
@@ -840,6 +934,7 @@ cl_int EnqueueWriteImage(CommandQueue *command_queue,
                          Event *const *event_wait_list,
                          Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueWriteImage);
     return 0;
 }
 
@@ -852,6 +947,7 @@ cl_int EnqueueFillImage(CommandQueue *command_queue,
                         Event *const *event_wait_list,
                         Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueFillImage);
     return 0;
 }
 
@@ -865,6 +961,7 @@ cl_int EnqueueCopyImage(CommandQueue *command_queue,
                         Event *const *event_wait_list,
                         Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueCopyImage);
     return 0;
 }
 
@@ -878,6 +975,7 @@ cl_int EnqueueCopyImageToBuffer(CommandQueue *command_queue,
                                 Event *const *event_wait_list,
                                 Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueCopyImageToBuffer);
     return 0;
 }
 
@@ -891,6 +989,7 @@ cl_int EnqueueCopyBufferToImage(CommandQueue *command_queue,
                                 Event *const *event_wait_list,
                                 Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueCopyBufferToImage);
     return 0;
 }
 
@@ -905,6 +1004,7 @@ void *EnqueueMapBuffer(CommandQueue *command_queue,
                        Event **event,
                        cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(EnqueueMapBuffer);
     return 0;
 }
 
@@ -921,6 +1021,7 @@ void *EnqueueMapImage(CommandQueue *command_queue,
                       Event **event,
                       cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(EnqueueMapImage);
     return 0;
 }
 
@@ -931,6 +1032,7 @@ cl_int EnqueueUnmapMemObject(CommandQueue *command_queue,
                              Event *const *event_wait_list,
                              Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueUnmapMemObject);
     return 0;
 }
 
@@ -942,6 +1044,7 @@ cl_int EnqueueMigrateMemObjects(CommandQueue *command_queue,
                                 Event *const *event_wait_list,
                                 Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueMigrateMemObjects);
     return 0;
 }
 
@@ -955,6 +1058,7 @@ cl_int EnqueueNDRangeKernel(CommandQueue *command_queue,
                             Event *const *event_wait_list,
                             Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueNDRangeKernel);
     return 0;
 }
 
@@ -969,6 +1073,7 @@ cl_int EnqueueNativeKernel(CommandQueue *command_queue,
                            Event *const *event_wait_list,
                            Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueNativeKernel);
     return 0;
 }
 
@@ -977,6 +1082,7 @@ cl_int EnqueueMarkerWithWaitList(CommandQueue *command_queue,
                                  Event *const *event_wait_list,
                                  Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueMarkerWithWaitList);
     return 0;
 }
 
@@ -985,6 +1091,7 @@ cl_int EnqueueBarrierWithWaitList(CommandQueue *command_queue,
                                   Event *const *event_wait_list,
                                   Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueBarrierWithWaitList);
     return 0;
 }
 
@@ -1000,6 +1107,7 @@ cl_int EnqueueSVMFree(CommandQueue *command_queue,
                       Event *const *event_wait_list,
                       Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueSVMFree);
     return 0;
 }
 
@@ -1012,6 +1120,7 @@ cl_int EnqueueSVMMemcpy(CommandQueue *command_queue,
                         Event *const *event_wait_list,
                         Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueSVMMemcpy);
     return 0;
 }
 
@@ -1024,6 +1133,7 @@ cl_int EnqueueSVMMemFill(CommandQueue *command_queue,
                          Event *const *event_wait_list,
                          Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueSVMMemFill);
     return 0;
 }
 
@@ -1036,6 +1146,7 @@ cl_int EnqueueSVMMap(CommandQueue *command_queue,
                      Event *const *event_wait_list,
                      Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueSVMMap);
     return 0;
 }
 
@@ -1045,6 +1156,7 @@ cl_int EnqueueSVMUnmap(CommandQueue *command_queue,
                        Event *const *event_wait_list,
                        Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueSVMUnmap);
     return 0;
 }
 
@@ -1057,6 +1169,7 @@ cl_int EnqueueSVMMigrateMem(CommandQueue *command_queue,
                             Event *const *event_wait_list,
                             Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueSVMMigrateMem);
     return 0;
 }
 
@@ -1070,6 +1183,7 @@ cl_int SetCommandQueueProperty(CommandQueue *command_queue,
                                cl_bool enable,
                                cl_command_queue_properties *old_properties)
 {
+    WARN_NOT_SUPPORTED(SetCommandQueueProperty);
     return 0;
 }
 
@@ -1082,6 +1196,7 @@ Memory *CreateImage2D(Context *context,
                       void *host_ptr,
                       cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateImage2D);
     return 0;
 }
 
@@ -1096,11 +1211,13 @@ Memory *CreateImage3D(Context *context,
                       void *host_ptr,
                       cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateImage3D);
     return 0;
 }
 
 cl_int EnqueueMarker(CommandQueue *command_queue, Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueMarker);
     return 0;
 }
 
@@ -1108,16 +1225,19 @@ cl_int EnqueueWaitForEvents(CommandQueue *command_queue,
                             cl_uint num_events,
                             Event *const *event_list)
 {
+    WARN_NOT_SUPPORTED(EnqueueWaitForEvents);
     return 0;
 }
 
 cl_int EnqueueBarrier(CommandQueue *command_queue)
 {
+    WARN_NOT_SUPPORTED(EnqueueBarrier);
     return 0;
 }
 
 cl_int UnloadCompiler()
 {
+    WARN_NOT_SUPPORTED(UnloadCompiler);
     return 0;
 }
 
@@ -1137,6 +1257,7 @@ CommandQueue *CreateCommandQueue(Context *context,
                                  cl_command_queue_properties properties,
                                  cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateCommandQueue);
     return 0;
 }
 
@@ -1146,6 +1267,7 @@ Sampler *CreateSampler(Context *context,
                        FilterMode filter_mode,
                        cl_int *errcode_ret)
 {
+    WARN_NOT_SUPPORTED(CreateSampler);
     return 0;
 }
 
@@ -1155,6 +1277,7 @@ cl_int EnqueueTask(CommandQueue *command_queue,
                    Event *const *event_wait_list,
                    Event **event)
 {
+    WARN_NOT_SUPPORTED(EnqueueTask);
     return 0;
 }