1 // GENERATED FILE - DO NOT EDIT. 2 // Generated by generate_entry_points.py using data from cl.xml and cl_angle_ext.xml. 3 // 4 // Copyright 2025 The ANGLE Project Authors. All rights reserved. 5 // Use of this source code is governed by a BSD-style license that can be 6 // found in the LICENSE file. 7 // 8 // capture_cl_autogen.h: 9 // Capture functions for the OpenCL entry points. 10 11 #ifndef LIBANGLE_CAPTURE_CL_AUTOGEN_H_ 12 #define LIBANGLE_CAPTURE_CL_AUTOGEN_H_ 13 14 #include "common/PackedEnums.h" 15 #include "libANGLE/capture/FrameCapture.h" 16 #ifdef ANGLE_ENABLE_CL 17 # include "common/PackedCLEnums_autogen.h" 18 #endif 19 20 namespace cl 21 { 22 23 // Method Captures 24 25 // CL 1.0 26 angle::CallCapture CaptureGetPlatformIDs(bool isCallValid, 27 cl_uint num_entries, 28 cl_platform_id *platforms, 29 cl_uint *num_platforms, 30 cl_int returnValue); 31 angle::CallCapture CaptureGetPlatformInfo(bool isCallValid, 32 cl_platform_id platform, 33 PlatformInfo param_namePacked, 34 size_t param_value_size, 35 void *param_value, 36 size_t *param_value_size_ret, 37 cl_int returnValue); 38 angle::CallCapture CaptureGetDeviceIDs(bool isCallValid, 39 cl_platform_id platform, 40 DeviceType device_typePacked, 41 cl_uint num_entries, 42 cl_device_id *devices, 43 cl_uint *num_devices, 44 cl_int returnValue); 45 angle::CallCapture CaptureGetDeviceInfo(bool isCallValid, 46 cl_device_id device, 47 DeviceInfo param_namePacked, 48 size_t param_value_size, 49 void *param_value, 50 size_t *param_value_size_ret, 51 cl_int returnValue); 52 angle::CallCapture CaptureCreateContext(bool isCallValid, 53 const cl_context_properties *properties, 54 cl_uint num_devices, 55 const cl_device_id *devices, 56 void(CL_CALLBACK *pfn_notify)(const char *errinfo, 57 const void *private_info, 58 size_t cb, 59 void *user_data), 60 void *user_data, 61 cl_int *errcode_ret, 62 cl_context returnValue); 63 angle::CallCapture CaptureCreateContextFromType( 64 bool isCallValid, 65 const cl_context_properties *properties, 66 DeviceType device_typePacked, 67 void(CL_CALLBACK *pfn_notify)(const char *errinfo, 68 const void *private_info, 69 size_t cb, 70 void *user_data), 71 void *user_data, 72 cl_int *errcode_ret, 73 cl_context returnValue); 74 angle::CallCapture CaptureRetainContext(bool isCallValid, cl_context context, cl_int returnValue); 75 angle::CallCapture CaptureReleaseContext(bool isCallValid, cl_context context, cl_int returnValue); 76 angle::CallCapture CaptureGetContextInfo(bool isCallValid, 77 cl_context context, 78 ContextInfo param_namePacked, 79 size_t param_value_size, 80 void *param_value, 81 size_t *param_value_size_ret, 82 cl_int returnValue); 83 angle::CallCapture CaptureRetainCommandQueue(bool isCallValid, 84 cl_command_queue command_queue, 85 cl_int returnValue); 86 angle::CallCapture CaptureReleaseCommandQueue(bool isCallValid, 87 cl_command_queue command_queue, 88 cl_int returnValue); 89 angle::CallCapture CaptureGetCommandQueueInfo(bool isCallValid, 90 cl_command_queue command_queue, 91 CommandQueueInfo param_namePacked, 92 size_t param_value_size, 93 void *param_value, 94 size_t *param_value_size_ret, 95 cl_int returnValue); 96 angle::CallCapture CaptureCreateBuffer(bool isCallValid, 97 cl_context context, 98 MemFlags flagsPacked, 99 size_t size, 100 void *host_ptr, 101 cl_int *errcode_ret, 102 cl_mem returnValue); 103 angle::CallCapture CaptureRetainMemObject(bool isCallValid, cl_mem memobj, cl_int returnValue); 104 angle::CallCapture CaptureReleaseMemObject(bool isCallValid, cl_mem memobj, cl_int returnValue); 105 angle::CallCapture CaptureGetSupportedImageFormats(bool isCallValid, 106 cl_context context, 107 MemFlags flagsPacked, 108 MemObjectType image_typePacked, 109 cl_uint num_entries, 110 cl_image_format *image_formats, 111 cl_uint *num_image_formats, 112 cl_int returnValue); 113 angle::CallCapture CaptureGetMemObjectInfo(bool isCallValid, 114 cl_mem memobj, 115 MemInfo param_namePacked, 116 size_t param_value_size, 117 void *param_value, 118 size_t *param_value_size_ret, 119 cl_int returnValue); 120 angle::CallCapture CaptureGetImageInfo(bool isCallValid, 121 cl_mem image, 122 ImageInfo param_namePacked, 123 size_t param_value_size, 124 void *param_value, 125 size_t *param_value_size_ret, 126 cl_int returnValue); 127 angle::CallCapture CaptureRetainSampler(bool isCallValid, cl_sampler sampler, cl_int returnValue); 128 angle::CallCapture CaptureReleaseSampler(bool isCallValid, cl_sampler sampler, cl_int returnValue); 129 angle::CallCapture CaptureGetSamplerInfo(bool isCallValid, 130 cl_sampler sampler, 131 SamplerInfo param_namePacked, 132 size_t param_value_size, 133 void *param_value, 134 size_t *param_value_size_ret, 135 cl_int returnValue); 136 angle::CallCapture CaptureCreateProgramWithSource(bool isCallValid, 137 cl_context context, 138 cl_uint count, 139 const char **strings, 140 const size_t *lengths, 141 cl_int *errcode_ret, 142 cl_program returnValue); 143 angle::CallCapture CaptureCreateProgramWithBinary(bool isCallValid, 144 cl_context context, 145 cl_uint num_devices, 146 const cl_device_id *device_list, 147 const size_t *lengths, 148 const unsigned char **binaries, 149 cl_int *binary_status, 150 cl_int *errcode_ret, 151 cl_program returnValue); 152 angle::CallCapture CaptureRetainProgram(bool isCallValid, cl_program program, cl_int returnValue); 153 angle::CallCapture CaptureReleaseProgram(bool isCallValid, cl_program program, cl_int returnValue); 154 angle::CallCapture CaptureBuildProgram(bool isCallValid, 155 cl_program program, 156 cl_uint num_devices, 157 const cl_device_id *device_list, 158 const char *options, 159 void(CL_CALLBACK *pfn_notify)(cl_program program, 160 void *user_data), 161 void *user_data, 162 cl_int returnValue); 163 angle::CallCapture CaptureGetProgramInfo(bool isCallValid, 164 cl_program program, 165 ProgramInfo param_namePacked, 166 size_t param_value_size, 167 void *param_value, 168 size_t *param_value_size_ret, 169 cl_int returnValue); 170 angle::CallCapture CaptureGetProgramBuildInfo(bool isCallValid, 171 cl_program program, 172 cl_device_id device, 173 ProgramBuildInfo param_namePacked, 174 size_t param_value_size, 175 void *param_value, 176 size_t *param_value_size_ret, 177 cl_int returnValue); 178 angle::CallCapture CaptureCreateKernel(bool isCallValid, 179 cl_program program, 180 const char *kernel_name, 181 cl_int *errcode_ret, 182 cl_kernel returnValue); 183 angle::CallCapture CaptureCreateKernelsInProgram(bool isCallValid, 184 cl_program program, 185 cl_uint num_kernels, 186 cl_kernel *kernels, 187 cl_uint *num_kernels_ret, 188 cl_int returnValue); 189 angle::CallCapture CaptureRetainKernel(bool isCallValid, cl_kernel kernel, cl_int returnValue); 190 angle::CallCapture CaptureReleaseKernel(bool isCallValid, cl_kernel kernel, cl_int returnValue); 191 angle::CallCapture CaptureSetKernelArg(bool isCallValid, 192 cl_kernel kernel, 193 cl_uint arg_index, 194 size_t arg_size, 195 const void *arg_value, 196 cl_int returnValue); 197 angle::CallCapture CaptureGetKernelInfo(bool isCallValid, 198 cl_kernel kernel, 199 KernelInfo param_namePacked, 200 size_t param_value_size, 201 void *param_value, 202 size_t *param_value_size_ret, 203 cl_int returnValue); 204 angle::CallCapture CaptureGetKernelWorkGroupInfo(bool isCallValid, 205 cl_kernel kernel, 206 cl_device_id device, 207 KernelWorkGroupInfo param_namePacked, 208 size_t param_value_size, 209 void *param_value, 210 size_t *param_value_size_ret, 211 cl_int returnValue); 212 angle::CallCapture CaptureWaitForEvents(bool isCallValid, 213 cl_uint num_events, 214 const cl_event *event_list, 215 cl_int returnValue); 216 angle::CallCapture CaptureGetEventInfo(bool isCallValid, 217 cl_event event, 218 EventInfo param_namePacked, 219 size_t param_value_size, 220 void *param_value, 221 size_t *param_value_size_ret, 222 cl_int returnValue); 223 angle::CallCapture CaptureRetainEvent(bool isCallValid, cl_event event, cl_int returnValue); 224 angle::CallCapture CaptureReleaseEvent(bool isCallValid, cl_event event, cl_int returnValue); 225 angle::CallCapture CaptureGetEventProfilingInfo(bool isCallValid, 226 cl_event event, 227 ProfilingInfo param_namePacked, 228 size_t param_value_size, 229 void *param_value, 230 size_t *param_value_size_ret, 231 cl_int returnValue); 232 angle::CallCapture CaptureFlush(bool isCallValid, 233 cl_command_queue command_queue, 234 cl_int returnValue); 235 angle::CallCapture CaptureFinish(bool isCallValid, 236 cl_command_queue command_queue, 237 cl_int returnValue); 238 angle::CallCapture CaptureEnqueueReadBuffer(bool isCallValid, 239 cl_command_queue command_queue, 240 cl_mem buffer, 241 cl_bool blocking_read, 242 size_t offset, 243 size_t size, 244 void *ptr, 245 cl_uint num_events_in_wait_list, 246 const cl_event *event_wait_list, 247 cl_event *event, 248 cl_int returnValue); 249 angle::CallCapture CaptureEnqueueWriteBuffer(bool isCallValid, 250 cl_command_queue command_queue, 251 cl_mem buffer, 252 cl_bool blocking_write, 253 size_t offset, 254 size_t size, 255 const void *ptr, 256 cl_uint num_events_in_wait_list, 257 const cl_event *event_wait_list, 258 cl_event *event, 259 cl_int returnValue); 260 angle::CallCapture CaptureEnqueueCopyBuffer(bool isCallValid, 261 cl_command_queue command_queue, 262 cl_mem src_buffer, 263 cl_mem dst_buffer, 264 size_t src_offset, 265 size_t dst_offset, 266 size_t size, 267 cl_uint num_events_in_wait_list, 268 const cl_event *event_wait_list, 269 cl_event *event, 270 cl_int returnValue); 271 angle::CallCapture CaptureEnqueueReadImage(bool isCallValid, 272 cl_command_queue command_queue, 273 cl_mem image, 274 cl_bool blocking_read, 275 const size_t *origin, 276 const size_t *region, 277 size_t row_pitch, 278 size_t slice_pitch, 279 void *ptr, 280 cl_uint num_events_in_wait_list, 281 const cl_event *event_wait_list, 282 cl_event *event, 283 cl_int returnValue); 284 angle::CallCapture CaptureEnqueueWriteImage(bool isCallValid, 285 cl_command_queue command_queue, 286 cl_mem image, 287 cl_bool blocking_write, 288 const size_t *origin, 289 const size_t *region, 290 size_t input_row_pitch, 291 size_t input_slice_pitch, 292 const void *ptr, 293 cl_uint num_events_in_wait_list, 294 const cl_event *event_wait_list, 295 cl_event *event, 296 cl_int returnValue); 297 angle::CallCapture CaptureEnqueueCopyImage(bool isCallValid, 298 cl_command_queue command_queue, 299 cl_mem src_image, 300 cl_mem dst_image, 301 const size_t *src_origin, 302 const size_t *dst_origin, 303 const size_t *region, 304 cl_uint num_events_in_wait_list, 305 const cl_event *event_wait_list, 306 cl_event *event, 307 cl_int returnValue); 308 angle::CallCapture CaptureEnqueueCopyImageToBuffer(bool isCallValid, 309 cl_command_queue command_queue, 310 cl_mem src_image, 311 cl_mem dst_buffer, 312 const size_t *src_origin, 313 const size_t *region, 314 size_t dst_offset, 315 cl_uint num_events_in_wait_list, 316 const cl_event *event_wait_list, 317 cl_event *event, 318 cl_int returnValue); 319 angle::CallCapture CaptureEnqueueCopyBufferToImage(bool isCallValid, 320 cl_command_queue command_queue, 321 cl_mem src_buffer, 322 cl_mem dst_image, 323 size_t src_offset, 324 const size_t *dst_origin, 325 const size_t *region, 326 cl_uint num_events_in_wait_list, 327 const cl_event *event_wait_list, 328 cl_event *event, 329 cl_int returnValue); 330 angle::CallCapture CaptureEnqueueMapBuffer(bool isCallValid, 331 cl_command_queue command_queue, 332 cl_mem buffer, 333 cl_bool blocking_map, 334 MapFlags map_flagsPacked, 335 size_t offset, 336 size_t size, 337 cl_uint num_events_in_wait_list, 338 const cl_event *event_wait_list, 339 cl_event *event, 340 cl_int *errcode_ret, 341 void *returnValue); 342 angle::CallCapture CaptureEnqueueMapImage(bool isCallValid, 343 cl_command_queue command_queue, 344 cl_mem image, 345 cl_bool blocking_map, 346 MapFlags map_flagsPacked, 347 const size_t *origin, 348 const size_t *region, 349 size_t *image_row_pitch, 350 size_t *image_slice_pitch, 351 cl_uint num_events_in_wait_list, 352 const cl_event *event_wait_list, 353 cl_event *event, 354 cl_int *errcode_ret, 355 void *returnValue); 356 angle::CallCapture CaptureEnqueueUnmapMemObject(bool isCallValid, 357 cl_command_queue command_queue, 358 cl_mem memobj, 359 void *mapped_ptr, 360 cl_uint num_events_in_wait_list, 361 const cl_event *event_wait_list, 362 cl_event *event, 363 cl_int returnValue); 364 angle::CallCapture CaptureEnqueueNDRangeKernel(bool isCallValid, 365 cl_command_queue command_queue, 366 cl_kernel kernel, 367 cl_uint work_dim, 368 const size_t *global_work_offset, 369 const size_t *global_work_size, 370 const size_t *local_work_size, 371 cl_uint num_events_in_wait_list, 372 const cl_event *event_wait_list, 373 cl_event *event, 374 cl_int returnValue); 375 angle::CallCapture CaptureEnqueueNativeKernel(bool isCallValid, 376 cl_command_queue command_queue, 377 void(CL_CALLBACK *user_func)(void *), 378 void *args, 379 size_t cb_args, 380 cl_uint num_mem_objects, 381 const cl_mem *mem_list, 382 const void **args_mem_loc, 383 cl_uint num_events_in_wait_list, 384 const cl_event *event_wait_list, 385 cl_event *event, 386 cl_int returnValue); 387 angle::CallCapture CaptureSetCommandQueueProperty(bool isCallValid, 388 cl_command_queue command_queue, 389 CommandQueueProperties propertiesPacked, 390 cl_bool enable, 391 cl_command_queue_properties *old_properties, 392 cl_int returnValue); 393 angle::CallCapture CaptureCreateImage2D(bool isCallValid, 394 cl_context context, 395 MemFlags flagsPacked, 396 const cl_image_format *image_format, 397 size_t image_width, 398 size_t image_height, 399 size_t image_row_pitch, 400 void *host_ptr, 401 cl_int *errcode_ret, 402 cl_mem returnValue); 403 angle::CallCapture CaptureCreateImage3D(bool isCallValid, 404 cl_context context, 405 MemFlags flagsPacked, 406 const cl_image_format *image_format, 407 size_t image_width, 408 size_t image_height, 409 size_t image_depth, 410 size_t image_row_pitch, 411 size_t image_slice_pitch, 412 void *host_ptr, 413 cl_int *errcode_ret, 414 cl_mem returnValue); 415 angle::CallCapture CaptureEnqueueMarker(bool isCallValid, 416 cl_command_queue command_queue, 417 cl_event *event, 418 cl_int returnValue); 419 angle::CallCapture CaptureEnqueueWaitForEvents(bool isCallValid, 420 cl_command_queue command_queue, 421 cl_uint num_events, 422 const cl_event *event_list, 423 cl_int returnValue); 424 angle::CallCapture CaptureEnqueueBarrier(bool isCallValid, 425 cl_command_queue command_queue, 426 cl_int returnValue); 427 angle::CallCapture CaptureUnloadCompiler(bool isCallValid, cl_int returnValue); 428 angle::CallCapture CaptureGetExtensionFunctionAddress(bool isCallValid, 429 const char *func_name, 430 void *returnValue); 431 angle::CallCapture CaptureCreateCommandQueue(bool isCallValid, 432 cl_context context, 433 cl_device_id device, 434 CommandQueueProperties propertiesPacked, 435 cl_int *errcode_ret, 436 cl_command_queue returnValue); 437 angle::CallCapture CaptureCreateSampler(bool isCallValid, 438 cl_context context, 439 cl_bool normalized_coords, 440 AddressingMode addressing_modePacked, 441 FilterMode filter_modePacked, 442 cl_int *errcode_ret, 443 cl_sampler returnValue); 444 angle::CallCapture CaptureEnqueueTask(bool isCallValid, 445 cl_command_queue command_queue, 446 cl_kernel kernel, 447 cl_uint num_events_in_wait_list, 448 const cl_event *event_wait_list, 449 cl_event *event, 450 cl_int returnValue); 451 452 // CL 1.1 453 angle::CallCapture CaptureCreateSubBuffer(bool isCallValid, 454 cl_mem buffer, 455 MemFlags flagsPacked, 456 cl_buffer_create_type buffer_create_type, 457 const void *buffer_create_info, 458 cl_int *errcode_ret, 459 cl_mem returnValue); 460 angle::CallCapture CaptureSetMemObjectDestructorCallback( 461 bool isCallValid, 462 cl_mem memobj, 463 void(CL_CALLBACK *pfn_notify)(cl_mem memobj, void *user_data), 464 void *user_data, 465 cl_int returnValue); 466 angle::CallCapture CaptureCreateUserEvent(bool isCallValid, 467 cl_context context, 468 cl_int *errcode_ret, 469 cl_event returnValue); 470 angle::CallCapture CaptureSetUserEventStatus(bool isCallValid, 471 cl_event event, 472 cl_int execution_status, 473 cl_int returnValue); 474 angle::CallCapture CaptureSetEventCallback( 475 bool isCallValid, 476 cl_event event, 477 cl_int command_exec_callback_type, 478 void(CL_CALLBACK *pfn_notify)(cl_event event, cl_int event_command_status, void *user_data), 479 void *user_data, 480 cl_int returnValue); 481 angle::CallCapture CaptureEnqueueReadBufferRect(bool isCallValid, 482 cl_command_queue command_queue, 483 cl_mem buffer, 484 cl_bool blocking_read, 485 const size_t *buffer_origin, 486 const size_t *host_origin, 487 const size_t *region, 488 size_t buffer_row_pitch, 489 size_t buffer_slice_pitch, 490 size_t host_row_pitch, 491 size_t host_slice_pitch, 492 void *ptr, 493 cl_uint num_events_in_wait_list, 494 const cl_event *event_wait_list, 495 cl_event *event, 496 cl_int returnValue); 497 angle::CallCapture CaptureEnqueueWriteBufferRect(bool isCallValid, 498 cl_command_queue command_queue, 499 cl_mem buffer, 500 cl_bool blocking_write, 501 const size_t *buffer_origin, 502 const size_t *host_origin, 503 const size_t *region, 504 size_t buffer_row_pitch, 505 size_t buffer_slice_pitch, 506 size_t host_row_pitch, 507 size_t host_slice_pitch, 508 const void *ptr, 509 cl_uint num_events_in_wait_list, 510 const cl_event *event_wait_list, 511 cl_event *event, 512 cl_int returnValue); 513 angle::CallCapture CaptureEnqueueCopyBufferRect(bool isCallValid, 514 cl_command_queue command_queue, 515 cl_mem src_buffer, 516 cl_mem dst_buffer, 517 const size_t *src_origin, 518 const size_t *dst_origin, 519 const size_t *region, 520 size_t src_row_pitch, 521 size_t src_slice_pitch, 522 size_t dst_row_pitch, 523 size_t dst_slice_pitch, 524 cl_uint num_events_in_wait_list, 525 const cl_event *event_wait_list, 526 cl_event *event, 527 cl_int returnValue); 528 529 // CL 1.2 530 angle::CallCapture CaptureCreateSubDevices(bool isCallValid, 531 cl_device_id in_device, 532 const cl_device_partition_property *properties, 533 cl_uint num_devices, 534 cl_device_id *out_devices, 535 cl_uint *num_devices_ret, 536 cl_int returnValue); 537 angle::CallCapture CaptureRetainDevice(bool isCallValid, cl_device_id device, cl_int returnValue); 538 angle::CallCapture CaptureReleaseDevice(bool isCallValid, cl_device_id device, cl_int returnValue); 539 angle::CallCapture CaptureCreateImage(bool isCallValid, 540 cl_context context, 541 MemFlags flagsPacked, 542 const cl_image_format *image_format, 543 const cl_image_desc *image_desc, 544 void *host_ptr, 545 cl_int *errcode_ret, 546 cl_mem returnValue); 547 angle::CallCapture CaptureCreateProgramWithBuiltInKernels(bool isCallValid, 548 cl_context context, 549 cl_uint num_devices, 550 const cl_device_id *device_list, 551 const char *kernel_names, 552 cl_int *errcode_ret, 553 cl_program returnValue); 554 angle::CallCapture CaptureCompileProgram(bool isCallValid, 555 cl_program program, 556 cl_uint num_devices, 557 const cl_device_id *device_list, 558 const char *options, 559 cl_uint num_input_headers, 560 const cl_program *input_headers, 561 const char **header_include_names, 562 void(CL_CALLBACK *pfn_notify)(cl_program program, 563 void *user_data), 564 void *user_data, 565 cl_int returnValue); 566 angle::CallCapture CaptureLinkProgram(bool isCallValid, 567 cl_context context, 568 cl_uint num_devices, 569 const cl_device_id *device_list, 570 const char *options, 571 cl_uint num_input_programs, 572 const cl_program *input_programs, 573 void(CL_CALLBACK *pfn_notify)(cl_program program, 574 void *user_data), 575 void *user_data, 576 cl_int *errcode_ret, 577 cl_program returnValue); 578 angle::CallCapture CaptureUnloadPlatformCompiler(bool isCallValid, 579 cl_platform_id platform, 580 cl_int returnValue); 581 angle::CallCapture CaptureGetKernelArgInfo(bool isCallValid, 582 cl_kernel kernel, 583 cl_uint arg_index, 584 KernelArgInfo param_namePacked, 585 size_t param_value_size, 586 void *param_value, 587 size_t *param_value_size_ret, 588 cl_int returnValue); 589 angle::CallCapture CaptureEnqueueFillBuffer(bool isCallValid, 590 cl_command_queue command_queue, 591 cl_mem buffer, 592 const void *pattern, 593 size_t pattern_size, 594 size_t offset, 595 size_t size, 596 cl_uint num_events_in_wait_list, 597 const cl_event *event_wait_list, 598 cl_event *event, 599 cl_int returnValue); 600 angle::CallCapture CaptureEnqueueFillImage(bool isCallValid, 601 cl_command_queue command_queue, 602 cl_mem image, 603 const void *fill_color, 604 const size_t *origin, 605 const size_t *region, 606 cl_uint num_events_in_wait_list, 607 const cl_event *event_wait_list, 608 cl_event *event, 609 cl_int returnValue); 610 angle::CallCapture CaptureEnqueueMigrateMemObjects(bool isCallValid, 611 cl_command_queue command_queue, 612 cl_uint num_mem_objects, 613 const cl_mem *mem_objects, 614 MemMigrationFlags flagsPacked, 615 cl_uint num_events_in_wait_list, 616 const cl_event *event_wait_list, 617 cl_event *event, 618 cl_int returnValue); 619 angle::CallCapture CaptureEnqueueMarkerWithWaitList(bool isCallValid, 620 cl_command_queue command_queue, 621 cl_uint num_events_in_wait_list, 622 const cl_event *event_wait_list, 623 cl_event *event, 624 cl_int returnValue); 625 angle::CallCapture CaptureEnqueueBarrierWithWaitList(bool isCallValid, 626 cl_command_queue command_queue, 627 cl_uint num_events_in_wait_list, 628 const cl_event *event_wait_list, 629 cl_event *event, 630 cl_int returnValue); 631 angle::CallCapture CaptureGetExtensionFunctionAddressForPlatform(bool isCallValid, 632 cl_platform_id platform, 633 const char *func_name, 634 void *returnValue); 635 636 // CL 2.0 637 angle::CallCapture CaptureCreateCommandQueueWithProperties(bool isCallValid, 638 cl_context context, 639 cl_device_id device, 640 const cl_queue_properties *properties, 641 cl_int *errcode_ret, 642 cl_command_queue returnValue); 643 angle::CallCapture CaptureCreatePipe(bool isCallValid, 644 cl_context context, 645 MemFlags flagsPacked, 646 cl_uint pipe_packet_size, 647 cl_uint pipe_max_packets, 648 const cl_pipe_properties *properties, 649 cl_int *errcode_ret, 650 cl_mem returnValue); 651 angle::CallCapture CaptureGetPipeInfo(bool isCallValid, 652 cl_mem pipe, 653 PipeInfo param_namePacked, 654 size_t param_value_size, 655 void *param_value, 656 size_t *param_value_size_ret, 657 cl_int returnValue); 658 angle::CallCapture CaptureSVMAlloc(bool isCallValid, 659 cl_context context, 660 SVM_MemFlags flagsPacked, 661 size_t size, 662 cl_uint alignment, 663 void *returnValue); 664 angle::CallCapture CaptureSVMFree(bool isCallValid, cl_context context, void *svm_pointer); 665 angle::CallCapture CaptureCreateSamplerWithProperties( 666 bool isCallValid, 667 cl_context context, 668 const cl_sampler_properties *sampler_properties, 669 cl_int *errcode_ret, 670 cl_sampler returnValue); 671 angle::CallCapture CaptureSetKernelArgSVMPointer(bool isCallValid, 672 cl_kernel kernel, 673 cl_uint arg_index, 674 const void *arg_value, 675 cl_int returnValue); 676 angle::CallCapture CaptureSetKernelExecInfo(bool isCallValid, 677 cl_kernel kernel, 678 KernelExecInfo param_namePacked, 679 size_t param_value_size, 680 const void *param_value, 681 cl_int returnValue); 682 angle::CallCapture CaptureEnqueueSVMFree(bool isCallValid, 683 cl_command_queue command_queue, 684 cl_uint num_svm_pointers, 685 void *svm_pointers[], 686 void(CL_CALLBACK *pfn_free_func)(cl_command_queue queue, 687 cl_uint num_svm_pointers, 688 void *svm_pointers[], 689 void *user_data), 690 void *user_data, 691 cl_uint num_events_in_wait_list, 692 const cl_event *event_wait_list, 693 cl_event *event, 694 cl_int returnValue); 695 angle::CallCapture CaptureEnqueueSVMMemcpy(bool isCallValid, 696 cl_command_queue command_queue, 697 cl_bool blocking_copy, 698 void *dst_ptr, 699 const void *src_ptr, 700 size_t size, 701 cl_uint num_events_in_wait_list, 702 const cl_event *event_wait_list, 703 cl_event *event, 704 cl_int returnValue); 705 angle::CallCapture CaptureEnqueueSVMMemFill(bool isCallValid, 706 cl_command_queue command_queue, 707 void *svm_ptr, 708 const void *pattern, 709 size_t pattern_size, 710 size_t size, 711 cl_uint num_events_in_wait_list, 712 const cl_event *event_wait_list, 713 cl_event *event, 714 cl_int returnValue); 715 angle::CallCapture CaptureEnqueueSVMMap(bool isCallValid, 716 cl_command_queue command_queue, 717 cl_bool blocking_map, 718 MapFlags flagsPacked, 719 void *svm_ptr, 720 size_t size, 721 cl_uint num_events_in_wait_list, 722 const cl_event *event_wait_list, 723 cl_event *event, 724 cl_int returnValue); 725 angle::CallCapture CaptureEnqueueSVMUnmap(bool isCallValid, 726 cl_command_queue command_queue, 727 void *svm_ptr, 728 cl_uint num_events_in_wait_list, 729 const cl_event *event_wait_list, 730 cl_event *event, 731 cl_int returnValue); 732 733 // CL 2.1 734 angle::CallCapture CaptureSetDefaultDeviceCommandQueue(bool isCallValid, 735 cl_context context, 736 cl_device_id device, 737 cl_command_queue command_queue, 738 cl_int returnValue); 739 angle::CallCapture CaptureGetDeviceAndHostTimer(bool isCallValid, 740 cl_device_id device, 741 cl_ulong *device_timestamp, 742 cl_ulong *host_timestamp, 743 cl_int returnValue); 744 angle::CallCapture CaptureGetHostTimer(bool isCallValid, 745 cl_device_id device, 746 cl_ulong *host_timestamp, 747 cl_int returnValue); 748 angle::CallCapture CaptureCreateProgramWithIL(bool isCallValid, 749 cl_context context, 750 const void *il, 751 size_t length, 752 cl_int *errcode_ret, 753 cl_program returnValue); 754 angle::CallCapture CaptureCloneKernel(bool isCallValid, 755 cl_kernel source_kernel, 756 cl_int *errcode_ret, 757 cl_kernel returnValue); 758 angle::CallCapture CaptureGetKernelSubGroupInfo(bool isCallValid, 759 cl_kernel kernel, 760 cl_device_id device, 761 KernelSubGroupInfo param_namePacked, 762 size_t input_value_size, 763 const void *input_value, 764 size_t param_value_size, 765 void *param_value, 766 size_t *param_value_size_ret, 767 cl_int returnValue); 768 angle::CallCapture CaptureEnqueueSVMMigrateMem(bool isCallValid, 769 cl_command_queue command_queue, 770 cl_uint num_svm_pointers, 771 const void **svm_pointers, 772 const size_t *sizes, 773 MemMigrationFlags flagsPacked, 774 cl_uint num_events_in_wait_list, 775 const cl_event *event_wait_list, 776 cl_event *event, 777 cl_int returnValue); 778 779 // CL 2.2 780 angle::CallCapture CaptureSetProgramReleaseCallback( 781 bool isCallValid, 782 cl_program program, 783 void(CL_CALLBACK *pfn_notify)(cl_program program, void *user_data), 784 void *user_data, 785 cl_int returnValue); 786 angle::CallCapture CaptureSetProgramSpecializationConstant(bool isCallValid, 787 cl_program program, 788 cl_uint spec_id, 789 size_t spec_size, 790 const void *spec_value, 791 cl_int returnValue); 792 793 // CL 3.0 794 angle::CallCapture CaptureSetContextDestructorCallback( 795 bool isCallValid, 796 cl_context context, 797 void(CL_CALLBACK *pfn_notify)(cl_context context, void *user_data), 798 void *user_data, 799 cl_int returnValue); 800 angle::CallCapture CaptureCreateBufferWithProperties(bool isCallValid, 801 cl_context context, 802 const cl_mem_properties *properties, 803 MemFlags flagsPacked, 804 size_t size, 805 void *host_ptr, 806 cl_int *errcode_ret, 807 cl_mem returnValue); 808 angle::CallCapture CaptureCreateImageWithProperties(bool isCallValid, 809 cl_context context, 810 const cl_mem_properties *properties, 811 MemFlags flagsPacked, 812 const cl_image_format *image_format, 813 const cl_image_desc *image_desc, 814 void *host_ptr, 815 cl_int *errcode_ret, 816 cl_mem returnValue); 817 818 // cl_khr_icd 819 angle::CallCapture CaptureIcdGetPlatformIDsKHR(bool isCallValid, 820 cl_uint num_entries, 821 cl_platform_id *platforms, 822 cl_uint *num_platforms, 823 cl_int returnValue); 824 825 // Parameter Captures 826 827 // CL 1.0 828 void CaptureGetPlatformIDs_platforms(bool isCallValid, 829 cl_uint num_entries, 830 cl_platform_id *platforms, 831 cl_uint *num_platforms, 832 angle::ParamCapture *paramCapture); 833 void CaptureGetPlatformIDs_num_platforms(bool isCallValid, 834 cl_uint num_entries, 835 cl_platform_id *platforms, 836 cl_uint *num_platforms, 837 angle::ParamCapture *paramCapture); 838 void CaptureGetPlatformInfo_param_value(bool isCallValid, 839 cl_platform_id platform, 840 PlatformInfo param_namePacked, 841 size_t param_value_size, 842 void *param_value, 843 size_t *param_value_size_ret, 844 angle::ParamCapture *paramCapture); 845 void CaptureGetPlatformInfo_param_value_size_ret(bool isCallValid, 846 cl_platform_id platform, 847 PlatformInfo param_namePacked, 848 size_t param_value_size, 849 void *param_value, 850 size_t *param_value_size_ret, 851 angle::ParamCapture *paramCapture); 852 void CaptureGetDeviceIDs_devices(bool isCallValid, 853 cl_platform_id platform, 854 DeviceType device_typePacked, 855 cl_uint num_entries, 856 cl_device_id *devices, 857 cl_uint *num_devices, 858 angle::ParamCapture *paramCapture); 859 void CaptureGetDeviceIDs_num_devices(bool isCallValid, 860 cl_platform_id platform, 861 DeviceType device_typePacked, 862 cl_uint num_entries, 863 cl_device_id *devices, 864 cl_uint *num_devices, 865 angle::ParamCapture *paramCapture); 866 void CaptureGetDeviceInfo_param_value(bool isCallValid, 867 cl_device_id device, 868 DeviceInfo param_namePacked, 869 size_t param_value_size, 870 void *param_value, 871 size_t *param_value_size_ret, 872 angle::ParamCapture *paramCapture); 873 void CaptureGetDeviceInfo_param_value_size_ret(bool isCallValid, 874 cl_device_id device, 875 DeviceInfo param_namePacked, 876 size_t param_value_size, 877 void *param_value, 878 size_t *param_value_size_ret, 879 angle::ParamCapture *paramCapture); 880 void CaptureCreateContext_properties(bool isCallValid, 881 const cl_context_properties *properties, 882 cl_uint num_devices, 883 const cl_device_id *devices, 884 void(CL_CALLBACK *pfn_notify)(const char *errinfo, 885 const void *private_info, 886 size_t cb, 887 void *user_data), 888 void *user_data, 889 cl_int *errcode_ret, 890 angle::ParamCapture *paramCapture); 891 void CaptureCreateContext_devices(bool isCallValid, 892 const cl_context_properties *properties, 893 cl_uint num_devices, 894 const cl_device_id *devices, 895 void(CL_CALLBACK *pfn_notify)(const char *errinfo, 896 const void *private_info, 897 size_t cb, 898 void *user_data), 899 void *user_data, 900 cl_int *errcode_ret, 901 angle::ParamCapture *paramCapture); 902 void CaptureCreateContext_pfn_notify(bool isCallValid, 903 const cl_context_properties *properties, 904 cl_uint num_devices, 905 const cl_device_id *devices, 906 void(CL_CALLBACK *pfn_notify)(const char *errinfo, 907 const void *private_info, 908 size_t cb, 909 void *user_data), 910 void *user_data, 911 cl_int *errcode_ret, 912 angle::ParamCapture *paramCapture); 913 void CaptureCreateContext_user_data(bool isCallValid, 914 const cl_context_properties *properties, 915 cl_uint num_devices, 916 const cl_device_id *devices, 917 void(CL_CALLBACK *pfn_notify)(const char *errinfo, 918 const void *private_info, 919 size_t cb, 920 void *user_data), 921 void *user_data, 922 cl_int *errcode_ret, 923 angle::ParamCapture *paramCapture); 924 void CaptureCreateContext_errcode_ret(bool isCallValid, 925 const cl_context_properties *properties, 926 cl_uint num_devices, 927 const cl_device_id *devices, 928 void(CL_CALLBACK *pfn_notify)(const char *errinfo, 929 const void *private_info, 930 size_t cb, 931 void *user_data), 932 void *user_data, 933 cl_int *errcode_ret, 934 angle::ParamCapture *paramCapture); 935 void CaptureCreateContextFromType_properties(bool isCallValid, 936 const cl_context_properties *properties, 937 DeviceType device_typePacked, 938 void(CL_CALLBACK *pfn_notify)(const char *errinfo, 939 const void *private_info, 940 size_t cb, 941 void *user_data), 942 void *user_data, 943 cl_int *errcode_ret, 944 angle::ParamCapture *paramCapture); 945 void CaptureCreateContextFromType_pfn_notify(bool isCallValid, 946 const cl_context_properties *properties, 947 DeviceType device_typePacked, 948 void(CL_CALLBACK *pfn_notify)(const char *errinfo, 949 const void *private_info, 950 size_t cb, 951 void *user_data), 952 void *user_data, 953 cl_int *errcode_ret, 954 angle::ParamCapture *paramCapture); 955 void CaptureCreateContextFromType_user_data(bool isCallValid, 956 const cl_context_properties *properties, 957 DeviceType device_typePacked, 958 void(CL_CALLBACK *pfn_notify)(const char *errinfo, 959 const void *private_info, 960 size_t cb, 961 void *user_data), 962 void *user_data, 963 cl_int *errcode_ret, 964 angle::ParamCapture *paramCapture); 965 void CaptureCreateContextFromType_errcode_ret( 966 bool isCallValid, 967 const cl_context_properties *properties, 968 DeviceType device_typePacked, 969 void(CL_CALLBACK *pfn_notify)(const char *errinfo, 970 const void *private_info, 971 size_t cb, 972 void *user_data), 973 void *user_data, 974 cl_int *errcode_ret, 975 angle::ParamCapture *paramCapture); 976 void CaptureGetContextInfo_param_value(bool isCallValid, 977 cl_context context, 978 ContextInfo param_namePacked, 979 size_t param_value_size, 980 void *param_value, 981 size_t *param_value_size_ret, 982 angle::ParamCapture *paramCapture); 983 void CaptureGetContextInfo_param_value_size_ret(bool isCallValid, 984 cl_context context, 985 ContextInfo param_namePacked, 986 size_t param_value_size, 987 void *param_value, 988 size_t *param_value_size_ret, 989 angle::ParamCapture *paramCapture); 990 void CaptureGetCommandQueueInfo_param_value(bool isCallValid, 991 cl_command_queue command_queue, 992 CommandQueueInfo param_namePacked, 993 size_t param_value_size, 994 void *param_value, 995 size_t *param_value_size_ret, 996 angle::ParamCapture *paramCapture); 997 void CaptureGetCommandQueueInfo_param_value_size_ret(bool isCallValid, 998 cl_command_queue command_queue, 999 CommandQueueInfo param_namePacked, 1000 size_t param_value_size, 1001 void *param_value, 1002 size_t *param_value_size_ret, 1003 angle::ParamCapture *paramCapture); 1004 void CaptureCreateBuffer_host_ptr(bool isCallValid, 1005 cl_context context, 1006 MemFlags flagsPacked, 1007 size_t size, 1008 void *host_ptr, 1009 cl_int *errcode_ret, 1010 angle::ParamCapture *paramCapture); 1011 void CaptureCreateBuffer_errcode_ret(bool isCallValid, 1012 cl_context context, 1013 MemFlags flagsPacked, 1014 size_t size, 1015 void *host_ptr, 1016 cl_int *errcode_ret, 1017 angle::ParamCapture *paramCapture); 1018 void CaptureGetSupportedImageFormats_image_formats(bool isCallValid, 1019 cl_context context, 1020 MemFlags flagsPacked, 1021 MemObjectType image_typePacked, 1022 cl_uint num_entries, 1023 cl_image_format *image_formats, 1024 cl_uint *num_image_formats, 1025 angle::ParamCapture *paramCapture); 1026 void CaptureGetSupportedImageFormats_num_image_formats(bool isCallValid, 1027 cl_context context, 1028 MemFlags flagsPacked, 1029 MemObjectType image_typePacked, 1030 cl_uint num_entries, 1031 cl_image_format *image_formats, 1032 cl_uint *num_image_formats, 1033 angle::ParamCapture *paramCapture); 1034 void CaptureGetMemObjectInfo_param_value(bool isCallValid, 1035 cl_mem memobj, 1036 MemInfo param_namePacked, 1037 size_t param_value_size, 1038 void *param_value, 1039 size_t *param_value_size_ret, 1040 angle::ParamCapture *paramCapture); 1041 void CaptureGetMemObjectInfo_param_value_size_ret(bool isCallValid, 1042 cl_mem memobj, 1043 MemInfo param_namePacked, 1044 size_t param_value_size, 1045 void *param_value, 1046 size_t *param_value_size_ret, 1047 angle::ParamCapture *paramCapture); 1048 void CaptureGetImageInfo_param_value(bool isCallValid, 1049 cl_mem image, 1050 ImageInfo param_namePacked, 1051 size_t param_value_size, 1052 void *param_value, 1053 size_t *param_value_size_ret, 1054 angle::ParamCapture *paramCapture); 1055 void CaptureGetImageInfo_param_value_size_ret(bool isCallValid, 1056 cl_mem image, 1057 ImageInfo param_namePacked, 1058 size_t param_value_size, 1059 void *param_value, 1060 size_t *param_value_size_ret, 1061 angle::ParamCapture *paramCapture); 1062 void CaptureGetSamplerInfo_param_value(bool isCallValid, 1063 cl_sampler sampler, 1064 SamplerInfo param_namePacked, 1065 size_t param_value_size, 1066 void *param_value, 1067 size_t *param_value_size_ret, 1068 angle::ParamCapture *paramCapture); 1069 void CaptureGetSamplerInfo_param_value_size_ret(bool isCallValid, 1070 cl_sampler sampler, 1071 SamplerInfo param_namePacked, 1072 size_t param_value_size, 1073 void *param_value, 1074 size_t *param_value_size_ret, 1075 angle::ParamCapture *paramCapture); 1076 void CaptureCreateProgramWithSource_strings(bool isCallValid, 1077 cl_context context, 1078 cl_uint count, 1079 const char **strings, 1080 const size_t *lengths, 1081 cl_int *errcode_ret, 1082 angle::ParamCapture *paramCapture); 1083 void CaptureCreateProgramWithSource_lengths(bool isCallValid, 1084 cl_context context, 1085 cl_uint count, 1086 const char **strings, 1087 const size_t *lengths, 1088 cl_int *errcode_ret, 1089 angle::ParamCapture *paramCapture); 1090 void CaptureCreateProgramWithSource_errcode_ret(bool isCallValid, 1091 cl_context context, 1092 cl_uint count, 1093 const char **strings, 1094 const size_t *lengths, 1095 cl_int *errcode_ret, 1096 angle::ParamCapture *paramCapture); 1097 void CaptureCreateProgramWithBinary_device_list(bool isCallValid, 1098 cl_context context, 1099 cl_uint num_devices, 1100 const cl_device_id *device_list, 1101 const size_t *lengths, 1102 const unsigned char **binaries, 1103 cl_int *binary_status, 1104 cl_int *errcode_ret, 1105 angle::ParamCapture *paramCapture); 1106 void CaptureCreateProgramWithBinary_lengths(bool isCallValid, 1107 cl_context context, 1108 cl_uint num_devices, 1109 const cl_device_id *device_list, 1110 const size_t *lengths, 1111 const unsigned char **binaries, 1112 cl_int *binary_status, 1113 cl_int *errcode_ret, 1114 angle::ParamCapture *paramCapture); 1115 void CaptureCreateProgramWithBinary_binaries(bool isCallValid, 1116 cl_context context, 1117 cl_uint num_devices, 1118 const cl_device_id *device_list, 1119 const size_t *lengths, 1120 const unsigned char **binaries, 1121 cl_int *binary_status, 1122 cl_int *errcode_ret, 1123 angle::ParamCapture *paramCapture); 1124 void CaptureCreateProgramWithBinary_binary_status(bool isCallValid, 1125 cl_context context, 1126 cl_uint num_devices, 1127 const cl_device_id *device_list, 1128 const size_t *lengths, 1129 const unsigned char **binaries, 1130 cl_int *binary_status, 1131 cl_int *errcode_ret, 1132 angle::ParamCapture *paramCapture); 1133 void CaptureCreateProgramWithBinary_errcode_ret(bool isCallValid, 1134 cl_context context, 1135 cl_uint num_devices, 1136 const cl_device_id *device_list, 1137 const size_t *lengths, 1138 const unsigned char **binaries, 1139 cl_int *binary_status, 1140 cl_int *errcode_ret, 1141 angle::ParamCapture *paramCapture); 1142 void CaptureBuildProgram_device_list(bool isCallValid, 1143 cl_program program, 1144 cl_uint num_devices, 1145 const cl_device_id *device_list, 1146 const char *options, 1147 void(CL_CALLBACK *pfn_notify)(cl_program program, 1148 void *user_data), 1149 void *user_data, 1150 angle::ParamCapture *paramCapture); 1151 void CaptureBuildProgram_options(bool isCallValid, 1152 cl_program program, 1153 cl_uint num_devices, 1154 const cl_device_id *device_list, 1155 const char *options, 1156 void(CL_CALLBACK *pfn_notify)(cl_program program, void *user_data), 1157 void *user_data, 1158 angle::ParamCapture *paramCapture); 1159 void CaptureBuildProgram_pfn_notify(bool isCallValid, 1160 cl_program program, 1161 cl_uint num_devices, 1162 const cl_device_id *device_list, 1163 const char *options, 1164 void(CL_CALLBACK *pfn_notify)(cl_program program, 1165 void *user_data), 1166 void *user_data, 1167 angle::ParamCapture *paramCapture); 1168 void CaptureBuildProgram_user_data(bool isCallValid, 1169 cl_program program, 1170 cl_uint num_devices, 1171 const cl_device_id *device_list, 1172 const char *options, 1173 void(CL_CALLBACK *pfn_notify)(cl_program program, 1174 void *user_data), 1175 void *user_data, 1176 angle::ParamCapture *paramCapture); 1177 void CaptureGetProgramInfo_param_value(bool isCallValid, 1178 cl_program program, 1179 ProgramInfo param_namePacked, 1180 size_t param_value_size, 1181 void *param_value, 1182 size_t *param_value_size_ret, 1183 angle::ParamCapture *paramCapture); 1184 void CaptureGetProgramInfo_param_value_size_ret(bool isCallValid, 1185 cl_program program, 1186 ProgramInfo param_namePacked, 1187 size_t param_value_size, 1188 void *param_value, 1189 size_t *param_value_size_ret, 1190 angle::ParamCapture *paramCapture); 1191 void CaptureGetProgramBuildInfo_param_value(bool isCallValid, 1192 cl_program program, 1193 cl_device_id device, 1194 ProgramBuildInfo param_namePacked, 1195 size_t param_value_size, 1196 void *param_value, 1197 size_t *param_value_size_ret, 1198 angle::ParamCapture *paramCapture); 1199 void CaptureGetProgramBuildInfo_param_value_size_ret(bool isCallValid, 1200 cl_program program, 1201 cl_device_id device, 1202 ProgramBuildInfo param_namePacked, 1203 size_t param_value_size, 1204 void *param_value, 1205 size_t *param_value_size_ret, 1206 angle::ParamCapture *paramCapture); 1207 void CaptureCreateKernel_kernel_name(bool isCallValid, 1208 cl_program program, 1209 const char *kernel_name, 1210 cl_int *errcode_ret, 1211 angle::ParamCapture *paramCapture); 1212 void CaptureCreateKernel_errcode_ret(bool isCallValid, 1213 cl_program program, 1214 const char *kernel_name, 1215 cl_int *errcode_ret, 1216 angle::ParamCapture *paramCapture); 1217 void CaptureCreateKernelsInProgram_kernels(bool isCallValid, 1218 cl_program program, 1219 cl_uint num_kernels, 1220 cl_kernel *kernels, 1221 cl_uint *num_kernels_ret, 1222 angle::ParamCapture *paramCapture); 1223 void CaptureCreateKernelsInProgram_num_kernels_ret(bool isCallValid, 1224 cl_program program, 1225 cl_uint num_kernels, 1226 cl_kernel *kernels, 1227 cl_uint *num_kernels_ret, 1228 angle::ParamCapture *paramCapture); 1229 void CaptureSetKernelArg_arg_value(bool isCallValid, 1230 cl_kernel kernel, 1231 cl_uint arg_index, 1232 size_t arg_size, 1233 const void *arg_value, 1234 angle::ParamCapture *paramCapture); 1235 void CaptureGetKernelInfo_param_value(bool isCallValid, 1236 cl_kernel kernel, 1237 KernelInfo param_namePacked, 1238 size_t param_value_size, 1239 void *param_value, 1240 size_t *param_value_size_ret, 1241 angle::ParamCapture *paramCapture); 1242 void CaptureGetKernelInfo_param_value_size_ret(bool isCallValid, 1243 cl_kernel kernel, 1244 KernelInfo param_namePacked, 1245 size_t param_value_size, 1246 void *param_value, 1247 size_t *param_value_size_ret, 1248 angle::ParamCapture *paramCapture); 1249 void CaptureGetKernelWorkGroupInfo_param_value(bool isCallValid, 1250 cl_kernel kernel, 1251 cl_device_id device, 1252 KernelWorkGroupInfo param_namePacked, 1253 size_t param_value_size, 1254 void *param_value, 1255 size_t *param_value_size_ret, 1256 angle::ParamCapture *paramCapture); 1257 void CaptureGetKernelWorkGroupInfo_param_value_size_ret(bool isCallValid, 1258 cl_kernel kernel, 1259 cl_device_id device, 1260 KernelWorkGroupInfo param_namePacked, 1261 size_t param_value_size, 1262 void *param_value, 1263 size_t *param_value_size_ret, 1264 angle::ParamCapture *paramCapture); 1265 void CaptureWaitForEvents_event_list(bool isCallValid, 1266 cl_uint num_events, 1267 const cl_event *event_list, 1268 angle::ParamCapture *paramCapture); 1269 void CaptureGetEventInfo_param_value(bool isCallValid, 1270 cl_event event, 1271 EventInfo param_namePacked, 1272 size_t param_value_size, 1273 void *param_value, 1274 size_t *param_value_size_ret, 1275 angle::ParamCapture *paramCapture); 1276 void CaptureGetEventInfo_param_value_size_ret(bool isCallValid, 1277 cl_event event, 1278 EventInfo param_namePacked, 1279 size_t param_value_size, 1280 void *param_value, 1281 size_t *param_value_size_ret, 1282 angle::ParamCapture *paramCapture); 1283 void CaptureGetEventProfilingInfo_param_value(bool isCallValid, 1284 cl_event event, 1285 ProfilingInfo param_namePacked, 1286 size_t param_value_size, 1287 void *param_value, 1288 size_t *param_value_size_ret, 1289 angle::ParamCapture *paramCapture); 1290 void CaptureGetEventProfilingInfo_param_value_size_ret(bool isCallValid, 1291 cl_event event, 1292 ProfilingInfo param_namePacked, 1293 size_t param_value_size, 1294 void *param_value, 1295 size_t *param_value_size_ret, 1296 angle::ParamCapture *paramCapture); 1297 void CaptureEnqueueReadBuffer_ptr(bool isCallValid, 1298 cl_command_queue command_queue, 1299 cl_mem buffer, 1300 cl_bool blocking_read, 1301 size_t offset, 1302 size_t size, 1303 void *ptr, 1304 cl_uint num_events_in_wait_list, 1305 const cl_event *event_wait_list, 1306 cl_event *event, 1307 angle::ParamCapture *paramCapture); 1308 void CaptureEnqueueReadBuffer_event_wait_list(bool isCallValid, 1309 cl_command_queue command_queue, 1310 cl_mem buffer, 1311 cl_bool blocking_read, 1312 size_t offset, 1313 size_t size, 1314 void *ptr, 1315 cl_uint num_events_in_wait_list, 1316 const cl_event *event_wait_list, 1317 cl_event *event, 1318 angle::ParamCapture *paramCapture); 1319 void CaptureEnqueueReadBuffer_event(bool isCallValid, 1320 cl_command_queue command_queue, 1321 cl_mem buffer, 1322 cl_bool blocking_read, 1323 size_t offset, 1324 size_t size, 1325 void *ptr, 1326 cl_uint num_events_in_wait_list, 1327 const cl_event *event_wait_list, 1328 cl_event *event, 1329 angle::ParamCapture *paramCapture); 1330 void CaptureEnqueueWriteBuffer_ptr(bool isCallValid, 1331 cl_command_queue command_queue, 1332 cl_mem buffer, 1333 cl_bool blocking_write, 1334 size_t offset, 1335 size_t size, 1336 const void *ptr, 1337 cl_uint num_events_in_wait_list, 1338 const cl_event *event_wait_list, 1339 cl_event *event, 1340 angle::ParamCapture *paramCapture); 1341 void CaptureEnqueueWriteBuffer_event_wait_list(bool isCallValid, 1342 cl_command_queue command_queue, 1343 cl_mem buffer, 1344 cl_bool blocking_write, 1345 size_t offset, 1346 size_t size, 1347 const void *ptr, 1348 cl_uint num_events_in_wait_list, 1349 const cl_event *event_wait_list, 1350 cl_event *event, 1351 angle::ParamCapture *paramCapture); 1352 void CaptureEnqueueWriteBuffer_event(bool isCallValid, 1353 cl_command_queue command_queue, 1354 cl_mem buffer, 1355 cl_bool blocking_write, 1356 size_t offset, 1357 size_t size, 1358 const void *ptr, 1359 cl_uint num_events_in_wait_list, 1360 const cl_event *event_wait_list, 1361 cl_event *event, 1362 angle::ParamCapture *paramCapture); 1363 void CaptureEnqueueCopyBuffer_event_wait_list(bool isCallValid, 1364 cl_command_queue command_queue, 1365 cl_mem src_buffer, 1366 cl_mem dst_buffer, 1367 size_t src_offset, 1368 size_t dst_offset, 1369 size_t size, 1370 cl_uint num_events_in_wait_list, 1371 const cl_event *event_wait_list, 1372 cl_event *event, 1373 angle::ParamCapture *paramCapture); 1374 void CaptureEnqueueCopyBuffer_event(bool isCallValid, 1375 cl_command_queue command_queue, 1376 cl_mem src_buffer, 1377 cl_mem dst_buffer, 1378 size_t src_offset, 1379 size_t dst_offset, 1380 size_t size, 1381 cl_uint num_events_in_wait_list, 1382 const cl_event *event_wait_list, 1383 cl_event *event, 1384 angle::ParamCapture *paramCapture); 1385 void CaptureEnqueueReadImage_origin(bool isCallValid, 1386 cl_command_queue command_queue, 1387 cl_mem image, 1388 cl_bool blocking_read, 1389 const size_t *origin, 1390 const size_t *region, 1391 size_t row_pitch, 1392 size_t slice_pitch, 1393 void *ptr, 1394 cl_uint num_events_in_wait_list, 1395 const cl_event *event_wait_list, 1396 cl_event *event, 1397 angle::ParamCapture *paramCapture); 1398 void CaptureEnqueueReadImage_region(bool isCallValid, 1399 cl_command_queue command_queue, 1400 cl_mem image, 1401 cl_bool blocking_read, 1402 const size_t *origin, 1403 const size_t *region, 1404 size_t row_pitch, 1405 size_t slice_pitch, 1406 void *ptr, 1407 cl_uint num_events_in_wait_list, 1408 const cl_event *event_wait_list, 1409 cl_event *event, 1410 angle::ParamCapture *paramCapture); 1411 void CaptureEnqueueReadImage_ptr(bool isCallValid, 1412 cl_command_queue command_queue, 1413 cl_mem image, 1414 cl_bool blocking_read, 1415 const size_t *origin, 1416 const size_t *region, 1417 size_t row_pitch, 1418 size_t slice_pitch, 1419 void *ptr, 1420 cl_uint num_events_in_wait_list, 1421 const cl_event *event_wait_list, 1422 cl_event *event, 1423 angle::ParamCapture *paramCapture); 1424 void CaptureEnqueueReadImage_event_wait_list(bool isCallValid, 1425 cl_command_queue command_queue, 1426 cl_mem image, 1427 cl_bool blocking_read, 1428 const size_t *origin, 1429 const size_t *region, 1430 size_t row_pitch, 1431 size_t slice_pitch, 1432 void *ptr, 1433 cl_uint num_events_in_wait_list, 1434 const cl_event *event_wait_list, 1435 cl_event *event, 1436 angle::ParamCapture *paramCapture); 1437 void CaptureEnqueueReadImage_event(bool isCallValid, 1438 cl_command_queue command_queue, 1439 cl_mem image, 1440 cl_bool blocking_read, 1441 const size_t *origin, 1442 const size_t *region, 1443 size_t row_pitch, 1444 size_t slice_pitch, 1445 void *ptr, 1446 cl_uint num_events_in_wait_list, 1447 const cl_event *event_wait_list, 1448 cl_event *event, 1449 angle::ParamCapture *paramCapture); 1450 void CaptureEnqueueWriteImage_origin(bool isCallValid, 1451 cl_command_queue command_queue, 1452 cl_mem image, 1453 cl_bool blocking_write, 1454 const size_t *origin, 1455 const size_t *region, 1456 size_t input_row_pitch, 1457 size_t input_slice_pitch, 1458 const void *ptr, 1459 cl_uint num_events_in_wait_list, 1460 const cl_event *event_wait_list, 1461 cl_event *event, 1462 angle::ParamCapture *paramCapture); 1463 void CaptureEnqueueWriteImage_region(bool isCallValid, 1464 cl_command_queue command_queue, 1465 cl_mem image, 1466 cl_bool blocking_write, 1467 const size_t *origin, 1468 const size_t *region, 1469 size_t input_row_pitch, 1470 size_t input_slice_pitch, 1471 const void *ptr, 1472 cl_uint num_events_in_wait_list, 1473 const cl_event *event_wait_list, 1474 cl_event *event, 1475 angle::ParamCapture *paramCapture); 1476 void CaptureEnqueueWriteImage_ptr(bool isCallValid, 1477 cl_command_queue command_queue, 1478 cl_mem image, 1479 cl_bool blocking_write, 1480 const size_t *origin, 1481 const size_t *region, 1482 size_t input_row_pitch, 1483 size_t input_slice_pitch, 1484 const void *ptr, 1485 cl_uint num_events_in_wait_list, 1486 const cl_event *event_wait_list, 1487 cl_event *event, 1488 angle::ParamCapture *paramCapture); 1489 void CaptureEnqueueWriteImage_event_wait_list(bool isCallValid, 1490 cl_command_queue command_queue, 1491 cl_mem image, 1492 cl_bool blocking_write, 1493 const size_t *origin, 1494 const size_t *region, 1495 size_t input_row_pitch, 1496 size_t input_slice_pitch, 1497 const void *ptr, 1498 cl_uint num_events_in_wait_list, 1499 const cl_event *event_wait_list, 1500 cl_event *event, 1501 angle::ParamCapture *paramCapture); 1502 void CaptureEnqueueWriteImage_event(bool isCallValid, 1503 cl_command_queue command_queue, 1504 cl_mem image, 1505 cl_bool blocking_write, 1506 const size_t *origin, 1507 const size_t *region, 1508 size_t input_row_pitch, 1509 size_t input_slice_pitch, 1510 const void *ptr, 1511 cl_uint num_events_in_wait_list, 1512 const cl_event *event_wait_list, 1513 cl_event *event, 1514 angle::ParamCapture *paramCapture); 1515 void CaptureEnqueueCopyImage_src_origin(bool isCallValid, 1516 cl_command_queue command_queue, 1517 cl_mem src_image, 1518 cl_mem dst_image, 1519 const size_t *src_origin, 1520 const size_t *dst_origin, 1521 const size_t *region, 1522 cl_uint num_events_in_wait_list, 1523 const cl_event *event_wait_list, 1524 cl_event *event, 1525 angle::ParamCapture *paramCapture); 1526 void CaptureEnqueueCopyImage_dst_origin(bool isCallValid, 1527 cl_command_queue command_queue, 1528 cl_mem src_image, 1529 cl_mem dst_image, 1530 const size_t *src_origin, 1531 const size_t *dst_origin, 1532 const size_t *region, 1533 cl_uint num_events_in_wait_list, 1534 const cl_event *event_wait_list, 1535 cl_event *event, 1536 angle::ParamCapture *paramCapture); 1537 void CaptureEnqueueCopyImage_region(bool isCallValid, 1538 cl_command_queue command_queue, 1539 cl_mem src_image, 1540 cl_mem dst_image, 1541 const size_t *src_origin, 1542 const size_t *dst_origin, 1543 const size_t *region, 1544 cl_uint num_events_in_wait_list, 1545 const cl_event *event_wait_list, 1546 cl_event *event, 1547 angle::ParamCapture *paramCapture); 1548 void CaptureEnqueueCopyImage_event_wait_list(bool isCallValid, 1549 cl_command_queue command_queue, 1550 cl_mem src_image, 1551 cl_mem dst_image, 1552 const size_t *src_origin, 1553 const size_t *dst_origin, 1554 const size_t *region, 1555 cl_uint num_events_in_wait_list, 1556 const cl_event *event_wait_list, 1557 cl_event *event, 1558 angle::ParamCapture *paramCapture); 1559 void CaptureEnqueueCopyImage_event(bool isCallValid, 1560 cl_command_queue command_queue, 1561 cl_mem src_image, 1562 cl_mem dst_image, 1563 const size_t *src_origin, 1564 const size_t *dst_origin, 1565 const size_t *region, 1566 cl_uint num_events_in_wait_list, 1567 const cl_event *event_wait_list, 1568 cl_event *event, 1569 angle::ParamCapture *paramCapture); 1570 void CaptureEnqueueCopyImageToBuffer_src_origin(bool isCallValid, 1571 cl_command_queue command_queue, 1572 cl_mem src_image, 1573 cl_mem dst_buffer, 1574 const size_t *src_origin, 1575 const size_t *region, 1576 size_t dst_offset, 1577 cl_uint num_events_in_wait_list, 1578 const cl_event *event_wait_list, 1579 cl_event *event, 1580 angle::ParamCapture *paramCapture); 1581 void CaptureEnqueueCopyImageToBuffer_region(bool isCallValid, 1582 cl_command_queue command_queue, 1583 cl_mem src_image, 1584 cl_mem dst_buffer, 1585 const size_t *src_origin, 1586 const size_t *region, 1587 size_t dst_offset, 1588 cl_uint num_events_in_wait_list, 1589 const cl_event *event_wait_list, 1590 cl_event *event, 1591 angle::ParamCapture *paramCapture); 1592 void CaptureEnqueueCopyImageToBuffer_event_wait_list(bool isCallValid, 1593 cl_command_queue command_queue, 1594 cl_mem src_image, 1595 cl_mem dst_buffer, 1596 const size_t *src_origin, 1597 const size_t *region, 1598 size_t dst_offset, 1599 cl_uint num_events_in_wait_list, 1600 const cl_event *event_wait_list, 1601 cl_event *event, 1602 angle::ParamCapture *paramCapture); 1603 void CaptureEnqueueCopyImageToBuffer_event(bool isCallValid, 1604 cl_command_queue command_queue, 1605 cl_mem src_image, 1606 cl_mem dst_buffer, 1607 const size_t *src_origin, 1608 const size_t *region, 1609 size_t dst_offset, 1610 cl_uint num_events_in_wait_list, 1611 const cl_event *event_wait_list, 1612 cl_event *event, 1613 angle::ParamCapture *paramCapture); 1614 void CaptureEnqueueCopyBufferToImage_dst_origin(bool isCallValid, 1615 cl_command_queue command_queue, 1616 cl_mem src_buffer, 1617 cl_mem dst_image, 1618 size_t src_offset, 1619 const size_t *dst_origin, 1620 const size_t *region, 1621 cl_uint num_events_in_wait_list, 1622 const cl_event *event_wait_list, 1623 cl_event *event, 1624 angle::ParamCapture *paramCapture); 1625 void CaptureEnqueueCopyBufferToImage_region(bool isCallValid, 1626 cl_command_queue command_queue, 1627 cl_mem src_buffer, 1628 cl_mem dst_image, 1629 size_t src_offset, 1630 const size_t *dst_origin, 1631 const size_t *region, 1632 cl_uint num_events_in_wait_list, 1633 const cl_event *event_wait_list, 1634 cl_event *event, 1635 angle::ParamCapture *paramCapture); 1636 void CaptureEnqueueCopyBufferToImage_event_wait_list(bool isCallValid, 1637 cl_command_queue command_queue, 1638 cl_mem src_buffer, 1639 cl_mem dst_image, 1640 size_t src_offset, 1641 const size_t *dst_origin, 1642 const size_t *region, 1643 cl_uint num_events_in_wait_list, 1644 const cl_event *event_wait_list, 1645 cl_event *event, 1646 angle::ParamCapture *paramCapture); 1647 void CaptureEnqueueCopyBufferToImage_event(bool isCallValid, 1648 cl_command_queue command_queue, 1649 cl_mem src_buffer, 1650 cl_mem dst_image, 1651 size_t src_offset, 1652 const size_t *dst_origin, 1653 const size_t *region, 1654 cl_uint num_events_in_wait_list, 1655 const cl_event *event_wait_list, 1656 cl_event *event, 1657 angle::ParamCapture *paramCapture); 1658 void CaptureEnqueueMapBuffer_event_wait_list(bool isCallValid, 1659 cl_command_queue command_queue, 1660 cl_mem buffer, 1661 cl_bool blocking_map, 1662 MapFlags map_flagsPacked, 1663 size_t offset, 1664 size_t size, 1665 cl_uint num_events_in_wait_list, 1666 const cl_event *event_wait_list, 1667 cl_event *event, 1668 cl_int *errcode_ret, 1669 angle::ParamCapture *paramCapture); 1670 void CaptureEnqueueMapBuffer_event(bool isCallValid, 1671 cl_command_queue command_queue, 1672 cl_mem buffer, 1673 cl_bool blocking_map, 1674 MapFlags map_flagsPacked, 1675 size_t offset, 1676 size_t size, 1677 cl_uint num_events_in_wait_list, 1678 const cl_event *event_wait_list, 1679 cl_event *event, 1680 cl_int *errcode_ret, 1681 angle::ParamCapture *paramCapture); 1682 void CaptureEnqueueMapBuffer_errcode_ret(bool isCallValid, 1683 cl_command_queue command_queue, 1684 cl_mem buffer, 1685 cl_bool blocking_map, 1686 MapFlags map_flagsPacked, 1687 size_t offset, 1688 size_t size, 1689 cl_uint num_events_in_wait_list, 1690 const cl_event *event_wait_list, 1691 cl_event *event, 1692 cl_int *errcode_ret, 1693 angle::ParamCapture *paramCapture); 1694 void CaptureEnqueueMapImage_origin(bool isCallValid, 1695 cl_command_queue command_queue, 1696 cl_mem image, 1697 cl_bool blocking_map, 1698 MapFlags map_flagsPacked, 1699 const size_t *origin, 1700 const size_t *region, 1701 size_t *image_row_pitch, 1702 size_t *image_slice_pitch, 1703 cl_uint num_events_in_wait_list, 1704 const cl_event *event_wait_list, 1705 cl_event *event, 1706 cl_int *errcode_ret, 1707 angle::ParamCapture *paramCapture); 1708 void CaptureEnqueueMapImage_region(bool isCallValid, 1709 cl_command_queue command_queue, 1710 cl_mem image, 1711 cl_bool blocking_map, 1712 MapFlags map_flagsPacked, 1713 const size_t *origin, 1714 const size_t *region, 1715 size_t *image_row_pitch, 1716 size_t *image_slice_pitch, 1717 cl_uint num_events_in_wait_list, 1718 const cl_event *event_wait_list, 1719 cl_event *event, 1720 cl_int *errcode_ret, 1721 angle::ParamCapture *paramCapture); 1722 void CaptureEnqueueMapImage_image_row_pitch(bool isCallValid, 1723 cl_command_queue command_queue, 1724 cl_mem image, 1725 cl_bool blocking_map, 1726 MapFlags map_flagsPacked, 1727 const size_t *origin, 1728 const size_t *region, 1729 size_t *image_row_pitch, 1730 size_t *image_slice_pitch, 1731 cl_uint num_events_in_wait_list, 1732 const cl_event *event_wait_list, 1733 cl_event *event, 1734 cl_int *errcode_ret, 1735 angle::ParamCapture *paramCapture); 1736 void CaptureEnqueueMapImage_image_slice_pitch(bool isCallValid, 1737 cl_command_queue command_queue, 1738 cl_mem image, 1739 cl_bool blocking_map, 1740 MapFlags map_flagsPacked, 1741 const size_t *origin, 1742 const size_t *region, 1743 size_t *image_row_pitch, 1744 size_t *image_slice_pitch, 1745 cl_uint num_events_in_wait_list, 1746 const cl_event *event_wait_list, 1747 cl_event *event, 1748 cl_int *errcode_ret, 1749 angle::ParamCapture *paramCapture); 1750 void CaptureEnqueueMapImage_event_wait_list(bool isCallValid, 1751 cl_command_queue command_queue, 1752 cl_mem image, 1753 cl_bool blocking_map, 1754 MapFlags map_flagsPacked, 1755 const size_t *origin, 1756 const size_t *region, 1757 size_t *image_row_pitch, 1758 size_t *image_slice_pitch, 1759 cl_uint num_events_in_wait_list, 1760 const cl_event *event_wait_list, 1761 cl_event *event, 1762 cl_int *errcode_ret, 1763 angle::ParamCapture *paramCapture); 1764 void CaptureEnqueueMapImage_event(bool isCallValid, 1765 cl_command_queue command_queue, 1766 cl_mem image, 1767 cl_bool blocking_map, 1768 MapFlags map_flagsPacked, 1769 const size_t *origin, 1770 const size_t *region, 1771 size_t *image_row_pitch, 1772 size_t *image_slice_pitch, 1773 cl_uint num_events_in_wait_list, 1774 const cl_event *event_wait_list, 1775 cl_event *event, 1776 cl_int *errcode_ret, 1777 angle::ParamCapture *paramCapture); 1778 void CaptureEnqueueMapImage_errcode_ret(bool isCallValid, 1779 cl_command_queue command_queue, 1780 cl_mem image, 1781 cl_bool blocking_map, 1782 MapFlags map_flagsPacked, 1783 const size_t *origin, 1784 const size_t *region, 1785 size_t *image_row_pitch, 1786 size_t *image_slice_pitch, 1787 cl_uint num_events_in_wait_list, 1788 const cl_event *event_wait_list, 1789 cl_event *event, 1790 cl_int *errcode_ret, 1791 angle::ParamCapture *paramCapture); 1792 void CaptureEnqueueUnmapMemObject_mapped_ptr(bool isCallValid, 1793 cl_command_queue command_queue, 1794 cl_mem memobj, 1795 void *mapped_ptr, 1796 cl_uint num_events_in_wait_list, 1797 const cl_event *event_wait_list, 1798 cl_event *event, 1799 angle::ParamCapture *paramCapture); 1800 void CaptureEnqueueUnmapMemObject_event_wait_list(bool isCallValid, 1801 cl_command_queue command_queue, 1802 cl_mem memobj, 1803 void *mapped_ptr, 1804 cl_uint num_events_in_wait_list, 1805 const cl_event *event_wait_list, 1806 cl_event *event, 1807 angle::ParamCapture *paramCapture); 1808 void CaptureEnqueueUnmapMemObject_event(bool isCallValid, 1809 cl_command_queue command_queue, 1810 cl_mem memobj, 1811 void *mapped_ptr, 1812 cl_uint num_events_in_wait_list, 1813 const cl_event *event_wait_list, 1814 cl_event *event, 1815 angle::ParamCapture *paramCapture); 1816 void CaptureEnqueueNDRangeKernel_global_work_offset(bool isCallValid, 1817 cl_command_queue command_queue, 1818 cl_kernel kernel, 1819 cl_uint work_dim, 1820 const size_t *global_work_offset, 1821 const size_t *global_work_size, 1822 const size_t *local_work_size, 1823 cl_uint num_events_in_wait_list, 1824 const cl_event *event_wait_list, 1825 cl_event *event, 1826 angle::ParamCapture *paramCapture); 1827 void CaptureEnqueueNDRangeKernel_global_work_size(bool isCallValid, 1828 cl_command_queue command_queue, 1829 cl_kernel kernel, 1830 cl_uint work_dim, 1831 const size_t *global_work_offset, 1832 const size_t *global_work_size, 1833 const size_t *local_work_size, 1834 cl_uint num_events_in_wait_list, 1835 const cl_event *event_wait_list, 1836 cl_event *event, 1837 angle::ParamCapture *paramCapture); 1838 void CaptureEnqueueNDRangeKernel_local_work_size(bool isCallValid, 1839 cl_command_queue command_queue, 1840 cl_kernel kernel, 1841 cl_uint work_dim, 1842 const size_t *global_work_offset, 1843 const size_t *global_work_size, 1844 const size_t *local_work_size, 1845 cl_uint num_events_in_wait_list, 1846 const cl_event *event_wait_list, 1847 cl_event *event, 1848 angle::ParamCapture *paramCapture); 1849 void CaptureEnqueueNDRangeKernel_event_wait_list(bool isCallValid, 1850 cl_command_queue command_queue, 1851 cl_kernel kernel, 1852 cl_uint work_dim, 1853 const size_t *global_work_offset, 1854 const size_t *global_work_size, 1855 const size_t *local_work_size, 1856 cl_uint num_events_in_wait_list, 1857 const cl_event *event_wait_list, 1858 cl_event *event, 1859 angle::ParamCapture *paramCapture); 1860 void CaptureEnqueueNDRangeKernel_event(bool isCallValid, 1861 cl_command_queue command_queue, 1862 cl_kernel kernel, 1863 cl_uint work_dim, 1864 const size_t *global_work_offset, 1865 const size_t *global_work_size, 1866 const size_t *local_work_size, 1867 cl_uint num_events_in_wait_list, 1868 const cl_event *event_wait_list, 1869 cl_event *event, 1870 angle::ParamCapture *paramCapture); 1871 void CaptureEnqueueNativeKernel_user_func(bool isCallValid, 1872 cl_command_queue command_queue, 1873 void(CL_CALLBACK *user_func)(void *), 1874 void *args, 1875 size_t cb_args, 1876 cl_uint num_mem_objects, 1877 const cl_mem *mem_list, 1878 const void **args_mem_loc, 1879 cl_uint num_events_in_wait_list, 1880 const cl_event *event_wait_list, 1881 cl_event *event, 1882 angle::ParamCapture *paramCapture); 1883 void CaptureEnqueueNativeKernel_args(bool isCallValid, 1884 cl_command_queue command_queue, 1885 void(CL_CALLBACK *user_func)(void *), 1886 void *args, 1887 size_t cb_args, 1888 cl_uint num_mem_objects, 1889 const cl_mem *mem_list, 1890 const void **args_mem_loc, 1891 cl_uint num_events_in_wait_list, 1892 const cl_event *event_wait_list, 1893 cl_event *event, 1894 angle::ParamCapture *paramCapture); 1895 void CaptureEnqueueNativeKernel_mem_list(bool isCallValid, 1896 cl_command_queue command_queue, 1897 void(CL_CALLBACK *user_func)(void *), 1898 void *args, 1899 size_t cb_args, 1900 cl_uint num_mem_objects, 1901 const cl_mem *mem_list, 1902 const void **args_mem_loc, 1903 cl_uint num_events_in_wait_list, 1904 const cl_event *event_wait_list, 1905 cl_event *event, 1906 angle::ParamCapture *paramCapture); 1907 void CaptureEnqueueNativeKernel_args_mem_loc(bool isCallValid, 1908 cl_command_queue command_queue, 1909 void(CL_CALLBACK *user_func)(void *), 1910 void *args, 1911 size_t cb_args, 1912 cl_uint num_mem_objects, 1913 const cl_mem *mem_list, 1914 const void **args_mem_loc, 1915 cl_uint num_events_in_wait_list, 1916 const cl_event *event_wait_list, 1917 cl_event *event, 1918 angle::ParamCapture *paramCapture); 1919 void CaptureEnqueueNativeKernel_event_wait_list(bool isCallValid, 1920 cl_command_queue command_queue, 1921 void(CL_CALLBACK *user_func)(void *), 1922 void *args, 1923 size_t cb_args, 1924 cl_uint num_mem_objects, 1925 const cl_mem *mem_list, 1926 const void **args_mem_loc, 1927 cl_uint num_events_in_wait_list, 1928 const cl_event *event_wait_list, 1929 cl_event *event, 1930 angle::ParamCapture *paramCapture); 1931 void CaptureEnqueueNativeKernel_event(bool isCallValid, 1932 cl_command_queue command_queue, 1933 void(CL_CALLBACK *user_func)(void *), 1934 void *args, 1935 size_t cb_args, 1936 cl_uint num_mem_objects, 1937 const cl_mem *mem_list, 1938 const void **args_mem_loc, 1939 cl_uint num_events_in_wait_list, 1940 const cl_event *event_wait_list, 1941 cl_event *event, 1942 angle::ParamCapture *paramCapture); 1943 void CaptureSetCommandQueueProperty_old_properties(bool isCallValid, 1944 cl_command_queue command_queue, 1945 CommandQueueProperties propertiesPacked, 1946 cl_bool enable, 1947 cl_command_queue_properties *old_properties, 1948 angle::ParamCapture *paramCapture); 1949 void CaptureCreateImage2D_image_format(bool isCallValid, 1950 cl_context context, 1951 MemFlags flagsPacked, 1952 const cl_image_format *image_format, 1953 size_t image_width, 1954 size_t image_height, 1955 size_t image_row_pitch, 1956 void *host_ptr, 1957 cl_int *errcode_ret, 1958 angle::ParamCapture *paramCapture); 1959 void CaptureCreateImage2D_host_ptr(bool isCallValid, 1960 cl_context context, 1961 MemFlags flagsPacked, 1962 const cl_image_format *image_format, 1963 size_t image_width, 1964 size_t image_height, 1965 size_t image_row_pitch, 1966 void *host_ptr, 1967 cl_int *errcode_ret, 1968 angle::ParamCapture *paramCapture); 1969 void CaptureCreateImage2D_errcode_ret(bool isCallValid, 1970 cl_context context, 1971 MemFlags flagsPacked, 1972 const cl_image_format *image_format, 1973 size_t image_width, 1974 size_t image_height, 1975 size_t image_row_pitch, 1976 void *host_ptr, 1977 cl_int *errcode_ret, 1978 angle::ParamCapture *paramCapture); 1979 void CaptureCreateImage3D_image_format(bool isCallValid, 1980 cl_context context, 1981 MemFlags flagsPacked, 1982 const cl_image_format *image_format, 1983 size_t image_width, 1984 size_t image_height, 1985 size_t image_depth, 1986 size_t image_row_pitch, 1987 size_t image_slice_pitch, 1988 void *host_ptr, 1989 cl_int *errcode_ret, 1990 angle::ParamCapture *paramCapture); 1991 void CaptureCreateImage3D_host_ptr(bool isCallValid, 1992 cl_context context, 1993 MemFlags flagsPacked, 1994 const cl_image_format *image_format, 1995 size_t image_width, 1996 size_t image_height, 1997 size_t image_depth, 1998 size_t image_row_pitch, 1999 size_t image_slice_pitch, 2000 void *host_ptr, 2001 cl_int *errcode_ret, 2002 angle::ParamCapture *paramCapture); 2003 void CaptureCreateImage3D_errcode_ret(bool isCallValid, 2004 cl_context context, 2005 MemFlags flagsPacked, 2006 const cl_image_format *image_format, 2007 size_t image_width, 2008 size_t image_height, 2009 size_t image_depth, 2010 size_t image_row_pitch, 2011 size_t image_slice_pitch, 2012 void *host_ptr, 2013 cl_int *errcode_ret, 2014 angle::ParamCapture *paramCapture); 2015 void CaptureEnqueueMarker_event(bool isCallValid, 2016 cl_command_queue command_queue, 2017 cl_event *event, 2018 angle::ParamCapture *paramCapture); 2019 void CaptureEnqueueWaitForEvents_event_list(bool isCallValid, 2020 cl_command_queue command_queue, 2021 cl_uint num_events, 2022 const cl_event *event_list, 2023 angle::ParamCapture *paramCapture); 2024 void CaptureGetExtensionFunctionAddress_func_name(bool isCallValid, 2025 const char *func_name, 2026 angle::ParamCapture *paramCapture); 2027 void CaptureCreateCommandQueue_errcode_ret(bool isCallValid, 2028 cl_context context, 2029 cl_device_id device, 2030 CommandQueueProperties propertiesPacked, 2031 cl_int *errcode_ret, 2032 angle::ParamCapture *paramCapture); 2033 void CaptureCreateSampler_errcode_ret(bool isCallValid, 2034 cl_context context, 2035 cl_bool normalized_coords, 2036 AddressingMode addressing_modePacked, 2037 FilterMode filter_modePacked, 2038 cl_int *errcode_ret, 2039 angle::ParamCapture *paramCapture); 2040 void CaptureEnqueueTask_event_wait_list(bool isCallValid, 2041 cl_command_queue command_queue, 2042 cl_kernel kernel, 2043 cl_uint num_events_in_wait_list, 2044 const cl_event *event_wait_list, 2045 cl_event *event, 2046 angle::ParamCapture *paramCapture); 2047 void CaptureEnqueueTask_event(bool isCallValid, 2048 cl_command_queue command_queue, 2049 cl_kernel kernel, 2050 cl_uint num_events_in_wait_list, 2051 const cl_event *event_wait_list, 2052 cl_event *event, 2053 angle::ParamCapture *paramCapture); 2054 2055 // CL 1.1 2056 void CaptureCreateSubBuffer_buffer_create_info(bool isCallValid, 2057 cl_mem buffer, 2058 MemFlags flagsPacked, 2059 cl_buffer_create_type buffer_create_type, 2060 const void *buffer_create_info, 2061 cl_int *errcode_ret, 2062 angle::ParamCapture *paramCapture); 2063 void CaptureCreateSubBuffer_errcode_ret(bool isCallValid, 2064 cl_mem buffer, 2065 MemFlags flagsPacked, 2066 cl_buffer_create_type buffer_create_type, 2067 const void *buffer_create_info, 2068 cl_int *errcode_ret, 2069 angle::ParamCapture *paramCapture); 2070 void CaptureSetMemObjectDestructorCallback_pfn_notify( 2071 bool isCallValid, 2072 cl_mem memobj, 2073 void(CL_CALLBACK *pfn_notify)(cl_mem memobj, void *user_data), 2074 void *user_data, 2075 angle::ParamCapture *paramCapture); 2076 void CaptureSetMemObjectDestructorCallback_user_data(bool isCallValid, 2077 cl_mem memobj, 2078 void(CL_CALLBACK *pfn_notify)(cl_mem memobj, 2079 void *user_data), 2080 void *user_data, 2081 angle::ParamCapture *paramCapture); 2082 void CaptureCreateUserEvent_errcode_ret(bool isCallValid, 2083 cl_context context, 2084 cl_int *errcode_ret, 2085 angle::ParamCapture *paramCapture); 2086 void CaptureSetEventCallback_pfn_notify(bool isCallValid, 2087 cl_event event, 2088 cl_int command_exec_callback_type, 2089 void(CL_CALLBACK *pfn_notify)(cl_event event, 2090 cl_int event_command_status, 2091 void *user_data), 2092 void *user_data, 2093 angle::ParamCapture *paramCapture); 2094 void CaptureSetEventCallback_user_data(bool isCallValid, 2095 cl_event event, 2096 cl_int command_exec_callback_type, 2097 void(CL_CALLBACK *pfn_notify)(cl_event event, 2098 cl_int event_command_status, 2099 void *user_data), 2100 void *user_data, 2101 angle::ParamCapture *paramCapture); 2102 void CaptureEnqueueReadBufferRect_buffer_origin(bool isCallValid, 2103 cl_command_queue command_queue, 2104 cl_mem buffer, 2105 cl_bool blocking_read, 2106 const size_t *buffer_origin, 2107 const size_t *host_origin, 2108 const size_t *region, 2109 size_t buffer_row_pitch, 2110 size_t buffer_slice_pitch, 2111 size_t host_row_pitch, 2112 size_t host_slice_pitch, 2113 void *ptr, 2114 cl_uint num_events_in_wait_list, 2115 const cl_event *event_wait_list, 2116 cl_event *event, 2117 angle::ParamCapture *paramCapture); 2118 void CaptureEnqueueReadBufferRect_host_origin(bool isCallValid, 2119 cl_command_queue command_queue, 2120 cl_mem buffer, 2121 cl_bool blocking_read, 2122 const size_t *buffer_origin, 2123 const size_t *host_origin, 2124 const size_t *region, 2125 size_t buffer_row_pitch, 2126 size_t buffer_slice_pitch, 2127 size_t host_row_pitch, 2128 size_t host_slice_pitch, 2129 void *ptr, 2130 cl_uint num_events_in_wait_list, 2131 const cl_event *event_wait_list, 2132 cl_event *event, 2133 angle::ParamCapture *paramCapture); 2134 void CaptureEnqueueReadBufferRect_region(bool isCallValid, 2135 cl_command_queue command_queue, 2136 cl_mem buffer, 2137 cl_bool blocking_read, 2138 const size_t *buffer_origin, 2139 const size_t *host_origin, 2140 const size_t *region, 2141 size_t buffer_row_pitch, 2142 size_t buffer_slice_pitch, 2143 size_t host_row_pitch, 2144 size_t host_slice_pitch, 2145 void *ptr, 2146 cl_uint num_events_in_wait_list, 2147 const cl_event *event_wait_list, 2148 cl_event *event, 2149 angle::ParamCapture *paramCapture); 2150 void CaptureEnqueueReadBufferRect_ptr(bool isCallValid, 2151 cl_command_queue command_queue, 2152 cl_mem buffer, 2153 cl_bool blocking_read, 2154 const size_t *buffer_origin, 2155 const size_t *host_origin, 2156 const size_t *region, 2157 size_t buffer_row_pitch, 2158 size_t buffer_slice_pitch, 2159 size_t host_row_pitch, 2160 size_t host_slice_pitch, 2161 void *ptr, 2162 cl_uint num_events_in_wait_list, 2163 const cl_event *event_wait_list, 2164 cl_event *event, 2165 angle::ParamCapture *paramCapture); 2166 void CaptureEnqueueReadBufferRect_event_wait_list(bool isCallValid, 2167 cl_command_queue command_queue, 2168 cl_mem buffer, 2169 cl_bool blocking_read, 2170 const size_t *buffer_origin, 2171 const size_t *host_origin, 2172 const size_t *region, 2173 size_t buffer_row_pitch, 2174 size_t buffer_slice_pitch, 2175 size_t host_row_pitch, 2176 size_t host_slice_pitch, 2177 void *ptr, 2178 cl_uint num_events_in_wait_list, 2179 const cl_event *event_wait_list, 2180 cl_event *event, 2181 angle::ParamCapture *paramCapture); 2182 void CaptureEnqueueReadBufferRect_event(bool isCallValid, 2183 cl_command_queue command_queue, 2184 cl_mem buffer, 2185 cl_bool blocking_read, 2186 const size_t *buffer_origin, 2187 const size_t *host_origin, 2188 const size_t *region, 2189 size_t buffer_row_pitch, 2190 size_t buffer_slice_pitch, 2191 size_t host_row_pitch, 2192 size_t host_slice_pitch, 2193 void *ptr, 2194 cl_uint num_events_in_wait_list, 2195 const cl_event *event_wait_list, 2196 cl_event *event, 2197 angle::ParamCapture *paramCapture); 2198 void CaptureEnqueueWriteBufferRect_buffer_origin(bool isCallValid, 2199 cl_command_queue command_queue, 2200 cl_mem buffer, 2201 cl_bool blocking_write, 2202 const size_t *buffer_origin, 2203 const size_t *host_origin, 2204 const size_t *region, 2205 size_t buffer_row_pitch, 2206 size_t buffer_slice_pitch, 2207 size_t host_row_pitch, 2208 size_t host_slice_pitch, 2209 const void *ptr, 2210 cl_uint num_events_in_wait_list, 2211 const cl_event *event_wait_list, 2212 cl_event *event, 2213 angle::ParamCapture *paramCapture); 2214 void CaptureEnqueueWriteBufferRect_host_origin(bool isCallValid, 2215 cl_command_queue command_queue, 2216 cl_mem buffer, 2217 cl_bool blocking_write, 2218 const size_t *buffer_origin, 2219 const size_t *host_origin, 2220 const size_t *region, 2221 size_t buffer_row_pitch, 2222 size_t buffer_slice_pitch, 2223 size_t host_row_pitch, 2224 size_t host_slice_pitch, 2225 const void *ptr, 2226 cl_uint num_events_in_wait_list, 2227 const cl_event *event_wait_list, 2228 cl_event *event, 2229 angle::ParamCapture *paramCapture); 2230 void CaptureEnqueueWriteBufferRect_region(bool isCallValid, 2231 cl_command_queue command_queue, 2232 cl_mem buffer, 2233 cl_bool blocking_write, 2234 const size_t *buffer_origin, 2235 const size_t *host_origin, 2236 const size_t *region, 2237 size_t buffer_row_pitch, 2238 size_t buffer_slice_pitch, 2239 size_t host_row_pitch, 2240 size_t host_slice_pitch, 2241 const void *ptr, 2242 cl_uint num_events_in_wait_list, 2243 const cl_event *event_wait_list, 2244 cl_event *event, 2245 angle::ParamCapture *paramCapture); 2246 void CaptureEnqueueWriteBufferRect_ptr(bool isCallValid, 2247 cl_command_queue command_queue, 2248 cl_mem buffer, 2249 cl_bool blocking_write, 2250 const size_t *buffer_origin, 2251 const size_t *host_origin, 2252 const size_t *region, 2253 size_t buffer_row_pitch, 2254 size_t buffer_slice_pitch, 2255 size_t host_row_pitch, 2256 size_t host_slice_pitch, 2257 const void *ptr, 2258 cl_uint num_events_in_wait_list, 2259 const cl_event *event_wait_list, 2260 cl_event *event, 2261 angle::ParamCapture *paramCapture); 2262 void CaptureEnqueueWriteBufferRect_event_wait_list(bool isCallValid, 2263 cl_command_queue command_queue, 2264 cl_mem buffer, 2265 cl_bool blocking_write, 2266 const size_t *buffer_origin, 2267 const size_t *host_origin, 2268 const size_t *region, 2269 size_t buffer_row_pitch, 2270 size_t buffer_slice_pitch, 2271 size_t host_row_pitch, 2272 size_t host_slice_pitch, 2273 const void *ptr, 2274 cl_uint num_events_in_wait_list, 2275 const cl_event *event_wait_list, 2276 cl_event *event, 2277 angle::ParamCapture *paramCapture); 2278 void CaptureEnqueueWriteBufferRect_event(bool isCallValid, 2279 cl_command_queue command_queue, 2280 cl_mem buffer, 2281 cl_bool blocking_write, 2282 const size_t *buffer_origin, 2283 const size_t *host_origin, 2284 const size_t *region, 2285 size_t buffer_row_pitch, 2286 size_t buffer_slice_pitch, 2287 size_t host_row_pitch, 2288 size_t host_slice_pitch, 2289 const void *ptr, 2290 cl_uint num_events_in_wait_list, 2291 const cl_event *event_wait_list, 2292 cl_event *event, 2293 angle::ParamCapture *paramCapture); 2294 void CaptureEnqueueCopyBufferRect_src_origin(bool isCallValid, 2295 cl_command_queue command_queue, 2296 cl_mem src_buffer, 2297 cl_mem dst_buffer, 2298 const size_t *src_origin, 2299 const size_t *dst_origin, 2300 const size_t *region, 2301 size_t src_row_pitch, 2302 size_t src_slice_pitch, 2303 size_t dst_row_pitch, 2304 size_t dst_slice_pitch, 2305 cl_uint num_events_in_wait_list, 2306 const cl_event *event_wait_list, 2307 cl_event *event, 2308 angle::ParamCapture *paramCapture); 2309 void CaptureEnqueueCopyBufferRect_dst_origin(bool isCallValid, 2310 cl_command_queue command_queue, 2311 cl_mem src_buffer, 2312 cl_mem dst_buffer, 2313 const size_t *src_origin, 2314 const size_t *dst_origin, 2315 const size_t *region, 2316 size_t src_row_pitch, 2317 size_t src_slice_pitch, 2318 size_t dst_row_pitch, 2319 size_t dst_slice_pitch, 2320 cl_uint num_events_in_wait_list, 2321 const cl_event *event_wait_list, 2322 cl_event *event, 2323 angle::ParamCapture *paramCapture); 2324 void CaptureEnqueueCopyBufferRect_region(bool isCallValid, 2325 cl_command_queue command_queue, 2326 cl_mem src_buffer, 2327 cl_mem dst_buffer, 2328 const size_t *src_origin, 2329 const size_t *dst_origin, 2330 const size_t *region, 2331 size_t src_row_pitch, 2332 size_t src_slice_pitch, 2333 size_t dst_row_pitch, 2334 size_t dst_slice_pitch, 2335 cl_uint num_events_in_wait_list, 2336 const cl_event *event_wait_list, 2337 cl_event *event, 2338 angle::ParamCapture *paramCapture); 2339 void CaptureEnqueueCopyBufferRect_event_wait_list(bool isCallValid, 2340 cl_command_queue command_queue, 2341 cl_mem src_buffer, 2342 cl_mem dst_buffer, 2343 const size_t *src_origin, 2344 const size_t *dst_origin, 2345 const size_t *region, 2346 size_t src_row_pitch, 2347 size_t src_slice_pitch, 2348 size_t dst_row_pitch, 2349 size_t dst_slice_pitch, 2350 cl_uint num_events_in_wait_list, 2351 const cl_event *event_wait_list, 2352 cl_event *event, 2353 angle::ParamCapture *paramCapture); 2354 void CaptureEnqueueCopyBufferRect_event(bool isCallValid, 2355 cl_command_queue command_queue, 2356 cl_mem src_buffer, 2357 cl_mem dst_buffer, 2358 const size_t *src_origin, 2359 const size_t *dst_origin, 2360 const size_t *region, 2361 size_t src_row_pitch, 2362 size_t src_slice_pitch, 2363 size_t dst_row_pitch, 2364 size_t dst_slice_pitch, 2365 cl_uint num_events_in_wait_list, 2366 const cl_event *event_wait_list, 2367 cl_event *event, 2368 angle::ParamCapture *paramCapture); 2369 2370 // CL 1.2 2371 void CaptureCreateSubDevices_properties(bool isCallValid, 2372 cl_device_id in_device, 2373 const cl_device_partition_property *properties, 2374 cl_uint num_devices, 2375 cl_device_id *out_devices, 2376 cl_uint *num_devices_ret, 2377 angle::ParamCapture *paramCapture); 2378 void CaptureCreateSubDevices_out_devices(bool isCallValid, 2379 cl_device_id in_device, 2380 const cl_device_partition_property *properties, 2381 cl_uint num_devices, 2382 cl_device_id *out_devices, 2383 cl_uint *num_devices_ret, 2384 angle::ParamCapture *paramCapture); 2385 void CaptureCreateSubDevices_num_devices_ret(bool isCallValid, 2386 cl_device_id in_device, 2387 const cl_device_partition_property *properties, 2388 cl_uint num_devices, 2389 cl_device_id *out_devices, 2390 cl_uint *num_devices_ret, 2391 angle::ParamCapture *paramCapture); 2392 void CaptureCreateImage_image_format(bool isCallValid, 2393 cl_context context, 2394 MemFlags flagsPacked, 2395 const cl_image_format *image_format, 2396 const cl_image_desc *image_desc, 2397 void *host_ptr, 2398 cl_int *errcode_ret, 2399 angle::ParamCapture *paramCapture); 2400 void CaptureCreateImage_image_desc(bool isCallValid, 2401 cl_context context, 2402 MemFlags flagsPacked, 2403 const cl_image_format *image_format, 2404 const cl_image_desc *image_desc, 2405 void *host_ptr, 2406 cl_int *errcode_ret, 2407 angle::ParamCapture *paramCapture); 2408 void CaptureCreateImage_host_ptr(bool isCallValid, 2409 cl_context context, 2410 MemFlags flagsPacked, 2411 const cl_image_format *image_format, 2412 const cl_image_desc *image_desc, 2413 void *host_ptr, 2414 cl_int *errcode_ret, 2415 angle::ParamCapture *paramCapture); 2416 void CaptureCreateImage_errcode_ret(bool isCallValid, 2417 cl_context context, 2418 MemFlags flagsPacked, 2419 const cl_image_format *image_format, 2420 const cl_image_desc *image_desc, 2421 void *host_ptr, 2422 cl_int *errcode_ret, 2423 angle::ParamCapture *paramCapture); 2424 void CaptureCreateProgramWithBuiltInKernels_device_list(bool isCallValid, 2425 cl_context context, 2426 cl_uint num_devices, 2427 const cl_device_id *device_list, 2428 const char *kernel_names, 2429 cl_int *errcode_ret, 2430 angle::ParamCapture *paramCapture); 2431 void CaptureCreateProgramWithBuiltInKernels_kernel_names(bool isCallValid, 2432 cl_context context, 2433 cl_uint num_devices, 2434 const cl_device_id *device_list, 2435 const char *kernel_names, 2436 cl_int *errcode_ret, 2437 angle::ParamCapture *paramCapture); 2438 void CaptureCreateProgramWithBuiltInKernels_errcode_ret(bool isCallValid, 2439 cl_context context, 2440 cl_uint num_devices, 2441 const cl_device_id *device_list, 2442 const char *kernel_names, 2443 cl_int *errcode_ret, 2444 angle::ParamCapture *paramCapture); 2445 void CaptureCompileProgram_device_list(bool isCallValid, 2446 cl_program program, 2447 cl_uint num_devices, 2448 const cl_device_id *device_list, 2449 const char *options, 2450 cl_uint num_input_headers, 2451 const cl_program *input_headers, 2452 const char **header_include_names, 2453 void(CL_CALLBACK *pfn_notify)(cl_program program, 2454 void *user_data), 2455 void *user_data, 2456 angle::ParamCapture *paramCapture); 2457 void CaptureCompileProgram_options(bool isCallValid, 2458 cl_program program, 2459 cl_uint num_devices, 2460 const cl_device_id *device_list, 2461 const char *options, 2462 cl_uint num_input_headers, 2463 const cl_program *input_headers, 2464 const char **header_include_names, 2465 void(CL_CALLBACK *pfn_notify)(cl_program program, 2466 void *user_data), 2467 void *user_data, 2468 angle::ParamCapture *paramCapture); 2469 void CaptureCompileProgram_input_headers(bool isCallValid, 2470 cl_program program, 2471 cl_uint num_devices, 2472 const cl_device_id *device_list, 2473 const char *options, 2474 cl_uint num_input_headers, 2475 const cl_program *input_headers, 2476 const char **header_include_names, 2477 void(CL_CALLBACK *pfn_notify)(cl_program program, 2478 void *user_data), 2479 void *user_data, 2480 angle::ParamCapture *paramCapture); 2481 void CaptureCompileProgram_header_include_names(bool isCallValid, 2482 cl_program program, 2483 cl_uint num_devices, 2484 const cl_device_id *device_list, 2485 const char *options, 2486 cl_uint num_input_headers, 2487 const cl_program *input_headers, 2488 const char **header_include_names, 2489 void(CL_CALLBACK *pfn_notify)(cl_program program, 2490 void *user_data), 2491 void *user_data, 2492 angle::ParamCapture *paramCapture); 2493 void CaptureCompileProgram_pfn_notify(bool isCallValid, 2494 cl_program program, 2495 cl_uint num_devices, 2496 const cl_device_id *device_list, 2497 const char *options, 2498 cl_uint num_input_headers, 2499 const cl_program *input_headers, 2500 const char **header_include_names, 2501 void(CL_CALLBACK *pfn_notify)(cl_program program, 2502 void *user_data), 2503 void *user_data, 2504 angle::ParamCapture *paramCapture); 2505 void CaptureCompileProgram_user_data(bool isCallValid, 2506 cl_program program, 2507 cl_uint num_devices, 2508 const cl_device_id *device_list, 2509 const char *options, 2510 cl_uint num_input_headers, 2511 const cl_program *input_headers, 2512 const char **header_include_names, 2513 void(CL_CALLBACK *pfn_notify)(cl_program program, 2514 void *user_data), 2515 void *user_data, 2516 angle::ParamCapture *paramCapture); 2517 void CaptureLinkProgram_device_list(bool isCallValid, 2518 cl_context context, 2519 cl_uint num_devices, 2520 const cl_device_id *device_list, 2521 const char *options, 2522 cl_uint num_input_programs, 2523 const cl_program *input_programs, 2524 void(CL_CALLBACK *pfn_notify)(cl_program program, 2525 void *user_data), 2526 void *user_data, 2527 cl_int *errcode_ret, 2528 angle::ParamCapture *paramCapture); 2529 void CaptureLinkProgram_options(bool isCallValid, 2530 cl_context context, 2531 cl_uint num_devices, 2532 const cl_device_id *device_list, 2533 const char *options, 2534 cl_uint num_input_programs, 2535 const cl_program *input_programs, 2536 void(CL_CALLBACK *pfn_notify)(cl_program program, void *user_data), 2537 void *user_data, 2538 cl_int *errcode_ret, 2539 angle::ParamCapture *paramCapture); 2540 void CaptureLinkProgram_input_programs(bool isCallValid, 2541 cl_context context, 2542 cl_uint num_devices, 2543 const cl_device_id *device_list, 2544 const char *options, 2545 cl_uint num_input_programs, 2546 const cl_program *input_programs, 2547 void(CL_CALLBACK *pfn_notify)(cl_program program, 2548 void *user_data), 2549 void *user_data, 2550 cl_int *errcode_ret, 2551 angle::ParamCapture *paramCapture); 2552 void CaptureLinkProgram_pfn_notify(bool isCallValid, 2553 cl_context context, 2554 cl_uint num_devices, 2555 const cl_device_id *device_list, 2556 const char *options, 2557 cl_uint num_input_programs, 2558 const cl_program *input_programs, 2559 void(CL_CALLBACK *pfn_notify)(cl_program program, 2560 void *user_data), 2561 void *user_data, 2562 cl_int *errcode_ret, 2563 angle::ParamCapture *paramCapture); 2564 void CaptureLinkProgram_user_data(bool isCallValid, 2565 cl_context context, 2566 cl_uint num_devices, 2567 const cl_device_id *device_list, 2568 const char *options, 2569 cl_uint num_input_programs, 2570 const cl_program *input_programs, 2571 void(CL_CALLBACK *pfn_notify)(cl_program program, 2572 void *user_data), 2573 void *user_data, 2574 cl_int *errcode_ret, 2575 angle::ParamCapture *paramCapture); 2576 void CaptureLinkProgram_errcode_ret(bool isCallValid, 2577 cl_context context, 2578 cl_uint num_devices, 2579 const cl_device_id *device_list, 2580 const char *options, 2581 cl_uint num_input_programs, 2582 const cl_program *input_programs, 2583 void(CL_CALLBACK *pfn_notify)(cl_program program, 2584 void *user_data), 2585 void *user_data, 2586 cl_int *errcode_ret, 2587 angle::ParamCapture *paramCapture); 2588 void CaptureGetKernelArgInfo_param_value(bool isCallValid, 2589 cl_kernel kernel, 2590 cl_uint arg_index, 2591 KernelArgInfo param_namePacked, 2592 size_t param_value_size, 2593 void *param_value, 2594 size_t *param_value_size_ret, 2595 angle::ParamCapture *paramCapture); 2596 void CaptureGetKernelArgInfo_param_value_size_ret(bool isCallValid, 2597 cl_kernel kernel, 2598 cl_uint arg_index, 2599 KernelArgInfo param_namePacked, 2600 size_t param_value_size, 2601 void *param_value, 2602 size_t *param_value_size_ret, 2603 angle::ParamCapture *paramCapture); 2604 void CaptureEnqueueFillBuffer_pattern(bool isCallValid, 2605 cl_command_queue command_queue, 2606 cl_mem buffer, 2607 const void *pattern, 2608 size_t pattern_size, 2609 size_t offset, 2610 size_t size, 2611 cl_uint num_events_in_wait_list, 2612 const cl_event *event_wait_list, 2613 cl_event *event, 2614 angle::ParamCapture *paramCapture); 2615 void CaptureEnqueueFillBuffer_event_wait_list(bool isCallValid, 2616 cl_command_queue command_queue, 2617 cl_mem buffer, 2618 const void *pattern, 2619 size_t pattern_size, 2620 size_t offset, 2621 size_t size, 2622 cl_uint num_events_in_wait_list, 2623 const cl_event *event_wait_list, 2624 cl_event *event, 2625 angle::ParamCapture *paramCapture); 2626 void CaptureEnqueueFillBuffer_event(bool isCallValid, 2627 cl_command_queue command_queue, 2628 cl_mem buffer, 2629 const void *pattern, 2630 size_t pattern_size, 2631 size_t offset, 2632 size_t size, 2633 cl_uint num_events_in_wait_list, 2634 const cl_event *event_wait_list, 2635 cl_event *event, 2636 angle::ParamCapture *paramCapture); 2637 void CaptureEnqueueFillImage_fill_color(bool isCallValid, 2638 cl_command_queue command_queue, 2639 cl_mem image, 2640 const void *fill_color, 2641 const size_t *origin, 2642 const size_t *region, 2643 cl_uint num_events_in_wait_list, 2644 const cl_event *event_wait_list, 2645 cl_event *event, 2646 angle::ParamCapture *paramCapture); 2647 void CaptureEnqueueFillImage_origin(bool isCallValid, 2648 cl_command_queue command_queue, 2649 cl_mem image, 2650 const void *fill_color, 2651 const size_t *origin, 2652 const size_t *region, 2653 cl_uint num_events_in_wait_list, 2654 const cl_event *event_wait_list, 2655 cl_event *event, 2656 angle::ParamCapture *paramCapture); 2657 void CaptureEnqueueFillImage_region(bool isCallValid, 2658 cl_command_queue command_queue, 2659 cl_mem image, 2660 const void *fill_color, 2661 const size_t *origin, 2662 const size_t *region, 2663 cl_uint num_events_in_wait_list, 2664 const cl_event *event_wait_list, 2665 cl_event *event, 2666 angle::ParamCapture *paramCapture); 2667 void CaptureEnqueueFillImage_event_wait_list(bool isCallValid, 2668 cl_command_queue command_queue, 2669 cl_mem image, 2670 const void *fill_color, 2671 const size_t *origin, 2672 const size_t *region, 2673 cl_uint num_events_in_wait_list, 2674 const cl_event *event_wait_list, 2675 cl_event *event, 2676 angle::ParamCapture *paramCapture); 2677 void CaptureEnqueueFillImage_event(bool isCallValid, 2678 cl_command_queue command_queue, 2679 cl_mem image, 2680 const void *fill_color, 2681 const size_t *origin, 2682 const size_t *region, 2683 cl_uint num_events_in_wait_list, 2684 const cl_event *event_wait_list, 2685 cl_event *event, 2686 angle::ParamCapture *paramCapture); 2687 void CaptureEnqueueMigrateMemObjects_mem_objects(bool isCallValid, 2688 cl_command_queue command_queue, 2689 cl_uint num_mem_objects, 2690 const cl_mem *mem_objects, 2691 MemMigrationFlags flagsPacked, 2692 cl_uint num_events_in_wait_list, 2693 const cl_event *event_wait_list, 2694 cl_event *event, 2695 angle::ParamCapture *paramCapture); 2696 void CaptureEnqueueMigrateMemObjects_event_wait_list(bool isCallValid, 2697 cl_command_queue command_queue, 2698 cl_uint num_mem_objects, 2699 const cl_mem *mem_objects, 2700 MemMigrationFlags flagsPacked, 2701 cl_uint num_events_in_wait_list, 2702 const cl_event *event_wait_list, 2703 cl_event *event, 2704 angle::ParamCapture *paramCapture); 2705 void CaptureEnqueueMigrateMemObjects_event(bool isCallValid, 2706 cl_command_queue command_queue, 2707 cl_uint num_mem_objects, 2708 const cl_mem *mem_objects, 2709 MemMigrationFlags flagsPacked, 2710 cl_uint num_events_in_wait_list, 2711 const cl_event *event_wait_list, 2712 cl_event *event, 2713 angle::ParamCapture *paramCapture); 2714 void CaptureEnqueueMarkerWithWaitList_event_wait_list(bool isCallValid, 2715 cl_command_queue command_queue, 2716 cl_uint num_events_in_wait_list, 2717 const cl_event *event_wait_list, 2718 cl_event *event, 2719 angle::ParamCapture *paramCapture); 2720 void CaptureEnqueueMarkerWithWaitList_event(bool isCallValid, 2721 cl_command_queue command_queue, 2722 cl_uint num_events_in_wait_list, 2723 const cl_event *event_wait_list, 2724 cl_event *event, 2725 angle::ParamCapture *paramCapture); 2726 void CaptureEnqueueBarrierWithWaitList_event_wait_list(bool isCallValid, 2727 cl_command_queue command_queue, 2728 cl_uint num_events_in_wait_list, 2729 const cl_event *event_wait_list, 2730 cl_event *event, 2731 angle::ParamCapture *paramCapture); 2732 void CaptureEnqueueBarrierWithWaitList_event(bool isCallValid, 2733 cl_command_queue command_queue, 2734 cl_uint num_events_in_wait_list, 2735 const cl_event *event_wait_list, 2736 cl_event *event, 2737 angle::ParamCapture *paramCapture); 2738 void CaptureGetExtensionFunctionAddressForPlatform_func_name(bool isCallValid, 2739 cl_platform_id platform, 2740 const char *func_name, 2741 angle::ParamCapture *paramCapture); 2742 2743 // CL 2.0 2744 void CaptureCreateCommandQueueWithProperties_properties(bool isCallValid, 2745 cl_context context, 2746 cl_device_id device, 2747 const cl_queue_properties *properties, 2748 cl_int *errcode_ret, 2749 angle::ParamCapture *paramCapture); 2750 void CaptureCreateCommandQueueWithProperties_errcode_ret(bool isCallValid, 2751 cl_context context, 2752 cl_device_id device, 2753 const cl_queue_properties *properties, 2754 cl_int *errcode_ret, 2755 angle::ParamCapture *paramCapture); 2756 void CaptureCreatePipe_properties(bool isCallValid, 2757 cl_context context, 2758 MemFlags flagsPacked, 2759 cl_uint pipe_packet_size, 2760 cl_uint pipe_max_packets, 2761 const cl_pipe_properties *properties, 2762 cl_int *errcode_ret, 2763 angle::ParamCapture *paramCapture); 2764 void CaptureCreatePipe_errcode_ret(bool isCallValid, 2765 cl_context context, 2766 MemFlags flagsPacked, 2767 cl_uint pipe_packet_size, 2768 cl_uint pipe_max_packets, 2769 const cl_pipe_properties *properties, 2770 cl_int *errcode_ret, 2771 angle::ParamCapture *paramCapture); 2772 void CaptureGetPipeInfo_param_value(bool isCallValid, 2773 cl_mem pipe, 2774 PipeInfo param_namePacked, 2775 size_t param_value_size, 2776 void *param_value, 2777 size_t *param_value_size_ret, 2778 angle::ParamCapture *paramCapture); 2779 void CaptureGetPipeInfo_param_value_size_ret(bool isCallValid, 2780 cl_mem pipe, 2781 PipeInfo param_namePacked, 2782 size_t param_value_size, 2783 void *param_value, 2784 size_t *param_value_size_ret, 2785 angle::ParamCapture *paramCapture); 2786 void CaptureSVMFree_svm_pointer(bool isCallValid, 2787 cl_context context, 2788 void *svm_pointer, 2789 angle::ParamCapture *paramCapture); 2790 void CaptureCreateSamplerWithProperties_sampler_properties( 2791 bool isCallValid, 2792 cl_context context, 2793 const cl_sampler_properties *sampler_properties, 2794 cl_int *errcode_ret, 2795 angle::ParamCapture *paramCapture); 2796 void CaptureCreateSamplerWithProperties_errcode_ret(bool isCallValid, 2797 cl_context context, 2798 const cl_sampler_properties *sampler_properties, 2799 cl_int *errcode_ret, 2800 angle::ParamCapture *paramCapture); 2801 void CaptureSetKernelArgSVMPointer_arg_value(bool isCallValid, 2802 cl_kernel kernel, 2803 cl_uint arg_index, 2804 const void *arg_value, 2805 angle::ParamCapture *paramCapture); 2806 void CaptureSetKernelExecInfo_param_value(bool isCallValid, 2807 cl_kernel kernel, 2808 KernelExecInfo param_namePacked, 2809 size_t param_value_size, 2810 const void *param_value, 2811 angle::ParamCapture *paramCapture); 2812 void CaptureEnqueueSVMFree_svm_pointers(bool isCallValid, 2813 cl_command_queue command_queue, 2814 cl_uint num_svm_pointers, 2815 void *svm_pointers[], 2816 void(CL_CALLBACK *pfn_free_func)(cl_command_queue queue, 2817 cl_uint num_svm_pointers, 2818 void *svm_pointers[], 2819 void *user_data), 2820 void *user_data, 2821 cl_uint num_events_in_wait_list, 2822 const cl_event *event_wait_list, 2823 cl_event *event, 2824 angle::ParamCapture *paramCapture); 2825 void CaptureEnqueueSVMFree_pfn_free_func(bool isCallValid, 2826 cl_command_queue command_queue, 2827 cl_uint num_svm_pointers, 2828 void *svm_pointers[], 2829 void(CL_CALLBACK *pfn_free_func)(cl_command_queue queue, 2830 cl_uint num_svm_pointers, 2831 void *svm_pointers[], 2832 void *user_data), 2833 void *user_data, 2834 cl_uint num_events_in_wait_list, 2835 const cl_event *event_wait_list, 2836 cl_event *event, 2837 angle::ParamCapture *paramCapture); 2838 void CaptureEnqueueSVMFree_user_data(bool isCallValid, 2839 cl_command_queue command_queue, 2840 cl_uint num_svm_pointers, 2841 void *svm_pointers[], 2842 void(CL_CALLBACK *pfn_free_func)(cl_command_queue queue, 2843 cl_uint num_svm_pointers, 2844 void *svm_pointers[], 2845 void *user_data), 2846 void *user_data, 2847 cl_uint num_events_in_wait_list, 2848 const cl_event *event_wait_list, 2849 cl_event *event, 2850 angle::ParamCapture *paramCapture); 2851 void CaptureEnqueueSVMFree_event_wait_list( 2852 bool isCallValid, 2853 cl_command_queue command_queue, 2854 cl_uint num_svm_pointers, 2855 void *svm_pointers[], 2856 void(CL_CALLBACK *pfn_free_func)(cl_command_queue queue, 2857 cl_uint num_svm_pointers, 2858 void *svm_pointers[], 2859 void *user_data), 2860 void *user_data, 2861 cl_uint num_events_in_wait_list, 2862 const cl_event *event_wait_list, 2863 cl_event *event, 2864 angle::ParamCapture *paramCapture); 2865 void CaptureEnqueueSVMFree_event(bool isCallValid, 2866 cl_command_queue command_queue, 2867 cl_uint num_svm_pointers, 2868 void *svm_pointers[], 2869 void(CL_CALLBACK *pfn_free_func)(cl_command_queue queue, 2870 cl_uint num_svm_pointers, 2871 void *svm_pointers[], 2872 void *user_data), 2873 void *user_data, 2874 cl_uint num_events_in_wait_list, 2875 const cl_event *event_wait_list, 2876 cl_event *event, 2877 angle::ParamCapture *paramCapture); 2878 void CaptureEnqueueSVMMemcpy_dst_ptr(bool isCallValid, 2879 cl_command_queue command_queue, 2880 cl_bool blocking_copy, 2881 void *dst_ptr, 2882 const void *src_ptr, 2883 size_t size, 2884 cl_uint num_events_in_wait_list, 2885 const cl_event *event_wait_list, 2886 cl_event *event, 2887 angle::ParamCapture *paramCapture); 2888 void CaptureEnqueueSVMMemcpy_src_ptr(bool isCallValid, 2889 cl_command_queue command_queue, 2890 cl_bool blocking_copy, 2891 void *dst_ptr, 2892 const void *src_ptr, 2893 size_t size, 2894 cl_uint num_events_in_wait_list, 2895 const cl_event *event_wait_list, 2896 cl_event *event, 2897 angle::ParamCapture *paramCapture); 2898 void CaptureEnqueueSVMMemcpy_event_wait_list(bool isCallValid, 2899 cl_command_queue command_queue, 2900 cl_bool blocking_copy, 2901 void *dst_ptr, 2902 const void *src_ptr, 2903 size_t size, 2904 cl_uint num_events_in_wait_list, 2905 const cl_event *event_wait_list, 2906 cl_event *event, 2907 angle::ParamCapture *paramCapture); 2908 void CaptureEnqueueSVMMemcpy_event(bool isCallValid, 2909 cl_command_queue command_queue, 2910 cl_bool blocking_copy, 2911 void *dst_ptr, 2912 const void *src_ptr, 2913 size_t size, 2914 cl_uint num_events_in_wait_list, 2915 const cl_event *event_wait_list, 2916 cl_event *event, 2917 angle::ParamCapture *paramCapture); 2918 void CaptureEnqueueSVMMemFill_svm_ptr(bool isCallValid, 2919 cl_command_queue command_queue, 2920 void *svm_ptr, 2921 const void *pattern, 2922 size_t pattern_size, 2923 size_t size, 2924 cl_uint num_events_in_wait_list, 2925 const cl_event *event_wait_list, 2926 cl_event *event, 2927 angle::ParamCapture *paramCapture); 2928 void CaptureEnqueueSVMMemFill_pattern(bool isCallValid, 2929 cl_command_queue command_queue, 2930 void *svm_ptr, 2931 const void *pattern, 2932 size_t pattern_size, 2933 size_t size, 2934 cl_uint num_events_in_wait_list, 2935 const cl_event *event_wait_list, 2936 cl_event *event, 2937 angle::ParamCapture *paramCapture); 2938 void CaptureEnqueueSVMMemFill_event_wait_list(bool isCallValid, 2939 cl_command_queue command_queue, 2940 void *svm_ptr, 2941 const void *pattern, 2942 size_t pattern_size, 2943 size_t size, 2944 cl_uint num_events_in_wait_list, 2945 const cl_event *event_wait_list, 2946 cl_event *event, 2947 angle::ParamCapture *paramCapture); 2948 void CaptureEnqueueSVMMemFill_event(bool isCallValid, 2949 cl_command_queue command_queue, 2950 void *svm_ptr, 2951 const void *pattern, 2952 size_t pattern_size, 2953 size_t size, 2954 cl_uint num_events_in_wait_list, 2955 const cl_event *event_wait_list, 2956 cl_event *event, 2957 angle::ParamCapture *paramCapture); 2958 void CaptureEnqueueSVMMap_svm_ptr(bool isCallValid, 2959 cl_command_queue command_queue, 2960 cl_bool blocking_map, 2961 MapFlags flagsPacked, 2962 void *svm_ptr, 2963 size_t size, 2964 cl_uint num_events_in_wait_list, 2965 const cl_event *event_wait_list, 2966 cl_event *event, 2967 angle::ParamCapture *paramCapture); 2968 void CaptureEnqueueSVMMap_event_wait_list(bool isCallValid, 2969 cl_command_queue command_queue, 2970 cl_bool blocking_map, 2971 MapFlags flagsPacked, 2972 void *svm_ptr, 2973 size_t size, 2974 cl_uint num_events_in_wait_list, 2975 const cl_event *event_wait_list, 2976 cl_event *event, 2977 angle::ParamCapture *paramCapture); 2978 void CaptureEnqueueSVMMap_event(bool isCallValid, 2979 cl_command_queue command_queue, 2980 cl_bool blocking_map, 2981 MapFlags flagsPacked, 2982 void *svm_ptr, 2983 size_t size, 2984 cl_uint num_events_in_wait_list, 2985 const cl_event *event_wait_list, 2986 cl_event *event, 2987 angle::ParamCapture *paramCapture); 2988 void CaptureEnqueueSVMUnmap_svm_ptr(bool isCallValid, 2989 cl_command_queue command_queue, 2990 void *svm_ptr, 2991 cl_uint num_events_in_wait_list, 2992 const cl_event *event_wait_list, 2993 cl_event *event, 2994 angle::ParamCapture *paramCapture); 2995 void CaptureEnqueueSVMUnmap_event_wait_list(bool isCallValid, 2996 cl_command_queue command_queue, 2997 void *svm_ptr, 2998 cl_uint num_events_in_wait_list, 2999 const cl_event *event_wait_list, 3000 cl_event *event, 3001 angle::ParamCapture *paramCapture); 3002 void CaptureEnqueueSVMUnmap_event(bool isCallValid, 3003 cl_command_queue command_queue, 3004 void *svm_ptr, 3005 cl_uint num_events_in_wait_list, 3006 const cl_event *event_wait_list, 3007 cl_event *event, 3008 angle::ParamCapture *paramCapture); 3009 3010 // CL 2.1 3011 void CaptureGetDeviceAndHostTimer_device_timestamp(bool isCallValid, 3012 cl_device_id device, 3013 cl_ulong *device_timestamp, 3014 cl_ulong *host_timestamp, 3015 angle::ParamCapture *paramCapture); 3016 void CaptureGetDeviceAndHostTimer_host_timestamp(bool isCallValid, 3017 cl_device_id device, 3018 cl_ulong *device_timestamp, 3019 cl_ulong *host_timestamp, 3020 angle::ParamCapture *paramCapture); 3021 void CaptureGetHostTimer_host_timestamp(bool isCallValid, 3022 cl_device_id device, 3023 cl_ulong *host_timestamp, 3024 angle::ParamCapture *paramCapture); 3025 void CaptureCreateProgramWithIL_il(bool isCallValid, 3026 cl_context context, 3027 const void *il, 3028 size_t length, 3029 cl_int *errcode_ret, 3030 angle::ParamCapture *paramCapture); 3031 void CaptureCreateProgramWithIL_errcode_ret(bool isCallValid, 3032 cl_context context, 3033 const void *il, 3034 size_t length, 3035 cl_int *errcode_ret, 3036 angle::ParamCapture *paramCapture); 3037 void CaptureCloneKernel_errcode_ret(bool isCallValid, 3038 cl_kernel source_kernel, 3039 cl_int *errcode_ret, 3040 angle::ParamCapture *paramCapture); 3041 void CaptureGetKernelSubGroupInfo_input_value(bool isCallValid, 3042 cl_kernel kernel, 3043 cl_device_id device, 3044 KernelSubGroupInfo param_namePacked, 3045 size_t input_value_size, 3046 const void *input_value, 3047 size_t param_value_size, 3048 void *param_value, 3049 size_t *param_value_size_ret, 3050 angle::ParamCapture *paramCapture); 3051 void CaptureGetKernelSubGroupInfo_param_value(bool isCallValid, 3052 cl_kernel kernel, 3053 cl_device_id device, 3054 KernelSubGroupInfo param_namePacked, 3055 size_t input_value_size, 3056 const void *input_value, 3057 size_t param_value_size, 3058 void *param_value, 3059 size_t *param_value_size_ret, 3060 angle::ParamCapture *paramCapture); 3061 void CaptureGetKernelSubGroupInfo_param_value_size_ret(bool isCallValid, 3062 cl_kernel kernel, 3063 cl_device_id device, 3064 KernelSubGroupInfo param_namePacked, 3065 size_t input_value_size, 3066 const void *input_value, 3067 size_t param_value_size, 3068 void *param_value, 3069 size_t *param_value_size_ret, 3070 angle::ParamCapture *paramCapture); 3071 void CaptureEnqueueSVMMigrateMem_svm_pointers(bool isCallValid, 3072 cl_command_queue command_queue, 3073 cl_uint num_svm_pointers, 3074 const void **svm_pointers, 3075 const size_t *sizes, 3076 MemMigrationFlags flagsPacked, 3077 cl_uint num_events_in_wait_list, 3078 const cl_event *event_wait_list, 3079 cl_event *event, 3080 angle::ParamCapture *paramCapture); 3081 void CaptureEnqueueSVMMigrateMem_sizes(bool isCallValid, 3082 cl_command_queue command_queue, 3083 cl_uint num_svm_pointers, 3084 const void **svm_pointers, 3085 const size_t *sizes, 3086 MemMigrationFlags flagsPacked, 3087 cl_uint num_events_in_wait_list, 3088 const cl_event *event_wait_list, 3089 cl_event *event, 3090 angle::ParamCapture *paramCapture); 3091 void CaptureEnqueueSVMMigrateMem_event_wait_list(bool isCallValid, 3092 cl_command_queue command_queue, 3093 cl_uint num_svm_pointers, 3094 const void **svm_pointers, 3095 const size_t *sizes, 3096 MemMigrationFlags flagsPacked, 3097 cl_uint num_events_in_wait_list, 3098 const cl_event *event_wait_list, 3099 cl_event *event, 3100 angle::ParamCapture *paramCapture); 3101 void CaptureEnqueueSVMMigrateMem_event(bool isCallValid, 3102 cl_command_queue command_queue, 3103 cl_uint num_svm_pointers, 3104 const void **svm_pointers, 3105 const size_t *sizes, 3106 MemMigrationFlags flagsPacked, 3107 cl_uint num_events_in_wait_list, 3108 const cl_event *event_wait_list, 3109 cl_event *event, 3110 angle::ParamCapture *paramCapture); 3111 3112 // CL 2.2 3113 void CaptureSetProgramReleaseCallback_pfn_notify(bool isCallValid, 3114 cl_program program, 3115 void(CL_CALLBACK *pfn_notify)(cl_program program, 3116 void *user_data), 3117 void *user_data, 3118 angle::ParamCapture *paramCapture); 3119 void CaptureSetProgramReleaseCallback_user_data(bool isCallValid, 3120 cl_program program, 3121 void(CL_CALLBACK *pfn_notify)(cl_program program, 3122 void *user_data), 3123 void *user_data, 3124 angle::ParamCapture *paramCapture); 3125 void CaptureSetProgramSpecializationConstant_spec_value(bool isCallValid, 3126 cl_program program, 3127 cl_uint spec_id, 3128 size_t spec_size, 3129 const void *spec_value, 3130 angle::ParamCapture *paramCapture); 3131 3132 // CL 3.0 3133 void CaptureSetContextDestructorCallback_pfn_notify( 3134 bool isCallValid, 3135 cl_context context, 3136 void(CL_CALLBACK *pfn_notify)(cl_context context, void *user_data), 3137 void *user_data, 3138 angle::ParamCapture *paramCapture); 3139 void CaptureSetContextDestructorCallback_user_data(bool isCallValid, 3140 cl_context context, 3141 void(CL_CALLBACK *pfn_notify)(cl_context context, 3142 void *user_data), 3143 void *user_data, 3144 angle::ParamCapture *paramCapture); 3145 void CaptureCreateBufferWithProperties_properties(bool isCallValid, 3146 cl_context context, 3147 const cl_mem_properties *properties, 3148 MemFlags flagsPacked, 3149 size_t size, 3150 void *host_ptr, 3151 cl_int *errcode_ret, 3152 angle::ParamCapture *paramCapture); 3153 void CaptureCreateBufferWithProperties_host_ptr(bool isCallValid, 3154 cl_context context, 3155 const cl_mem_properties *properties, 3156 MemFlags flagsPacked, 3157 size_t size, 3158 void *host_ptr, 3159 cl_int *errcode_ret, 3160 angle::ParamCapture *paramCapture); 3161 void CaptureCreateBufferWithProperties_errcode_ret(bool isCallValid, 3162 cl_context context, 3163 const cl_mem_properties *properties, 3164 MemFlags flagsPacked, 3165 size_t size, 3166 void *host_ptr, 3167 cl_int *errcode_ret, 3168 angle::ParamCapture *paramCapture); 3169 void CaptureCreateImageWithProperties_properties(bool isCallValid, 3170 cl_context context, 3171 const cl_mem_properties *properties, 3172 MemFlags flagsPacked, 3173 const cl_image_format *image_format, 3174 const cl_image_desc *image_desc, 3175 void *host_ptr, 3176 cl_int *errcode_ret, 3177 angle::ParamCapture *paramCapture); 3178 void CaptureCreateImageWithProperties_image_format(bool isCallValid, 3179 cl_context context, 3180 const cl_mem_properties *properties, 3181 MemFlags flagsPacked, 3182 const cl_image_format *image_format, 3183 const cl_image_desc *image_desc, 3184 void *host_ptr, 3185 cl_int *errcode_ret, 3186 angle::ParamCapture *paramCapture); 3187 void CaptureCreateImageWithProperties_image_desc(bool isCallValid, 3188 cl_context context, 3189 const cl_mem_properties *properties, 3190 MemFlags flagsPacked, 3191 const cl_image_format *image_format, 3192 const cl_image_desc *image_desc, 3193 void *host_ptr, 3194 cl_int *errcode_ret, 3195 angle::ParamCapture *paramCapture); 3196 void CaptureCreateImageWithProperties_host_ptr(bool isCallValid, 3197 cl_context context, 3198 const cl_mem_properties *properties, 3199 MemFlags flagsPacked, 3200 const cl_image_format *image_format, 3201 const cl_image_desc *image_desc, 3202 void *host_ptr, 3203 cl_int *errcode_ret, 3204 angle::ParamCapture *paramCapture); 3205 void CaptureCreateImageWithProperties_errcode_ret(bool isCallValid, 3206 cl_context context, 3207 const cl_mem_properties *properties, 3208 MemFlags flagsPacked, 3209 const cl_image_format *image_format, 3210 const cl_image_desc *image_desc, 3211 void *host_ptr, 3212 cl_int *errcode_ret, 3213 angle::ParamCapture *paramCapture); 3214 3215 // cl_khr_icd 3216 void CaptureIcdGetPlatformIDsKHR_platforms(bool isCallValid, 3217 cl_uint num_entries, 3218 cl_platform_id *platforms, 3219 cl_uint *num_platforms, 3220 angle::ParamCapture *paramCapture); 3221 void CaptureIcdGetPlatformIDsKHR_num_platforms(bool isCallValid, 3222 cl_uint num_entries, 3223 cl_platform_id *platforms, 3224 cl_uint *num_platforms, 3225 angle::ParamCapture *paramCapture); 3226 } // namespace cl 3227 3228 #endif // LIBANGLE_CAPTURE_CL_AUTOGEN_H_ 3229