opencl-1.2-stubs/opencl_stubs.c

   1 #include <CL/cl.h>
   2 #include <stdio.h>
   3
   4 #define PRINT_STUB_ERROR printf("\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\nERROR: %s from stub libOpenCL.so library called! This library can be used to resolve OpenCL symbols at compile time but must *not* be in your runtime path (You need to use a real OpenCL implementation, this one is empty)\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n", __func__)
   5
   6 cl_int
   7 clGetPlatformIDs(cl_uint          num_entries,
   8                  cl_platform_id * platforms,
   9                  cl_uint *        num_platforms)
  10 {
  11         PRINT_STUB_ERROR;
  12         return CL_OUT_OF_RESOURCES;
  13 }
  14
  15 cl_int
  16 clGetPlatformInfo(cl_platform_id   platform,
  17                   cl_platform_info param_name,
  18                   size_t           param_value_size,
  19                   void *           param_value,
  20                   size_t *         param_value_size_ret)
  21 {
  22         PRINT_STUB_ERROR;
  23         return CL_OUT_OF_RESOURCES;
  24 }
  25
  26 cl_int
  27 clGetDeviceIDs(cl_platform_id   platform,
  28                cl_device_type   device_type,
  29                cl_uint          num_entries,
  30                cl_device_id *   devices,
  31                cl_uint *        num_devices)
  32 {
  33         PRINT_STUB_ERROR;
  34         return CL_OUT_OF_RESOURCES;
  35 }
  36
  37 cl_int
  38 clGetDeviceInfo(cl_device_id    device,
  39                 cl_device_info  param_name,
  40                 size_t          param_value_size,
  41                 void *          param_value,
  42                 size_t *        param_value_size_ret)
  43 {
  44         PRINT_STUB_ERROR;
  45         return CL_OUT_OF_RESOURCES;
  46 }
  47
  48 cl_int
  49 clCreateSubDevices(cl_device_id                         in_device,
  50                    const cl_device_partition_property * properties,
  51                    cl_uint                              num_devices,
  52                    cl_device_id *                       out_devices,
  53                    cl_uint *                            num_devices_ret)
  54 {
  55         PRINT_STUB_ERROR;
  56         return CL_OUT_OF_RESOURCES;
  57 }
  58
  59 cl_int
  60 clRetainDevice(cl_device_id device)
  61 {
  62         PRINT_STUB_ERROR;
  63         return CL_OUT_OF_RESOURCES;
  64 }
  65
  66 cl_int
  67 clReleaseDevice(cl_device_id device)
  68 {
  69         PRINT_STUB_ERROR;
  70         return CL_OUT_OF_RESOURCES;
  71 }
  72
  73 cl_context
  74 clCreateContext(const cl_context_properties * properties,
  75                 cl_uint                 num_devices,
  76                 const cl_device_id *    devices,
  77                 void (CL_CALLBACK *     pfn_notify)(const char *, const void *, size_t, void *),
  78                 void *                  user_data,
  79                 cl_int *                errcode_ret)
  80 {
  81         PRINT_STUB_ERROR;
  82         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
  83         return NULL;
  84 }
  85
  86 cl_context
  87 clCreateContextFromType(const cl_context_properties * properties,
  88                         cl_device_type                device_type,
  89                         void (CL_CALLBACK *           pfn_notify )(const char *, const void *, size_t, void *),
  90                         void *                        user_data,
  91                         cl_int *                      errcode_ret)
  92 {
  93         PRINT_STUB_ERROR;
  94         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
  95         return NULL;
  96 }
  97
  98 cl_int
  99 clRetainContext(cl_context context)
 100 {
 101         PRINT_STUB_ERROR;
 102         return CL_OUT_OF_RESOURCES;
 103 }
 104
 105 cl_int
 106 clReleaseContext(cl_context context)
 107 {
 108         PRINT_STUB_ERROR;
 109         return CL_OUT_OF_RESOURCES;
 110 }
 111
 112 cl_int
 113 clGetContextInfo(cl_context         context,
 114                  cl_context_info    param_name,
 115                  size_t             param_value_size,
 116                  void *             param_value,
 117                  size_t *           param_value_size_ret)
 118 {
 119         PRINT_STUB_ERROR;
 120         return CL_OUT_OF_RESOURCES;
 121 }
 122
 123 cl_command_queue
 124 clCreateCommandQueue(cl_context                     context,
 125                      cl_device_id                   device,
 126                      cl_command_queue_properties    properties,
 127                      cl_int *                       errcode_ret)
 128 {
 129         PRINT_STUB_ERROR;
 130         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
 131         return NULL;
 132 }
 133
 134 cl_int
 135 clRetainCommandQueue(cl_command_queue command_queue)
 136 {
 137         PRINT_STUB_ERROR;
 138         return CL_OUT_OF_RESOURCES;
 139 }
 140
 141 cl_int
 142 clReleaseCommandQueue(cl_command_queue command_queue)
 143 {
 144         PRINT_STUB_ERROR;
 145         return CL_OUT_OF_RESOURCES;
 146 }
 147
 148 cl_int
 149 clGetCommandQueueInfo(cl_command_queue      command_queue,
 150                       cl_command_queue_info param_name,
 151                       size_t                param_value_size,
 152                       void *                param_value,
 153                       size_t *              param_value_size_ret)
 154 {
 155         PRINT_STUB_ERROR;
 156         return CL_OUT_OF_RESOURCES;
 157 }
 158
 159 cl_mem
 160 clCreateBuffer(cl_context   context,
 161                cl_mem_flags flags,
 162                size_t       size,
 163                void *       host_ptr,
 164                cl_int *     errcode_ret)
 165 {
 166         PRINT_STUB_ERROR;
 167         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
 168         return NULL;
 169 }
 170
 171 cl_mem
 172 clCreateSubBuffer(cl_mem                   buffer,
 173                   cl_mem_flags             flags,
 174                   cl_buffer_create_type    buffer_create_type,
 175                   const void *             buffer_create_info,
 176                   cl_int *                 errcode_ret)
 177 {
 178         PRINT_STUB_ERROR;
 179         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
 180         return NULL;
 181 }
 182
 183 cl_mem
 184 clCreateImage(cl_context              context,
 185               cl_mem_flags            flags,
 186               const cl_image_format * image_format,
 187               const cl_image_desc *   image_desc,
 188               void *                  host_ptr,
 189               cl_int *                errcode_ret)
 190 {
 191         PRINT_STUB_ERROR;
 192         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
 193         return NULL;
 194 }
 195
 196 cl_int
 197 clRetainMemObject(cl_mem memobj)
 198 {
 199         PRINT_STUB_ERROR;
 200         return CL_OUT_OF_RESOURCES;
 201 }
 202
 203 cl_int
 204 clReleaseMemObject(cl_mem memobj)
 205 {
 206         PRINT_STUB_ERROR;
 207         return CL_OUT_OF_RESOURCES;
 208 }
 209
 210 cl_int
 211 clGetSupportedImageFormats(cl_context           context,
 212                            cl_mem_flags         flags,
 213                            cl_mem_object_type   image_type,
 214                            cl_uint              num_entries,
 215                            cl_image_format *    image_formats,
 216                            cl_uint *            num_image_formats)
 217 {
 218         PRINT_STUB_ERROR;
 219         return CL_OUT_OF_RESOURCES;
 220 }
 221
 222 cl_int
 223 clGetMemObjectInfo(cl_mem           memobj,
 224                    cl_mem_info      param_name,
 225                    size_t           param_value_size,
 226                    void *           param_value,
 227                    size_t *         param_value_size_ret)
 228 {
 229         PRINT_STUB_ERROR;
 230         return CL_OUT_OF_RESOURCES;
 231 }
 232
 233 cl_int
 234 clGetImageInfo(cl_mem           image,
 235                cl_image_info    param_name,
 236                size_t           param_value_size,
 237                void *           param_value,
 238                size_t *         param_value_size_ret)
 239 {
 240         PRINT_STUB_ERROR;
 241         return CL_OUT_OF_RESOURCES;
 242 }
 243
 244 cl_int
 245 clSetMemObjectDestructorCallback(  cl_mem memobj,
 246                                    void (CL_CALLBACK * pfn_notify)( cl_mem memobj, void* user_data),
 247                                    void * user_data )
 248 {
 249         PRINT_STUB_ERROR;
 250         return CL_OUT_OF_RESOURCES;
 251 }
 252
 253 cl_sampler
 254 clCreateSampler(cl_context          context,
 255                 cl_bool             normalized_coords,
 256                 cl_addressing_mode  addressing_mode,
 257                 cl_filter_mode      filter_mode,
 258                 cl_int *            errcode_ret)
 259 {
 260         PRINT_STUB_ERROR;
 261         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
 262         return NULL;
 263 }
 264
 265 cl_int
 266 clRetainSampler(cl_sampler sampler)
 267 {
 268         PRINT_STUB_ERROR;
 269         return CL_OUT_OF_RESOURCES;
 270 }
 271
 272 cl_int
 273 clReleaseSampler(cl_sampler sampler)
 274 {
 275         PRINT_STUB_ERROR;
 276         return CL_OUT_OF_RESOURCES;
 277 }
 278
 279 cl_int
 280 clGetSamplerInfo(cl_sampler         sampler,
 281                  cl_sampler_info    param_name,
 282                  size_t             param_value_size,
 283                  void *             param_value,
 284                  size_t *           param_value_size_ret)
 285 {
 286         PRINT_STUB_ERROR;
 287         return CL_OUT_OF_RESOURCES;
 288 }
 289
 290 cl_program
 291 clCreateProgramWithSource(cl_context        context,
 292                           cl_uint           count,
 293                           const char **     strings,
 294                           const size_t *    lengths,
 295                           cl_int *          errcode_ret)
 296 {
 297         PRINT_STUB_ERROR;
 298         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
 299         return NULL;
 300 }
 301
 302 cl_program
 303 clCreateProgramWithBinary(cl_context                     context,
 304                           cl_uint                        num_devices,
 305                           const cl_device_id *           device_list,
 306                           const size_t *                 lengths,
 307                           const unsigned char **         binaries,
 308                           cl_int *                       binary_status,
 309                           cl_int *                       errcode_ret)
 310 {
 311         PRINT_STUB_ERROR;
 312         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
 313         return NULL;
 314 }
 315
 316 cl_program
 317 clCreateProgramWithBuiltInKernels(cl_context            context,
 318                                   cl_uint               num_devices,
 319                                   const cl_device_id *  device_list,
 320                                   const char *          kernel_names,
 321                                   cl_int *              errcode_ret)
 322 {
 323         PRINT_STUB_ERROR;
 324         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
 325         return NULL;
 326 }
 327
 328 cl_int
 329 clRetainProgram(cl_program program)
 330 {
 331         PRINT_STUB_ERROR;
 332         return CL_OUT_OF_RESOURCES;
 333 }
 334
 335 cl_int
 336 clReleaseProgram(cl_program program)
 337 {
 338         PRINT_STUB_ERROR;
 339         return CL_OUT_OF_RESOURCES;
 340 }
 341
 342 cl_int
 343 clBuildProgram(cl_program           program,
 344                cl_uint              num_devices,
 345                const cl_device_id * device_list,
 346                const char *         options,
 347                void (CL_CALLBACK *  pfn_notify)(cl_program program, void * user_data),
 348                void *               user_data)
 349 {
 350         PRINT_STUB_ERROR;
 351         return CL_OUT_OF_RESOURCES;
 352 }
 353
 354 cl_int
 355 clCompileProgram(cl_program           program,
 356                  cl_uint              num_devices,
 357                  const cl_device_id * device_list,
 358                  const char *         options,
 359                  cl_uint              num_input_headers,
 360                  const cl_program *   input_headers,
 361                  const char **        header_include_names,
 362                  void (CL_CALLBACK *  pfn_notify)(cl_program program, void * user_data),
 363                  void *               user_data)
 364 {
 365         PRINT_STUB_ERROR;
 366         return CL_OUT_OF_RESOURCES;
 367 }
 368
 369 cl_program
 370 clLinkProgram(cl_context           context,
 371               cl_uint              num_devices,
 372               const cl_device_id * device_list,
 373               const char *         options,
 374               cl_uint              num_input_programs,
 375               const cl_program *   input_programs,
 376               void (CL_CALLBACK *  pfn_notify)(cl_program program, void * user_data),
 377               void *               user_data,
 378               cl_int *             errcode_ret )
 379 {
 380         PRINT_STUB_ERROR;
 381         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
 382         return NULL;
 383 }
 384
 385
 386 cl_int
 387 clUnloadPlatformCompiler(cl_platform_id platform)
 388 {
 389         PRINT_STUB_ERROR;
 390         return CL_OUT_OF_RESOURCES;
 391 }
 392
 393 cl_int
 394 clGetProgramInfo(cl_program         program,
 395                  cl_program_info    param_name,
 396                  size_t             param_value_size,
 397                  void *             param_value,
 398                  size_t *           param_value_size_ret)
 399 {
 400         PRINT_STUB_ERROR;
 401         return CL_OUT_OF_RESOURCES;
 402 }
 403
 404 cl_int
 405 clGetProgramBuildInfo(cl_program            program,
 406                       cl_device_id          device,
 407                       cl_program_build_info param_name,
 408                       size_t                param_value_size,
 409                       void *                param_value,
 410                       size_t *              param_value_size_ret)
 411 {
 412         PRINT_STUB_ERROR;
 413         return CL_OUT_OF_RESOURCES;
 414 }
 415
 416 cl_kernel
 417 clCreateKernel(cl_program      program,
 418                const char *    kernel_name,
 419                cl_int *        errcode_ret)
 420 {
 421         PRINT_STUB_ERROR;
 422         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
 423         return NULL;
 424 }
 425
 426 cl_int
 427 clCreateKernelsInProgram(cl_program     program,
 428                          cl_uint        num_kernels,
 429                          cl_kernel *    kernels,
 430                          cl_uint *      num_kernels_ret)
 431 {
 432         PRINT_STUB_ERROR;
 433         return CL_OUT_OF_RESOURCES;
 434 }
 435
 436 cl_int
 437 clRetainKernel(cl_kernel    kernel)
 438 {
 439         PRINT_STUB_ERROR;
 440         return CL_OUT_OF_RESOURCES;
 441 }
 442
 443 cl_int
 444 clReleaseKernel(cl_kernel   kernel)
 445 {
 446         PRINT_STUB_ERROR;
 447         return CL_OUT_OF_RESOURCES;
 448 }
 449
 450 cl_int
 451 clSetKernelArg(cl_kernel    kernel,
 452                cl_uint      arg_index,
 453                size_t       arg_size,
 454                const void * arg_value)
 455 {
 456         PRINT_STUB_ERROR;
 457         return CL_OUT_OF_RESOURCES;
 458 }
 459
 460 cl_int
 461 clGetKernelInfo(cl_kernel       kernel,
 462                 cl_kernel_info  param_name,
 463                 size_t          param_value_size,
 464                 void *          param_value,
 465                 size_t *        param_value_size_ret)
 466 {
 467         PRINT_STUB_ERROR;
 468         return CL_OUT_OF_RESOURCES;
 469 }
 470
 471 cl_int
 472 clGetKernelArgInfo(cl_kernel           kernel,
 473                    cl_uint             arg_indx,
 474                    cl_kernel_arg_info  param_name,
 475                    size_t              param_value_size,
 476                    void *              param_value,
 477                    size_t *            param_value_size_ret)
 478 {
 479         PRINT_STUB_ERROR;
 480         return CL_OUT_OF_RESOURCES;
 481 }
 482
 483 cl_int
 484 clGetKernelWorkGroupInfo(cl_kernel                  kernel,
 485                          cl_device_id               device,
 486                          cl_kernel_work_group_info  param_name,
 487                          size_t                     param_value_size,
 488                          void *                     param_value,
 489                          size_t *                   param_value_size_ret)
 490 {
 491         PRINT_STUB_ERROR;
 492         return CL_OUT_OF_RESOURCES;
 493 }
 494
 495 cl_int
 496 clWaitForEvents(cl_uint             num_events,
 497                 const cl_event *    event_list)
 498 {
 499         PRINT_STUB_ERROR;
 500         return CL_OUT_OF_RESOURCES;
 501 }
 502
 503 cl_int
 504 clGetEventInfo(cl_event         event,
 505                cl_event_info    param_name,
 506                size_t           param_value_size,
 507                void *           param_value,
 508                size_t *         param_value_size_ret)
 509 {
 510         PRINT_STUB_ERROR;
 511         return CL_OUT_OF_RESOURCES;
 512 }
 513
 514 cl_event
 515 clCreateUserEvent(cl_context    context,
 516                   cl_int *      errcode_ret)
 517 {
 518         PRINT_STUB_ERROR;
 519         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
 520         return NULL;
 521 }
 522
 523 cl_int
 524 clRetainEvent(cl_event event)
 525 {
 526         PRINT_STUB_ERROR;
 527         return CL_OUT_OF_RESOURCES;
 528 }
 529
 530 cl_int
 531 clReleaseEvent(cl_event event)
 532 {
 533         PRINT_STUB_ERROR;
 534         return CL_OUT_OF_RESOURCES;
 535 }
 536
 537 cl_int
 538 clSetUserEventStatus(cl_event   event,
 539                      cl_int     execution_status)
 540 {
 541         PRINT_STUB_ERROR;
 542         return CL_OUT_OF_RESOURCES;
 543 }
 544
 545 cl_int
 546 clSetEventCallback( cl_event            event,
 547                     cl_int              command_exec_callback_type,
 548                     void (CL_CALLBACK * pfn_notify)(cl_event, cl_int, void *),
 549                     void *              user_data)
 550 {
 551         PRINT_STUB_ERROR;
 552         return CL_OUT_OF_RESOURCES;
 553 }
 554
 555 cl_int
 556 clGetEventProfilingInfo(cl_event            event,
 557                         cl_profiling_info   param_name,
 558                         size_t              param_value_size,
 559                         void *              param_value,
 560                         size_t *            param_value_size_ret)
 561 {
 562         PRINT_STUB_ERROR;
 563         return CL_OUT_OF_RESOURCES;
 564 }
 565
 566 cl_int
 567 clFlush(cl_command_queue command_queue)
 568 {
 569         PRINT_STUB_ERROR;
 570         return CL_OUT_OF_RESOURCES;
 571 }
 572
 573 cl_int
 574 clFinish(cl_command_queue command_queue)
 575 {
 576         PRINT_STUB_ERROR;
 577         return CL_OUT_OF_RESOURCES;
 578 }
 579
 580 cl_int
 581 clEnqueueReadBuffer(cl_command_queue    command_queue,
 582                     cl_mem              buffer,
 583                     cl_bool             blocking_read,
 584                     size_t              offset,
 585                     size_t              size,
 586                     void *              ptr,
 587                     cl_uint             num_events_in_wait_list,
 588                     const cl_event *    event_wait_list,
 589                     cl_event *          event)
 590 {
 591         PRINT_STUB_ERROR;
 592         return CL_OUT_OF_RESOURCES;
 593 }
 594
 595 cl_int
 596 clEnqueueReadBufferRect(cl_command_queue    command_queue,
 597                         cl_mem              buffer,
 598                         cl_bool             blocking_read,
 599                         const size_t *      buffer_offset,
 600                         const size_t *      host_offset,
 601                         const size_t *      region,
 602                         size_t              buffer_row_pitch,
 603                         size_t              buffer_slice_pitch,
 604                         size_t              host_row_pitch,
 605                         size_t              host_slice_pitch,
 606                         void *              ptr,
 607                         cl_uint             num_events_in_wait_list,
 608                         const cl_event *    event_wait_list,
 609                         cl_event *          event)
 610 {
 611         PRINT_STUB_ERROR;
 612         return CL_OUT_OF_RESOURCES;
 613 }
 614
 615 cl_int
 616 clEnqueueWriteBuffer(cl_command_queue   command_queue,
 617                      cl_mem             buffer,
 618                      cl_bool            blocking_write,
 619                      size_t             offset,
 620                      size_t             size,
 621                      const void *       ptr,
 622                      cl_uint            num_events_in_wait_list,
 623                      const cl_event *   event_wait_list,
 624                      cl_event *         event)
 625 {
 626         PRINT_STUB_ERROR;
 627         return CL_OUT_OF_RESOURCES;
 628 }
 629
 630 cl_int
 631 clEnqueueWriteBufferRect(cl_command_queue    command_queue,
 632                          cl_mem              buffer,
 633                          cl_bool             blocking_write,
 634                          const size_t *      buffer_offset,
 635                          const size_t *      host_offset,
 636                          const size_t *      region,
 637                          size_t              buffer_row_pitch,
 638                          size_t              buffer_slice_pitch,
 639                          size_t              host_row_pitch,
 640                          size_t              host_slice_pitch,
 641                          const void *        ptr,
 642                          cl_uint             num_events_in_wait_list,
 643                          const cl_event *    event_wait_list,
 644                          cl_event *          event)
 645 {
 646         PRINT_STUB_ERROR;
 647         return CL_OUT_OF_RESOURCES;
 648 }
 649
 650 cl_int
 651 clEnqueueFillBuffer(cl_command_queue   command_queue,
 652                     cl_mem             buffer,
 653                     const void *       pattern,
 654                     size_t             pattern_size,
 655                     size_t             offset,
 656                     size_t             size,
 657                     cl_uint            num_events_in_wait_list,
 658                     const cl_event *   event_wait_list,
 659                     cl_event *         event)
 660 {
 661         PRINT_STUB_ERROR;
 662         return CL_OUT_OF_RESOURCES;
 663 }
 664
 665 cl_int
 666 clEnqueueCopyBuffer(cl_command_queue    command_queue,
 667                     cl_mem              src_buffer,
 668                     cl_mem              dst_buffer,
 669                     size_t              src_offset,
 670                     size_t              dst_offset,
 671                     size_t              size,
 672                     cl_uint             num_events_in_wait_list,
 673                     const cl_event *    event_wait_list,
 674                     cl_event *          event)
 675 {
 676         PRINT_STUB_ERROR;
 677         return CL_OUT_OF_RESOURCES;
 678 }
 679
 680 cl_int
 681 clEnqueueCopyBufferRect(cl_command_queue    command_queue,
 682                         cl_mem              src_buffer,
 683                         cl_mem              dst_buffer,
 684                         const size_t *      src_origin,
 685                         const size_t *      dst_origin,
 686                         const size_t *      region,
 687                         size_t              src_row_pitch,
 688                         size_t              src_slice_pitch,
 689                         size_t              dst_row_pitch,
 690                         size_t              dst_slice_pitch,
 691                         cl_uint             num_events_in_wait_list,
 692                         const cl_event *    event_wait_list,
 693                         cl_event *          event)
 694 {
 695         PRINT_STUB_ERROR;
 696         return CL_OUT_OF_RESOURCES;
 697 }
 698
 699 cl_int
 700 clEnqueueReadImage(cl_command_queue     command_queue,
 701                    cl_mem               image,
 702                    cl_bool              blocking_read,
 703                    const size_t *       origin,
 704                    const size_t *       region,
 705                    size_t               row_pitch,
 706                    size_t               slice_pitch,
 707                    void *               ptr,
 708                    cl_uint              num_events_in_wait_list,
 709                    const cl_event *     event_wait_list,
 710                    cl_event *           event)
 711 {
 712         PRINT_STUB_ERROR;
 713         return CL_OUT_OF_RESOURCES;
 714 }
 715
 716 cl_int
 717 clEnqueueWriteImage(cl_command_queue    command_queue,
 718                     cl_mem              image,
 719                     cl_bool             blocking_write,
 720                     const size_t *      origin,
 721                     const size_t *      region,
 722                     size_t              input_row_pitch,
 723                     size_t              input_slice_pitch,
 724                     const void *        ptr,
 725                     cl_uint             num_events_in_wait_list,
 726                     const cl_event *    event_wait_list,
 727                     cl_event *          event)
 728 {
 729         PRINT_STUB_ERROR;
 730         return CL_OUT_OF_RESOURCES;
 731 }
 732
 733 cl_int
 734 clEnqueueFillImage(cl_command_queue   command_queue,
 735                    cl_mem             image,
 736                    const void *       fill_color,
 737                    const size_t *     origin,
 738                    const size_t *     region,
 739                    cl_uint            num_events_in_wait_list,
 740                    const cl_event *   event_wait_list,
 741                    cl_event *         event)
 742 {
 743         PRINT_STUB_ERROR;
 744         return CL_OUT_OF_RESOURCES;
 745 }
 746
 747 cl_int
 748 clEnqueueCopyImage(cl_command_queue     command_queue,
 749                    cl_mem               src_image,
 750                    cl_mem               dst_image,
 751                    const size_t *       src_origin,
 752                    const size_t *       dst_origin,
 753                    const size_t *       region,
 754                    cl_uint              num_events_in_wait_list,
 755                    const cl_event *     event_wait_list,
 756                    cl_event *           event)
 757 {
 758         PRINT_STUB_ERROR;
 759         return CL_OUT_OF_RESOURCES;
 760 }
 761
 762 cl_int
 763 clEnqueueCopyImageToBuffer(cl_command_queue command_queue,
 764                            cl_mem           src_image,
 765                            cl_mem           dst_buffer,
 766                            const size_t *   src_origin,
 767                            const size_t *   region,
 768                            size_t           dst_offset,
 769                            cl_uint          num_events_in_wait_list,
 770                            const cl_event * event_wait_list,
 771                            cl_event *       event)
 772 {
 773         PRINT_STUB_ERROR;
 774         return CL_OUT_OF_RESOURCES;
 775 }
 776
 777 cl_int
 778 clEnqueueCopyBufferToImage(cl_command_queue command_queue,
 779                            cl_mem           src_buffer,
 780                            cl_mem           dst_image,
 781                            size_t           src_offset,
 782                            const size_t *   dst_origin,
 783                            const size_t *   region,
 784                            cl_uint          num_events_in_wait_list,
 785                            const cl_event * event_wait_list,
 786                            cl_event *       event)
 787 {
 788         PRINT_STUB_ERROR;
 789         return CL_OUT_OF_RESOURCES;
 790 }
 791
 792 void *
 793 clEnqueueMapBuffer(cl_command_queue command_queue,
 794                    cl_mem           buffer,
 795                    cl_bool          blocking_map,
 796                    cl_map_flags     map_flags,
 797                    size_t           offset,
 798                    size_t           size,
 799                    cl_uint          num_events_in_wait_list,
 800                    const cl_event * event_wait_list,
 801                    cl_event *       event,
 802                    cl_int *         errcode_ret)
 803 {
 804         PRINT_STUB_ERROR;
 805         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
 806         return NULL;
 807 }
 808
 809 void *
 810 clEnqueueMapImage(cl_command_queue  command_queue,
 811                   cl_mem            image,
 812                   cl_bool           blocking_map,
 813                   cl_map_flags      map_flags,
 814                   const size_t *    origin,
 815                   const size_t *    region,
 816                   size_t *          image_row_pitch,
 817                   size_t *          image_slice_pitch,
 818                   cl_uint           num_events_in_wait_list,
 819                   const cl_event *  event_wait_list,
 820                   cl_event *        event,
 821                   cl_int *          errcode_ret)
 822 {
 823         PRINT_STUB_ERROR;
 824         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
 825         return NULL;
 826 }
 827
 828 cl_int
 829 clEnqueueUnmapMemObject(cl_command_queue command_queue,
 830                         cl_mem           memobj,
 831                         void *           mapped_ptr,
 832                         cl_uint          num_events_in_wait_list,
 833                         const cl_event * event_wait_list,
 834                         cl_event *       event)
 835 {
 836         PRINT_STUB_ERROR;
 837         return CL_OUT_OF_RESOURCES;
 838 }
 839
 840 cl_int
 841 clEnqueueMigrateMemObjects(cl_command_queue       command_queue,
 842                            cl_uint                num_mem_objects,
 843                            const cl_mem *         mem_objects,
 844                            cl_mem_migration_flags flags,
 845                            cl_uint                num_events_in_wait_list,
 846                            const cl_event *       event_wait_list,
 847                            cl_event *             event)
 848 {
 849         PRINT_STUB_ERROR;
 850         return CL_OUT_OF_RESOURCES;
 851 }
 852
 853 cl_int
 854 clEnqueueNDRangeKernel(cl_command_queue command_queue,
 855                        cl_kernel        kernel,
 856                        cl_uint          work_dim,
 857                        const size_t *   global_work_offset,
 858                        const size_t *   global_work_size,
 859                        const size_t *   local_work_size,
 860                        cl_uint          num_events_in_wait_list,
 861                        const cl_event * event_wait_list,
 862                        cl_event *       event)
 863 {
 864         PRINT_STUB_ERROR;
 865         return CL_OUT_OF_RESOURCES;
 866 }
 867
 868 cl_int
 869 clEnqueueTask(cl_command_queue  command_queue,
 870               cl_kernel         kernel,
 871               cl_uint           num_events_in_wait_list,
 872               const cl_event *  event_wait_list,
 873               cl_event *        event)
 874 {
 875         PRINT_STUB_ERROR;
 876         return CL_OUT_OF_RESOURCES;
 877 }
 878
 879 cl_int
 880 clEnqueueNativeKernel(cl_command_queue    command_queue,
 881                       void (CL_CALLBACK * user_func)(void *),
 882                       void *              args,
 883                       size_t              cb_args,
 884                       cl_uint             num_mem_objects,
 885                       const cl_mem *      mem_list,
 886                       const void **       args_mem_loc,
 887                       cl_uint             num_events_in_wait_list,
 888                       const cl_event *    event_wait_list,
 889                       cl_event *          event)
 890 {
 891         PRINT_STUB_ERROR;
 892         return CL_OUT_OF_RESOURCES;
 893 }
 894
 895 cl_int
 896 clEnqueueMarkerWithWaitList(cl_command_queue command_queue,
 897                             cl_uint          num_events_in_wait_list,
 898                             const cl_event * event_wait_list,
 899                             cl_event *       event)
 900 {
 901         PRINT_STUB_ERROR;
 902         return CL_OUT_OF_RESOURCES;
 903 }
 904
 905 cl_int
 906 clEnqueueBarrierWithWaitList(cl_command_queue command_queue,
 907                              cl_uint          num_events_in_wait_list,
 908                              const cl_event * event_wait_list,
 909                              cl_event *       event)
 910 {
 911         PRINT_STUB_ERROR;
 912         return CL_OUT_OF_RESOURCES;
 913 }
 914
 915 void *
 916 clGetExtensionFunctionAddressForPlatform(cl_platform_id platform,
 917                                          const char *   func_name)
 918 {
 919         PRINT_STUB_ERROR;
 920         return NULL;
 921 }
 922
 923
 924 cl_mem
 925 clCreateImage2D(cl_context              context,
 926                 cl_mem_flags            flags,
 927                 const cl_image_format * image_format,
 928                 size_t                  image_width,
 929                 size_t                  image_height,
 930                 size_t                  image_row_pitch,
 931                 void *                  host_ptr,
 932                 cl_int *                errcode_ret)
 933 {
 934         PRINT_STUB_ERROR;
 935         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
 936         return NULL;
 937 }
 938
 939 cl_mem
 940 clCreateImage3D(cl_context              context,
 941                 cl_mem_flags            flags,
 942                 const cl_image_format * image_format,
 943                 size_t                  image_width,
 944                 size_t                  image_height,
 945                 size_t                  image_depth,
 946                 size_t                  image_row_pitch,
 947                 size_t                  image_slice_pitch,
 948                 void *                  host_ptr,
 949                 cl_int *                errcode_ret)
 950 {
 951         PRINT_STUB_ERROR;
 952         if( errcode_ret ) *errcode_ret = CL_OUT_OF_RESOURCES;
 953         return NULL;
 954 }
 955
 956 cl_int
 957 clEnqueueMarker(cl_command_queue    command_queue,
 958                 cl_event *          event)
 959 {
 960         PRINT_STUB_ERROR;
 961         return CL_OUT_OF_RESOURCES;
 962 }
 963
 964 cl_int
 965 clEnqueueWaitForEvents(cl_command_queue command_queue,
 966                        cl_uint          num_events,
 967                        const cl_event * event_list)
 968 {
 969         PRINT_STUB_ERROR;
 970         return CL_OUT_OF_RESOURCES;
 971 }
 972
 973 cl_int
 974 clEnqueueBarrier(cl_command_queue command_queue)
 975 {
 976         PRINT_STUB_ERROR;
 977         return CL_OUT_OF_RESOURCES;
 978 }
 979
 980 cl_int
 981 clUnloadCompiler(void)
 982 {
 983         PRINT_STUB_ERROR;
 984         return CL_OUT_OF_RESOURCES;
 985 }
 986
 987 void *
 988 clGetExtensionFunctionAddress(const char * func_name)
 989 {
 990         PRINT_STUB_ERROR;
 991         return NULL;
 992 }
 993
 994 cl_int
 995 clSetCommandQueueProperty(cl_command_queue              command_queue,
 996                           cl_command_queue_properties   properties,
 997                           cl_bool                       enable,
 998                           cl_command_queue_properties * old_properties)
 999 {
1000         PRINT_STUB_ERROR;
1001         return CL_OUT_OF_RESOURCES;
1002 }