// RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CL -fdeclare-opencl-builtins -DNO_HEADER
// RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CL -fdeclare-opencl-builtins -finclude-default-header
// RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CL1.2 -fdeclare-opencl-builtins -DNO_HEADER -cl-ext=-cl_intel_subgroups
// RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CL1.2 -fdeclare-opencl-builtins -finclude-default-header -cl-ext=-cl_intel_subgroups
// RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CL2.0 -fdeclare-opencl-builtins -DNO_HEADER
// RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CL2.0 -fdeclare-opencl-builtins -finclude-default-header
// RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CL3.0 -fdeclare-opencl-builtins -finclude-default-header
// RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CLC++ -fdeclare-opencl-builtins -DNO_HEADER
// RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CLC++ -fdeclare-opencl-builtins -finclude-default-header
// RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CLC++2021 -fdeclare-opencl-builtins -finclude-default-header
// RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CL2.0 -fdeclare-opencl-builtins -finclude-default-header -cl-ext=-cl_khr_fp64 -DNO_FP64
// RUN: %clang_cc1 %s -triple spir -verify -pedantic -Wconversion -Werror -fsyntax-only -cl-std=CL3.0 -fdeclare-opencl-builtins -finclude-default-header -DNO_ATOMSCOPE

// Test the -fdeclare-opencl-builtins option.  This is not a completeness
// test, so it should not test for all builtins defined by OpenCL.  Instead
// this test should cover different functional aspects of the TableGen builtin
// function machinery.

#pragma OPENCL EXTENSION cl_khr_fp16 : enable
#if __OPENCL_C_VERSION__ < CL_VERSION_1_2
#pragma OPENCL EXTENSION cl_khr_fp64 : enable
#endif

#if __OPENCL_C_VERSION__ <= CL_VERSION_1_2
#pragma OPENCL EXTENSION cl_khr_3d_image_writes : enable
#endif

// First, test that Clang gracefully handles missing types.
#ifdef NO_HEADER
void test_without_header(void) {
  barrier(0);
  // expected-note@-1 0+{{candidate function not viable}}
  // expected-error@-2 0+{{argument type 'void' is incomplete}}
  // expected-error@-3 0+{{no matching function for call to 'barrier'}}
  // expected-error@* {{typedef type cl_mem_fence_flags not found; include the base header with -finclude-default-header}}
}
#endif

// Provide typedefs when invoking clang without -finclude-default-header.
#ifdef NO_HEADER
typedef unsigned char uchar;
typedef unsigned int uint;
typedef unsigned long ulong;
typedef unsigned short ushort;
typedef __SIZE_TYPE__ size_t;
typedef __PTRDIFF_TYPE__ ptrdiff_t;
typedef __INTPTR_TYPE__ intptr_t;
typedef __UINTPTR_TYPE__ uintptr_t;
typedef char char2 __attribute__((ext_vector_type(2)));
typedef char char4 __attribute__((ext_vector_type(4)));
typedef uchar uchar4 __attribute__((ext_vector_type(4)));
typedef uchar uchar16 __attribute__((ext_vector_type(16)));
typedef float float4 __attribute__((ext_vector_type(4)));
typedef float float16 __attribute__((ext_vector_type(16)));
typedef half half4 __attribute__((ext_vector_type(4)));
typedef int int2 __attribute__((ext_vector_type(2)));
typedef int int4 __attribute__((ext_vector_type(4)));
typedef uint uint2 __attribute__((ext_vector_type(2)));
typedef uint uint4 __attribute__((ext_vector_type(4)));
typedef long long2 __attribute__((ext_vector_type(2)));
typedef long long8 __attribute__((ext_vector_type(8)));
typedef ulong ulong4 __attribute__((ext_vector_type(4)));
typedef short short16 __attribute__((ext_vector_type(16)));
typedef ushort ushort3 __attribute__((ext_vector_type(3)));

typedef int clk_profiling_info;
#define CLK_PROFILING_COMMAND_EXEC_TIME 0x1

typedef uint cl_mem_fence_flags;
#define CLK_GLOBAL_MEM_FENCE 0x02

typedef struct {int a;} ndrange_t;

// Enable extensions that are enabled in opencl-c-base.h.
#if (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200)
#define __opencl_c_device_enqueue 1
#define __opencl_c_generic_address_space 1
#define cl_khr_subgroup_extended_types 1
#define cl_khr_subgroup_ballot 1
#define cl_khr_subgroup_non_uniform_arithmetic 1
#define cl_khr_subgroup_clustered_reduce 1
#define __opencl_c_read_write_images 1
#define __opencl_subgroup_builtins 1
#endif

#if (__OPENCL_CPP_VERSION__ == 100 || __OPENCL_C_VERSION__ == 200)
#define __opencl_c_atomic_order_seq_cst 1
#define __opencl_c_atomic_scope_device 1
#endif

#define __opencl_c_named_address_space_builtins 1
#endif

kernel void test_pointers(volatile global void *global_p, global const int4 *a) {
  int i;
  unsigned int ui;

  prefetch(a, 2);

  atom_add((volatile __global int *)global_p, i);
  atom_cmpxchg((volatile __global unsigned int *)global_p, ui, ui);
}

// Only test enum arguments when the base header is included, because we need
// the enum declarations.
#if !defined(NO_HEADER) && (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200)
kernel void test_enum_args(volatile global atomic_int *global_p, global int *expected) {
  int desired;
  atomic_work_item_fence(CLK_GLOBAL_MEM_FENCE, memory_order_acq_rel, memory_scope_device);
  atomic_compare_exchange_strong_explicit(global_p, expected, desired,
                                          memory_order_acq_rel,
                                          memory_order_relaxed,
                                          memory_scope_work_group);
}
#endif

#if defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200
void test_typedef_args(clk_event_t evt, volatile atomic_flag *flg, global unsigned long long *values) {
  capture_event_profiling_info(evt, CLK_PROFILING_COMMAND_EXEC_TIME, values);

  atomic_flag_clear(flg);
  bool result = atomic_flag_test_and_set(flg);

  size_t ws[2] = {2, 8};
  ndrange_t r = ndrange_2D(ws);
}

// Check that atomic_fetch_ functions can be called with (u)intptr_t arguments,
// despite OpenCLBuiltins.td not providing explicit overloads for those types.
void test_atomic_fetch(volatile __generic atomic_int *a_int,
                       volatile __generic atomic_intptr_t *a_intptr,
                       volatile __generic atomic_uintptr_t *a_uintptr) {
  int i;
  intptr_t ip;
  uintptr_t uip;
  ptrdiff_t ptrdiff;

  i = atomic_fetch_add(a_int, i);
  ip = atomic_fetch_add(a_intptr, ptrdiff);
  uip = atomic_fetch_add(a_uintptr, ptrdiff);

  ip = atomic_fetch_or(a_intptr, ip);
  uip = atomic_fetch_or(a_uintptr, uip);
}
#endif

#if !defined(NO_HEADER) && !defined(NO_FP64) && __OPENCL_C_VERSION__ >= 200
// Check added atomic_fetch_ functions by cl_ext_float_atomics
// extension can be called
void test_atomic_fetch_with_address_space(volatile __generic atomic_float *a_float,
                                          volatile __generic atomic_double *a_double,
                                          volatile __local atomic_float *a_float_local,
                                          volatile __local atomic_double *a_double_local,
                                          volatile __global atomic_float *a_float_global,
                                          volatile __global atomic_double *a_double_global) {
  float f1, resf1;
  double d1, resd1;
  resf1 = atomic_fetch_min(a_float, f1);
  resf1 = atomic_fetch_max_explicit(a_float_local, f1, memory_order_seq_cst);
  resf1 = atomic_fetch_add_explicit(a_float_global, f1, memory_order_seq_cst, memory_scope_work_group);

  resd1 = atomic_fetch_min(a_double, d1);
  resd1 = atomic_fetch_max_explicit(a_double_local, d1, memory_order_seq_cst);
  resd1 = atomic_fetch_add_explicit(a_double_global, d1, memory_order_seq_cst, memory_scope_work_group);
}
#endif // !defined(NO_HEADER) && __OPENCL_C_VERSION__ >= 200

#if !defined(NO_HEADER) && __OPENCL_C_VERSION__ == 200 && defined(__opencl_c_generic_address_space)

// Test that overloads that use atomic_double are not available when the fp64
// extension is disabled.  Test this by counting the number of notes about
// candidate functions.
void test_atomic_double_reporting(volatile __generic atomic_int *a) {
  atomic_init(a, a);
  // expected-error@-1{{no matching function for call to 'atomic_init'}}
#if defined(NO_FP64)
  // Expecting 5 candidates: int, uint, long, ulong, float
  // expected-note@-4 5 {{candidate function not viable: no known conversion}}
#else
  // Expecting 6 candidates: int, uint, long, ulong, float, double
  // expected-note@-7 6 {{candidate function not viable: no known conversion}}
#endif
}

#endif

#if defined(NO_ATOMSCOPE) && __OPENCL_C_VERSION__ >= 300
// Disable the feature by undefining the feature macro.
#undef __opencl_c_atomic_scope_device

// Test that only the overload with explicit order and scope arguments is
// available when the __opencl_c_atomic_scope_device feature is disabled.
void test_atomics_without_scope_device(volatile __generic atomic_int *a_int) {
  int d;

  atomic_exchange(a_int, d);
  // expected-error@-1{{use of undeclared identifier 'atomic_exchange'}}

  atomic_exchange_explicit(a_int, d, memory_order_seq_cst);
  // expected-error@-1{{no matching function for call to 'atomic_exchange_explicit'}}

  atomic_exchange_explicit(a_int, d, memory_order_seq_cst, memory_scope_work_group);
}

#endif

// Test old atomic overloaded with generic address space in C++ for OpenCL.
#if __OPENCL_C_VERSION__ >= 200
void test_legacy_atomics_cpp(__generic volatile unsigned int *a) {
  atomic_add(a, 1);
#if !defined(__cplusplus)
  // expected-error@-2{{no matching function for call to 'atomic_add'}}
  // expected-note@-3 4 {{candidate function not viable}}
#endif
}
#endif

kernel void basic_conversion(void) {
  float f;
  char2 c2;
  long2 l2;
  float4 f4;
  int4 i4;

#ifdef NO_FP64
  (void)convert_double_rtp(f);
  // expected-error@-1{{use of undeclared identifier 'convert_double_rtp'}}
#else
  double d;
  f = convert_float(d);
#endif
  l2 = convert_long2_rtz(c2);
  i4 = convert_int4_sat(f4);
}

kernel void basic_conversion_neg(void) {
  int i;
  float f;

  f = convert_float_sat(i);
#if !defined(__OPENCL_CPP_VERSION__)
  // expected-error@-2{{use of undeclared identifier 'convert_float_sat'}}
#else
  // expected-error@-4{{use of undeclared identifier 'convert_float_sat'; did you mean 'convert_float'?}}
  // expected-note@-5{{'convert_float' declared here}}
#endif
}

char4 test_int(char c, char4 c4) {
  char m = max(c, c);
  char4 m4 = max(c4, c4);
  uchar4 abs1 = abs(c4);
  uchar4 abs2 = abs(abs1);
  return max(c4, c);
}

kernel void basic_vector_misc(float4 a) {
  float4 res;
  uint4 mask = (uint4)(1, 2, 3, 4);

  res = shuffle(a, mask);
}

kernel void basic_image_readonly(read_only image2d_t image_read_only_image2d) {
  int2 i2;
  sampler_t sampler;
  half4 res;
  float4 resf;

  resf = read_imagef(image_read_only_image2d, i2);
  res = read_imageh(image_read_only_image2d, i2);
#if __OPENCL_C_VERSION__ < CL_VERSION_1_2 && !defined(__OPENCL_CPP_VERSION__)
  // expected-error@-3{{no matching function for call to 'read_imagef'}}
  // expected-error@-3{{no matching function for call to 'read_imageh'}}
#endif
  res = read_imageh(image_read_only_image2d, sampler, i2);

  int imgWidth = get_image_width(image_read_only_image2d);
}

#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
kernel void basic_image_readwrite(read_write image3d_t image_read_write_image3d) {
  half4 h4;
  int4 i4;

  write_imageh(image_read_write_image3d, i4, h4);

  int imgDepth = get_image_depth(image_read_write_image3d);
}
#endif // __OPENCL_C_VERSION__ >= CL_VERSION_2_0

kernel void basic_image_writeonly(write_only image1d_buffer_t image_write_only_image1d_buffer, write_only image3d_t image3dwo) {
  half4 h4;
  float4 f4;
  int i;

  write_imagef(image_write_only_image1d_buffer, i, f4);
  write_imageh(image_write_only_image1d_buffer, i, h4);

  int4 i4;
  write_imagef(image3dwo, i4, i, f4);
#if __OPENCL_C_VERSION__ <= CL_VERSION_1_2 && !defined(__OPENCL_CPP_VERSION__)
  // expected-error@-2{{no matching function for call to 'write_imagef'}}
#endif
}

kernel void basic_subgroup(global uint *out) {
  out[0] = get_sub_group_size();
#if __OPENCL_C_VERSION__ <= CL_VERSION_1_2 && !defined(__OPENCL_CPP_VERSION__)
  // expected-error@-2{{use of undeclared identifier 'get_sub_group_size'}}
#endif

// Only test when the base header is included, because we need the enum declarations.
#if !defined(NO_HEADER) && (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200)
  sub_group_barrier(CLK_GLOBAL_MEM_FENCE, memory_scope_device);
#endif
}

kernel void extended_subgroup(global uint4 *out, global int *scalar, global char2 *c2) {
  out[0] = get_sub_group_eq_mask();
  scalar[0] = sub_group_non_uniform_scan_inclusive_or(3);
  scalar[1] = sub_group_clustered_reduce_logical_xor(2, 4);
  *c2 = sub_group_broadcast(*c2, 2);
#if __OPENCL_C_VERSION__ < CL_VERSION_2_0 && !defined(__OPENCL_CPP_VERSION__)
  // expected-error@-5{{use of undeclared identifier 'get_sub_group_eq_mask'}}
  // expected-error@-5{{use of undeclared identifier 'sub_group_non_uniform_scan_inclusive_or'}}
  // expected-error@-5{{use of undeclared identifier 'sub_group_clustered_reduce_logical_xor'}}
  // expected-error@-5{{use of undeclared identifier 'sub_group_broadcast'}}
#endif
}

kernel void basic_vector_data(void) {
#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
  generic void *generic_p;
#endif
  constant void *constant_p;
  local void *local_p;
  global void *global_p;
  private void *private_p;
  size_t s;
  ulong4 ul4;
  short16 s16;
#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
  ushort3 us3;
  uchar16 uc16;
#endif
  long8 l8;
  uint2 ui2;
  float16 f16;

  ul4 = vload4(s, (const __constant ulong *) constant_p);
  s16 = vload16(s, (const __constant short *) constant_p);

#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0
  us3 = vload3(s, (const __generic ushort *) generic_p);
  uc16 = vload16(s, (const __generic uchar *) generic_p);
#endif

  l8 = vload8(s, (const __global long *) global_p);
  ui2 = vload2(s, (const __local uint *) local_p);
  f16 = vload16(s, (const __private float *) private_p);
}

kernel void basic_work_item(void) {
  uint ui;

  barrier(CLK_GLOBAL_MEM_FENCE);

  get_enqueued_local_size(ui);
#if !defined(__OPENCL_CPP_VERSION__) && __OPENCL_C_VERSION__ < CL_VERSION_2_0
// expected-error@-2{{use of undeclared identifier 'get_enqueued_local_size'}}
#endif
}

#ifdef NO_FP64
void test_extension_types(char2 c2) {
  // We should see 6 candidates for float and half types, and none for double types.
  int i = isnan(c2);
  // expected-error@-1{{no matching function for call to 'isnan'}}
  // expected-note@-2 6 {{candidate function not viable: no known conversion from '__private char2' (vector of 2 'char' values) to 'float}}
  // expected-note@-3 6 {{candidate function not viable: no known conversion from '__private char2' (vector of 2 'char' values) to 'half}}
}
#endif