summaryrefslogtreecommitdiffstats
path: root/dynamic-layers/clang-layer/recipes-devtools/clang
diff options
context:
space:
mode:
Diffstat (limited to 'dynamic-layers/clang-layer/recipes-devtools/clang')
-rw-r--r--dynamic-layers/clang-layer/recipes-devtools/clang/files/0001-Fix-debug-info-of-work-item-builtin-translation-745.patch119
-rw-r--r--dynamic-layers/clang-layer/recipes-devtools/clang/files/0001-Memory-leak-fix-for-Managed-Static-Mutex.patch35
-rw-r--r--dynamic-layers/clang-layer/recipes-devtools/clang/files/0002-Add-cl_khr_extended_subgroup-extensions.patch812
-rw-r--r--dynamic-layers/clang-layer/recipes-devtools/clang/files/BasicBlockUtils-Add-metadata-fixing-in-SplitBlockPre.patch111
-rw-r--r--dynamic-layers/clang-layer/recipes-devtools/clang/files/IndVarSimplify-Do-not-use-SCEV-expander-for-IVCount-.patch146
-rw-r--r--dynamic-layers/clang-layer/recipes-devtools/clang/files/fix-shared-libs.patch30
-rw-r--r--dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm10-OpenCL-3.0-support.patch8259
-rw-r--r--dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm10-Remove-repo-name-in-LLVM-IR.patch50
-rw-r--r--dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm10-skip-building-tests.patch51
-rw-r--r--dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm11-OpenCL-3.0-support.patch8453
-rw-r--r--dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm11-Remove-repo-name-in-LLVM-IR.patch50
-rw-r--r--dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm11-skip-building-tests.patch51
-rw-r--r--dynamic-layers/clang-layer/recipes-devtools/clang/llvm-project-source.bbappend35
13 files changed, 0 insertions, 18202 deletions
diff --git a/dynamic-layers/clang-layer/recipes-devtools/clang/files/0001-Fix-debug-info-of-work-item-builtin-translation-745.patch b/dynamic-layers/clang-layer/recipes-devtools/clang/files/0001-Fix-debug-info-of-work-item-builtin-translation-745.patch
deleted file mode 100644
index 923b871f..00000000
--- a/dynamic-layers/clang-layer/recipes-devtools/clang/files/0001-Fix-debug-info-of-work-item-builtin-translation-745.patch
+++ /dev/null
@@ -1,119 +0,0 @@
1From 200c200eb19602ffd7c8f29d0b2df9df1fd311bf Mon Sep 17 00:00:00 2001
2From: Naveen Saini <naveen.kumar.saini@intel.com>
3Date: Wed, 7 Apr 2021 17:44:20 +0800
4Subject: [PATCH] Fix debug info of work-item builtin translation (#745)
5
6debug info of work-item builtins are lost in both llvm IR -> spirv and
7spirv -> llvm IR translations. See #744
8
9Upstream-Status: Backport [https://github.com/KhronosGroup/SPIRV-LLVM-Translator/commit/c734c5c8bbd3012a09c610e4be68e90cc603c580]
10Signed-off-by: Wenju He <wenju.he@intel.com>
11Signed-off-by: Naveen Saini <naveen.kumar.saini@intel.com>
12---
13 lib/SPIRV/OCL20ToSPIRV.cpp | 5 ++-
14 lib/SPIRV/SPIRVReader.cpp | 1 +
15 test/DebugInfo/builtin-get-global-id.ll | 60 +++++++++++++++++++++++++
16 3 files changed, 65 insertions(+), 1 deletion(-)
17 create mode 100644 test/DebugInfo/builtin-get-global-id.ll
18
19diff --git a/lib/SPIRV/OCL20ToSPIRV.cpp b/lib/SPIRV/OCL20ToSPIRV.cpp
20index 1262c48c..a742c8cf 100644
21--- a/lib/SPIRV/OCL20ToSPIRV.cpp
22+++ b/lib/SPIRV/OCL20ToSPIRV.cpp
23@@ -1297,11 +1297,14 @@ void OCL20ToSPIRV::transWorkItemBuiltinsToVariables() {
24 for (auto UI = I.user_begin(), UE = I.user_end(); UI != UE; ++UI) {
25 auto CI = dyn_cast<CallInst>(*UI);
26 assert(CI && "invalid instruction");
27- Value *NewValue = new LoadInst(BV, "", CI);
28+ const DebugLoc &DLoc = CI->getDebugLoc();
29+ Instruction *NewValue = new LoadInst(BV, "", CI);
30+ NewValue->setDebugLoc(DLoc);
31 LLVM_DEBUG(dbgs() << "Transform: " << *CI << " => " << *NewValue << '\n');
32 if (IsVec) {
33 NewValue =
34 ExtractElementInst::Create(NewValue, CI->getArgOperand(0), "", CI);
35+ NewValue->setDebugLoc(DLoc);
36 LLVM_DEBUG(dbgs() << *NewValue << '\n');
37 }
38 NewValue->takeName(CI);
39diff --git a/lib/SPIRV/SPIRVReader.cpp b/lib/SPIRV/SPIRVReader.cpp
40index 16a3dd38..528f6663 100644
41--- a/lib/SPIRV/SPIRVReader.cpp
42+++ b/lib/SPIRV/SPIRVReader.cpp
43@@ -307,6 +307,7 @@ bool SPIRVToLLVM::transOCLBuiltinFromVariable(GlobalVariable *GV,
44 auto Replace = [&](std::vector<Value *> Arg, Instruction *I) {
45 auto Call = CallInst::Create(Func, Arg, "", I);
46 Call->takeName(I);
47+ Call->setDebugLoc(I->getDebugLoc());
48 setAttrByCalledFunc(Call);
49 SPIRVDBG(dbgs() << "[transOCLBuiltinFromVariable] " << *I << " -> " << *Call
50 << '\n';)
51diff --git a/test/DebugInfo/builtin-get-global-id.ll b/test/DebugInfo/builtin-get-global-id.ll
52new file mode 100644
53index 00000000..a4a00e63
54--- /dev/null
55+++ b/test/DebugInfo/builtin-get-global-id.ll
56@@ -0,0 +1,60 @@
57+; Check debug info of builtin get_global_id is preserved from LLVM IR to spirv
58+; and spirv to LLVM IR translation.
59+
60+; Original .cl source:
61+; kernel void test() {
62+; size_t gid = get_global_id(0);
63+; }
64+
65+; Command line:
66+; ./clang -cc1 1.cl -triple spir64 -cl-std=cl2.0 -emit-llvm -finclude-default-header -debug-info-kind=line-tables-only -O0
67+
68+; RUN: llvm-as %s -o %t.bc
69+; RUN: llvm-spirv %t.bc -spirv-text -o - | FileCheck %s --check-prefix CHECK-SPIRV
70+; RUN: llvm-spirv %t.bc -o %t.spv
71+; RUN: llvm-spirv -r %t.spv -o - | llvm-dis -o - | FileCheck %s
72+
73+target datalayout = "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024"
74+target triple = "spir64"
75+
76+; CHECK-SPIRV: ExtInst {{.*}} DebugScope
77+; CHECK-SPIRV-NEXT: Line {{[0-9]+}} 2 16
78+; CHECK-SPIRV-NEXT: Load {{[0-9]+}} [[LoadRes:[0-9]+]]
79+; CHECK-SPIRV-NEXT: CompositeExtract {{[0-9]+}} {{[0-9]+}} [[LoadRes]] 0
80+
81+; Function Attrs: convergent noinline norecurse nounwind optnone
82+define spir_kernel void @test() #0 !dbg !7 !kernel_arg_addr_space !2 !kernel_arg_access_qual !2 !kernel_arg_type !2 !kernel_arg_base_type !2 !kernel_arg_type_qual !2 {
83+entry:
84+ %gid = alloca i64, align 8
85+ %call = call spir_func i64 @_Z13get_global_idj(i32 0) #2, !dbg !10
86+; CHECK: %call = call spir_func i64 @_Z13get_global_idj(i32 0) #1, !dbg [[DBG:![0-9]+]]
87+ store i64 %call, i64* %gid, align 8, !dbg !11
88+ ret void, !dbg !12
89+}
90+
91+; Function Attrs: convergent nounwind readnone
92+declare spir_func i64 @_Z13get_global_idj(i32) #1
93+
94+attributes #0 = { convergent noinline norecurse nounwind optnone "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="none" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "uniform-work-group-size"="false" "unsafe-fp-math"="false" "use-soft-float"="false" }
95+attributes #1 = { convergent nounwind readnone "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="none" "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
96+attributes #2 = { convergent nounwind readnone }
97+
98+!llvm.dbg.cu = !{!0}
99+!llvm.module.flags = !{!3, !4}
100+!opencl.ocl.version = !{!5}
101+!opencl.spir.version = !{!5}
102+!llvm.ident = !{!6}
103+
104+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.0.0 (https://github.com/llvm/llvm-project.git b5bc56da8aa23dc57db9d286b0591dbcf9b1bdd3)", isOptimized: false, runtimeVersion: 0, emissionKind: LineTablesOnly, enums: !2, nameTableKind: None)
105+!1 = !DIFile(filename: "<stdin>", directory: "")
106+!2 = !{}
107+!3 = !{i32 2, !"Debug Info Version", i32 3}
108+!4 = !{i32 1, !"wchar_size", i32 4}
109+!5 = !{i32 2, i32 0}
110+!6 = !{!"clang version 12.0.0 (https://github.com/llvm/llvm-project.git b5bc56da8aa23dc57db9d286b0591dbcf9b1bdd3)"}
111+!7 = distinct !DISubprogram(name: "test", scope: !8, file: !8, line: 1, type: !9, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
112+!8 = !DIFile(filename: "1.cl", directory: "")
113+!9 = !DISubroutineType(types: !2)
114+!10 = !DILocation(line: 2, column: 16, scope: !7)
115+!11 = !DILocation(line: 2, column: 10, scope: !7)
116+!12 = !DILocation(line: 3, column: 1, scope: !7)
117--
1182.17.1
119
diff --git a/dynamic-layers/clang-layer/recipes-devtools/clang/files/0001-Memory-leak-fix-for-Managed-Static-Mutex.patch b/dynamic-layers/clang-layer/recipes-devtools/clang/files/0001-Memory-leak-fix-for-Managed-Static-Mutex.patch
deleted file mode 100644
index 103dad5e..00000000
--- a/dynamic-layers/clang-layer/recipes-devtools/clang/files/0001-Memory-leak-fix-for-Managed-Static-Mutex.patch
+++ /dev/null
@@ -1,35 +0,0 @@
1From c86c43b70e029b102543e8a85d269cbeb5c00279 Mon Sep 17 00:00:00 2001
2From: juanrod2 <>
3Date: Tue, 22 Dec 2020 08:33:08 +0800
4Subject: [PATCH] Memory leak fix for Managed Static Mutex
5
6Upstream-Status: Backport [Taken from opencl-clang patches; https://github.com/intel/opencl-clang/blob/ocl-open-100/patches/llvm/0001-Memory-leak-fix-for-Managed-Static-Mutex.patch]
7
8Signed-off-by: Naveen Saini <naveen.kumar.saini@intel.com>
9
10Cleaning a mutex inside ManagedStatic llvm class.
11---
12 llvm/lib/Support/ManagedStatic.cpp | 6 +++++-
13 1 file changed, 5 insertions(+), 1 deletion(-)
14
15diff --git a/llvm/lib/Support/ManagedStatic.cpp b/llvm/lib/Support/ManagedStatic.cpp
16index 053493f72fb5..6571580ccecf 100644
17--- a/llvm/lib/Support/ManagedStatic.cpp
18+++ b/llvm/lib/Support/ManagedStatic.cpp
19@@ -76,8 +76,12 @@ void ManagedStaticBase::destroy() const {
20
21 /// llvm_shutdown - Deallocate and destroy all ManagedStatic variables.
22 void llvm::llvm_shutdown() {
23- std::lock_guard<std::recursive_mutex> Lock(*getManagedStaticMutex());
24+ getManagedStaticMutex()->lock();
25
26 while (StaticList)
27 StaticList->destroy();
28+
29+ getManagedStaticMutex()->unlock();
30+ delete ManagedStaticMutex;
31+ ManagedStaticMutex = nullptr;
32 }
33--
342.29.2
35
diff --git a/dynamic-layers/clang-layer/recipes-devtools/clang/files/0002-Add-cl_khr_extended_subgroup-extensions.patch b/dynamic-layers/clang-layer/recipes-devtools/clang/files/0002-Add-cl_khr_extended_subgroup-extensions.patch
deleted file mode 100644
index cbe492c4..00000000
--- a/dynamic-layers/clang-layer/recipes-devtools/clang/files/0002-Add-cl_khr_extended_subgroup-extensions.patch
+++ /dev/null
@@ -1,812 +0,0 @@
1From 27d47f1a17c8921b07acc8cdc26e38cc609de4a9 Mon Sep 17 00:00:00 2001
2From: Naveen Saini <naveen.kumar.saini@intel.com>
3Date: Wed, 7 Apr 2021 16:38:38 +0800
4Subject: [PATCH 2/2] Add cl_khr_extended_subgroup extensions.
5
6Added extensions and their function declarations into
7the standard header.
8
9Patch by Piotr Fusik!
10
11Tags: #clang
12
13Upstream-Status: Backport [https://github.com/llvm/llvm-project/commit/4a4402f0d72167477a6252e4c3daf5089ebc8f9a]
14Signed-off-by: Anastasia Stulova <anastasia.stulova@arm.com>
15Signed-off-by: Naveen Saini <naveen.kumar.saini@intel.com>
16---
17 .../include/clang/Basic/OpenCLExtensions.def | 7 +
18 clang/lib/Headers/opencl-c.h | 668 ++++++++++++++++++
19 clang/test/SemaOpenCL/extension-version.cl | 83 +++
20 3 files changed, 758 insertions(+)
21
22diff --git a/clang/include/clang/Basic/OpenCLExtensions.def b/clang/include/clang/Basic/OpenCLExtensions.def
23index 608f78a13eef..d1574164f9b2 100644
24--- a/clang/include/clang/Basic/OpenCLExtensions.def
25+++ b/clang/include/clang/Basic/OpenCLExtensions.def
26@@ -74,6 +74,13 @@ OPENCLEXT_INTERNAL(cl_khr_mipmap_image_writes, 200, ~0U)
27 OPENCLEXT_INTERNAL(cl_khr_srgb_image_writes, 200, ~0U)
28 OPENCLEXT_INTERNAL(cl_khr_subgroups, 200, ~0U)
29 OPENCLEXT_INTERNAL(cl_khr_terminate_context, 200, ~0U)
30+OPENCLEXT_INTERNAL(cl_khr_subgroup_extended_types, 200, ~0U)
31+OPENCLEXT_INTERNAL(cl_khr_subgroup_non_uniform_vote, 200, ~0U)
32+OPENCLEXT_INTERNAL(cl_khr_subgroup_ballot, 200, ~0U)
33+OPENCLEXT_INTERNAL(cl_khr_subgroup_non_uniform_arithmetic, 200, ~0U)
34+OPENCLEXT_INTERNAL(cl_khr_subgroup_shuffle, 200, ~0U)
35+OPENCLEXT_INTERNAL(cl_khr_subgroup_shuffle_relative, 200, ~0U)
36+OPENCLEXT_INTERNAL(cl_khr_subgroup_clustered_reduce, 200, ~0U)
37
38 // Clang Extensions.
39 OPENCLEXT_INTERNAL(cl_clang_storage_class_specifiers, 100, ~0U)
40diff --git a/clang/lib/Headers/opencl-c.h b/clang/lib/Headers/opencl-c.h
41index 93a946cec5b1..67d900eb1c3d 100644
42--- a/clang/lib/Headers/opencl-c.h
43+++ b/clang/lib/Headers/opencl-c.h
44@@ -17530,6 +17530,674 @@ double __ovld __conv sub_group_scan_inclusive_max(double x);
45
46 #endif //cl_khr_subgroups cl_intel_subgroups
47
48+#if defined(cl_khr_subgroup_extended_types)
49+char __ovld __conv sub_group_broadcast( char value, uint index );
50+char2 __ovld __conv sub_group_broadcast( char2 value, uint index );
51+char3 __ovld __conv sub_group_broadcast( char3 value, uint index );
52+char4 __ovld __conv sub_group_broadcast( char4 value, uint index );
53+char8 __ovld __conv sub_group_broadcast( char8 value, uint index );
54+char16 __ovld __conv sub_group_broadcast( char16 value, uint index );
55+
56+uchar __ovld __conv sub_group_broadcast( uchar value, uint index );
57+uchar2 __ovld __conv sub_group_broadcast( uchar2 value, uint index );
58+uchar3 __ovld __conv sub_group_broadcast( uchar3 value, uint index );
59+uchar4 __ovld __conv sub_group_broadcast( uchar4 value, uint index );
60+uchar8 __ovld __conv sub_group_broadcast( uchar8 value, uint index );
61+uchar16 __ovld __conv sub_group_broadcast( uchar16 value, uint index );
62+
63+short __ovld __conv sub_group_broadcast( short value, uint index );
64+short2 __ovld __conv sub_group_broadcast( short2 value, uint index );
65+short3 __ovld __conv sub_group_broadcast( short3 value, uint index );
66+short4 __ovld __conv sub_group_broadcast( short4 value, uint index );
67+short8 __ovld __conv sub_group_broadcast( short8 value, uint index );
68+short16 __ovld __conv sub_group_broadcast( short16 value, uint index );
69+
70+ushort __ovld __conv sub_group_broadcast( ushort value, uint index );
71+ushort2 __ovld __conv sub_group_broadcast( ushort2 value, uint index );
72+ushort3 __ovld __conv sub_group_broadcast( ushort3 value, uint index );
73+ushort4 __ovld __conv sub_group_broadcast( ushort4 value, uint index );
74+ushort8 __ovld __conv sub_group_broadcast( ushort8 value, uint index );
75+ushort16 __ovld __conv sub_group_broadcast( ushort16 value, uint index );
76+
77+// scalar int broadcast is part of cl_khr_subgroups
78+int2 __ovld __conv sub_group_broadcast( int2 value, uint index );
79+int3 __ovld __conv sub_group_broadcast( int3 value, uint index );
80+int4 __ovld __conv sub_group_broadcast( int4 value, uint index );
81+int8 __ovld __conv sub_group_broadcast( int8 value, uint index );
82+int16 __ovld __conv sub_group_broadcast( int16 value, uint index );
83+
84+// scalar uint broadcast is part of cl_khr_subgroups
85+uint2 __ovld __conv sub_group_broadcast( uint2 value, uint index );
86+uint3 __ovld __conv sub_group_broadcast( uint3 value, uint index );
87+uint4 __ovld __conv sub_group_broadcast( uint4 value, uint index );
88+uint8 __ovld __conv sub_group_broadcast( uint8 value, uint index );
89+uint16 __ovld __conv sub_group_broadcast( uint16 value, uint index );
90+
91+// scalar long broadcast is part of cl_khr_subgroups
92+long2 __ovld __conv sub_group_broadcast( long2 value, uint index );
93+long3 __ovld __conv sub_group_broadcast( long3 value, uint index );
94+long4 __ovld __conv sub_group_broadcast( long4 value, uint index );
95+long8 __ovld __conv sub_group_broadcast( long8 value, uint index );
96+long16 __ovld __conv sub_group_broadcast( long16 value, uint index );
97+
98+// scalar ulong broadcast is part of cl_khr_subgroups
99+ulong2 __ovld __conv sub_group_broadcast( ulong2 value, uint index );
100+ulong3 __ovld __conv sub_group_broadcast( ulong3 value, uint index );
101+ulong4 __ovld __conv sub_group_broadcast( ulong4 value, uint index );
102+ulong8 __ovld __conv sub_group_broadcast( ulong8 value, uint index );
103+ulong16 __ovld __conv sub_group_broadcast( ulong16 value, uint index );
104+
105+// scalar float broadcast is part of cl_khr_subgroups
106+float2 __ovld __conv sub_group_broadcast( float2 value, uint index );
107+float3 __ovld __conv sub_group_broadcast( float3 value, uint index );
108+float4 __ovld __conv sub_group_broadcast( float4 value, uint index );
109+float8 __ovld __conv sub_group_broadcast( float8 value, uint index );
110+float16 __ovld __conv sub_group_broadcast( float16 value, uint index );
111+
112+char __ovld __conv sub_group_reduce_add( char value );
113+uchar __ovld __conv sub_group_reduce_add( uchar value );
114+short __ovld __conv sub_group_reduce_add( short value );
115+ushort __ovld __conv sub_group_reduce_add( ushort value );
116+
117+char __ovld __conv sub_group_reduce_min( char value );
118+uchar __ovld __conv sub_group_reduce_min( uchar value );
119+short __ovld __conv sub_group_reduce_min( short value );
120+ushort __ovld __conv sub_group_reduce_min( ushort value );
121+
122+char __ovld __conv sub_group_reduce_max( char value );
123+uchar __ovld __conv sub_group_reduce_max( uchar value );
124+short __ovld __conv sub_group_reduce_max( short value );
125+ushort __ovld __conv sub_group_reduce_max( ushort value );
126+
127+char __ovld __conv sub_group_scan_inclusive_add( char value );
128+uchar __ovld __conv sub_group_scan_inclusive_add( uchar value );
129+short __ovld __conv sub_group_scan_inclusive_add( short value );
130+ushort __ovld __conv sub_group_scan_inclusive_add( ushort value );
131+
132+char __ovld __conv sub_group_scan_inclusive_min( char value );
133+uchar __ovld __conv sub_group_scan_inclusive_min( uchar value );
134+short __ovld __conv sub_group_scan_inclusive_min( short value );
135+ushort __ovld __conv sub_group_scan_inclusive_min( ushort value );
136+
137+char __ovld __conv sub_group_scan_inclusive_max( char value );
138+uchar __ovld __conv sub_group_scan_inclusive_max( uchar value );
139+short __ovld __conv sub_group_scan_inclusive_max( short value );
140+ushort __ovld __conv sub_group_scan_inclusive_max( ushort value );
141+
142+char __ovld __conv sub_group_scan_exclusive_add( char value );
143+uchar __ovld __conv sub_group_scan_exclusive_add( uchar value );
144+short __ovld __conv sub_group_scan_exclusive_add( short value );
145+ushort __ovld __conv sub_group_scan_exclusive_add( ushort value );
146+
147+char __ovld __conv sub_group_scan_exclusive_min( char value );
148+uchar __ovld __conv sub_group_scan_exclusive_min( uchar value );
149+short __ovld __conv sub_group_scan_exclusive_min( short value );
150+ushort __ovld __conv sub_group_scan_exclusive_min( ushort value );
151+
152+char __ovld __conv sub_group_scan_exclusive_max( char value );
153+uchar __ovld __conv sub_group_scan_exclusive_max( uchar value );
154+short __ovld __conv sub_group_scan_exclusive_max( short value );
155+ushort __ovld __conv sub_group_scan_exclusive_max( ushort value );
156+
157+#if defined(cl_khr_fp16)
158+// scalar half broadcast is part of cl_khr_subgroups
159+half2 __ovld __conv sub_group_broadcast( half2 value, uint index );
160+half3 __ovld __conv sub_group_broadcast( half3 value, uint index );
161+half4 __ovld __conv sub_group_broadcast( half4 value, uint index );
162+half8 __ovld __conv sub_group_broadcast( half8 value, uint index );
163+half16 __ovld __conv sub_group_broadcast( half16 value, uint index );
164+#endif // cl_khr_fp16
165+
166+#if defined(cl_khr_fp64)
167+// scalar double broadcast is part of cl_khr_subgroups
168+double2 __ovld __conv sub_group_broadcast( double2 value, uint index );
169+double3 __ovld __conv sub_group_broadcast( double3 value, uint index );
170+double4 __ovld __conv sub_group_broadcast( double4 value, uint index );
171+double8 __ovld __conv sub_group_broadcast( double8 value, uint index );
172+double16 __ovld __conv sub_group_broadcast( double16 value, uint index );
173+#endif // cl_khr_fp64
174+
175+#endif // cl_khr_subgroup_extended_types
176+
177+#if defined(cl_khr_subgroup_non_uniform_vote)
178+int __ovld sub_group_elect(void);
179+int __ovld sub_group_non_uniform_all( int predicate );
180+int __ovld sub_group_non_uniform_any( int predicate );
181+
182+int __ovld sub_group_non_uniform_all_equal( char value );
183+int __ovld sub_group_non_uniform_all_equal( uchar value );
184+int __ovld sub_group_non_uniform_all_equal( short value );
185+int __ovld sub_group_non_uniform_all_equal( ushort value );
186+int __ovld sub_group_non_uniform_all_equal( int value );
187+int __ovld sub_group_non_uniform_all_equal( uint value );
188+int __ovld sub_group_non_uniform_all_equal( long value );
189+int __ovld sub_group_non_uniform_all_equal( ulong value );
190+int __ovld sub_group_non_uniform_all_equal( float value );
191+
192+#if defined(cl_khr_fp16)
193+int __ovld sub_group_non_uniform_all_equal( half value );
194+#endif // cl_khr_fp16
195+
196+#if defined(cl_khr_fp64)
197+int __ovld sub_group_non_uniform_all_equal( double value );
198+#endif // cl_khr_fp64
199+
200+#endif // cl_khr_subgroup_non_uniform_vote
201+
202+#if defined(cl_khr_subgroup_ballot)
203+char __ovld sub_group_non_uniform_broadcast( char value, uint index );
204+char2 __ovld sub_group_non_uniform_broadcast( char2 value, uint index );
205+char3 __ovld sub_group_non_uniform_broadcast( char3 value, uint index );
206+char4 __ovld sub_group_non_uniform_broadcast( char4 value, uint index );
207+char8 __ovld sub_group_non_uniform_broadcast( char8 value, uint index );
208+char16 __ovld sub_group_non_uniform_broadcast( char16 value, uint index );
209+
210+uchar __ovld sub_group_non_uniform_broadcast( uchar value, uint index );
211+uchar2 __ovld sub_group_non_uniform_broadcast( uchar2 value, uint index );
212+uchar3 __ovld sub_group_non_uniform_broadcast( uchar3 value, uint index );
213+uchar4 __ovld sub_group_non_uniform_broadcast( uchar4 value, uint index );
214+uchar8 __ovld sub_group_non_uniform_broadcast( uchar8 value, uint index );
215+uchar16 __ovld sub_group_non_uniform_broadcast( uchar16 value, uint index );
216+
217+short __ovld sub_group_non_uniform_broadcast( short value, uint index );
218+short2 __ovld sub_group_non_uniform_broadcast( short2 value, uint index );
219+short3 __ovld sub_group_non_uniform_broadcast( short3 value, uint index );
220+short4 __ovld sub_group_non_uniform_broadcast( short4 value, uint index );
221+short8 __ovld sub_group_non_uniform_broadcast( short8 value, uint index );
222+short16 __ovld sub_group_non_uniform_broadcast( short16 value, uint index );
223+
224+ushort __ovld sub_group_non_uniform_broadcast( ushort value, uint index );
225+ushort2 __ovld sub_group_non_uniform_broadcast( ushort2 value, uint index );
226+ushort3 __ovld sub_group_non_uniform_broadcast( ushort3 value, uint index );
227+ushort4 __ovld sub_group_non_uniform_broadcast( ushort4 value, uint index );
228+ushort8 __ovld sub_group_non_uniform_broadcast( ushort8 value, uint index );
229+ushort16 __ovld sub_group_non_uniform_broadcast( ushort16 value, uint index );
230+
231+int __ovld sub_group_non_uniform_broadcast( int value, uint index );
232+int2 __ovld sub_group_non_uniform_broadcast( int2 value, uint index );
233+int3 __ovld sub_group_non_uniform_broadcast( int3 value, uint index );
234+int4 __ovld sub_group_non_uniform_broadcast( int4 value, uint index );
235+int8 __ovld sub_group_non_uniform_broadcast( int8 value, uint index );
236+int16 __ovld sub_group_non_uniform_broadcast( int16 value, uint index );
237+
238+uint __ovld sub_group_non_uniform_broadcast( uint value, uint index );
239+uint2 __ovld sub_group_non_uniform_broadcast( uint2 value, uint index );
240+uint3 __ovld sub_group_non_uniform_broadcast( uint3 value, uint index );
241+uint4 __ovld sub_group_non_uniform_broadcast( uint4 value, uint index );
242+uint8 __ovld sub_group_non_uniform_broadcast( uint8 value, uint index );
243+uint16 __ovld sub_group_non_uniform_broadcast( uint16 value, uint index );
244+
245+long __ovld sub_group_non_uniform_broadcast( long value, uint index );
246+long2 __ovld sub_group_non_uniform_broadcast( long2 value, uint index );
247+long3 __ovld sub_group_non_uniform_broadcast( long3 value, uint index );
248+long4 __ovld sub_group_non_uniform_broadcast( long4 value, uint index );
249+long8 __ovld sub_group_non_uniform_broadcast( long8 value, uint index );
250+long16 __ovld sub_group_non_uniform_broadcast( long16 value, uint index );
251+
252+ulong __ovld sub_group_non_uniform_broadcast( ulong value, uint index );
253+ulong2 __ovld sub_group_non_uniform_broadcast( ulong2 value, uint index );
254+ulong3 __ovld sub_group_non_uniform_broadcast( ulong3 value, uint index );
255+ulong4 __ovld sub_group_non_uniform_broadcast( ulong4 value, uint index );
256+ulong8 __ovld sub_group_non_uniform_broadcast( ulong8 value, uint index );
257+ulong16 __ovld sub_group_non_uniform_broadcast( ulong16 value, uint index );
258+
259+float __ovld sub_group_non_uniform_broadcast( float value, uint index );
260+float2 __ovld sub_group_non_uniform_broadcast( float2 value, uint index );
261+float3 __ovld sub_group_non_uniform_broadcast( float3 value, uint index );
262+float4 __ovld sub_group_non_uniform_broadcast( float4 value, uint index );
263+float8 __ovld sub_group_non_uniform_broadcast( float8 value, uint index );
264+float16 __ovld sub_group_non_uniform_broadcast( float16 value, uint index );
265+
266+char __ovld sub_group_broadcast_first( char value );
267+uchar __ovld sub_group_broadcast_first( uchar value );
268+short __ovld sub_group_broadcast_first( short value );
269+ushort __ovld sub_group_broadcast_first( ushort value );
270+int __ovld sub_group_broadcast_first( int value );
271+uint __ovld sub_group_broadcast_first( uint value );
272+long __ovld sub_group_broadcast_first( long value );
273+ulong __ovld sub_group_broadcast_first( ulong value );
274+float __ovld sub_group_broadcast_first( float value );
275+
276+uint4 __ovld sub_group_ballot( int predicate );
277+int __ovld __cnfn sub_group_inverse_ballot( uint4 value );
278+int __ovld __cnfn sub_group_ballot_bit_extract( uint4 value, uint index );
279+uint __ovld __cnfn sub_group_ballot_bit_count( uint4 value );
280+
281+uint __ovld sub_group_ballot_inclusive_scan( uint4 value );
282+uint __ovld sub_group_ballot_exclusive_scan( uint4 value );
283+uint __ovld sub_group_ballot_find_lsb( uint4 value );
284+uint __ovld sub_group_ballot_find_msb( uint4 value );
285+
286+uint4 __ovld __cnfn get_sub_group_eq_mask(void);
287+uint4 __ovld __cnfn get_sub_group_ge_mask(void);
288+uint4 __ovld __cnfn get_sub_group_gt_mask(void);
289+uint4 __ovld __cnfn get_sub_group_le_mask(void);
290+uint4 __ovld __cnfn get_sub_group_lt_mask(void);
291+
292+#if defined(cl_khr_fp16)
293+half __ovld sub_group_non_uniform_broadcast( half value, uint index );
294+half2 __ovld sub_group_non_uniform_broadcast( half2 value, uint index );
295+half3 __ovld sub_group_non_uniform_broadcast( half3 value, uint index );
296+half4 __ovld sub_group_non_uniform_broadcast( half4 value, uint index );
297+half8 __ovld sub_group_non_uniform_broadcast( half8 value, uint index );
298+half16 __ovld sub_group_non_uniform_broadcast( half16 value, uint index );
299+
300+half __ovld sub_group_broadcast_first( half value );
301+#endif // cl_khr_fp16
302+
303+#if defined(cl_khr_fp64)
304+double __ovld sub_group_non_uniform_broadcast( double value, uint index );
305+double2 __ovld sub_group_non_uniform_broadcast( double2 value, uint index );
306+double3 __ovld sub_group_non_uniform_broadcast( double3 value, uint index );
307+double4 __ovld sub_group_non_uniform_broadcast( double4 value, uint index );
308+double8 __ovld sub_group_non_uniform_broadcast( double8 value, uint index );
309+double16 __ovld sub_group_non_uniform_broadcast( double16 value, uint index );
310+
311+double __ovld sub_group_broadcast_first( double value );
312+#endif // cl_khr_fp64
313+
314+#endif // cl_khr_subgroup_ballot
315+
316+#if defined(cl_khr_subgroup_non_uniform_arithmetic)
317+char __ovld sub_group_non_uniform_reduce_add( char value );
318+uchar __ovld sub_group_non_uniform_reduce_add( uchar value );
319+short __ovld sub_group_non_uniform_reduce_add( short value );
320+ushort __ovld sub_group_non_uniform_reduce_add( ushort value );
321+int __ovld sub_group_non_uniform_reduce_add( int value );
322+uint __ovld sub_group_non_uniform_reduce_add( uint value );
323+long __ovld sub_group_non_uniform_reduce_add( long value );
324+ulong __ovld sub_group_non_uniform_reduce_add( ulong value );
325+float __ovld sub_group_non_uniform_reduce_add( float value );
326+
327+char __ovld sub_group_non_uniform_reduce_mul( char value );
328+uchar __ovld sub_group_non_uniform_reduce_mul( uchar value );
329+short __ovld sub_group_non_uniform_reduce_mul( short value );
330+ushort __ovld sub_group_non_uniform_reduce_mul( ushort value );
331+int __ovld sub_group_non_uniform_reduce_mul( int value );
332+uint __ovld sub_group_non_uniform_reduce_mul( uint value );
333+long __ovld sub_group_non_uniform_reduce_mul( long value );
334+ulong __ovld sub_group_non_uniform_reduce_mul( ulong value );
335+float __ovld sub_group_non_uniform_reduce_mul( float value );
336+
337+char __ovld sub_group_non_uniform_reduce_min( char value );
338+uchar __ovld sub_group_non_uniform_reduce_min( uchar value );
339+short __ovld sub_group_non_uniform_reduce_min( short value );
340+ushort __ovld sub_group_non_uniform_reduce_min( ushort value );
341+int __ovld sub_group_non_uniform_reduce_min( int value );
342+uint __ovld sub_group_non_uniform_reduce_min( uint value );
343+long __ovld sub_group_non_uniform_reduce_min( long value );
344+ulong __ovld sub_group_non_uniform_reduce_min( ulong value );
345+float __ovld sub_group_non_uniform_reduce_min( float value );
346+
347+char __ovld sub_group_non_uniform_reduce_max( char value );
348+uchar __ovld sub_group_non_uniform_reduce_max( uchar value );
349+short __ovld sub_group_non_uniform_reduce_max( short value );
350+ushort __ovld sub_group_non_uniform_reduce_max( ushort value );
351+int __ovld sub_group_non_uniform_reduce_max( int value );
352+uint __ovld sub_group_non_uniform_reduce_max( uint value );
353+long __ovld sub_group_non_uniform_reduce_max( long value );
354+ulong __ovld sub_group_non_uniform_reduce_max( ulong value );
355+float __ovld sub_group_non_uniform_reduce_max( float value );
356+
357+char __ovld sub_group_non_uniform_scan_inclusive_add( char value );
358+uchar __ovld sub_group_non_uniform_scan_inclusive_add( uchar value );
359+short __ovld sub_group_non_uniform_scan_inclusive_add( short value );
360+ushort __ovld sub_group_non_uniform_scan_inclusive_add( ushort value );
361+int __ovld sub_group_non_uniform_scan_inclusive_add( int value );
362+uint __ovld sub_group_non_uniform_scan_inclusive_add( uint value );
363+long __ovld sub_group_non_uniform_scan_inclusive_add( long value );
364+ulong __ovld sub_group_non_uniform_scan_inclusive_add( ulong value );
365+float __ovld sub_group_non_uniform_scan_inclusive_add( float value );
366+
367+char __ovld sub_group_non_uniform_scan_inclusive_mul( char value );
368+uchar __ovld sub_group_non_uniform_scan_inclusive_mul( uchar value );
369+short __ovld sub_group_non_uniform_scan_inclusive_mul( short value );
370+ushort __ovld sub_group_non_uniform_scan_inclusive_mul( ushort value );
371+int __ovld sub_group_non_uniform_scan_inclusive_mul( int value );
372+uint __ovld sub_group_non_uniform_scan_inclusive_mul( uint value );
373+long __ovld sub_group_non_uniform_scan_inclusive_mul( long value );
374+ulong __ovld sub_group_non_uniform_scan_inclusive_mul( ulong value );
375+float __ovld sub_group_non_uniform_scan_inclusive_mul( float value );
376+
377+char __ovld sub_group_non_uniform_scan_inclusive_min( char value );
378+uchar __ovld sub_group_non_uniform_scan_inclusive_min( uchar value );
379+short __ovld sub_group_non_uniform_scan_inclusive_min( short value );
380+ushort __ovld sub_group_non_uniform_scan_inclusive_min( ushort value );
381+int __ovld sub_group_non_uniform_scan_inclusive_min( int value );
382+uint __ovld sub_group_non_uniform_scan_inclusive_min( uint value );
383+long __ovld sub_group_non_uniform_scan_inclusive_min( long value );
384+ulong __ovld sub_group_non_uniform_scan_inclusive_min( ulong value );
385+float __ovld sub_group_non_uniform_scan_inclusive_min( float value );
386+
387+char __ovld sub_group_non_uniform_scan_inclusive_max( char value );
388+uchar __ovld sub_group_non_uniform_scan_inclusive_max( uchar value );
389+short __ovld sub_group_non_uniform_scan_inclusive_max( short value );
390+ushort __ovld sub_group_non_uniform_scan_inclusive_max( ushort value );
391+int __ovld sub_group_non_uniform_scan_inclusive_max( int value );
392+uint __ovld sub_group_non_uniform_scan_inclusive_max( uint value );
393+long __ovld sub_group_non_uniform_scan_inclusive_max( long value );
394+ulong __ovld sub_group_non_uniform_scan_inclusive_max( ulong value );
395+float __ovld sub_group_non_uniform_scan_inclusive_max( float value );
396+
397+char __ovld sub_group_non_uniform_scan_exclusive_add( char value );
398+uchar __ovld sub_group_non_uniform_scan_exclusive_add( uchar value );
399+short __ovld sub_group_non_uniform_scan_exclusive_add( short value );
400+ushort __ovld sub_group_non_uniform_scan_exclusive_add( ushort value );
401+int __ovld sub_group_non_uniform_scan_exclusive_add( int value );
402+uint __ovld sub_group_non_uniform_scan_exclusive_add( uint value );
403+long __ovld sub_group_non_uniform_scan_exclusive_add( long value );
404+ulong __ovld sub_group_non_uniform_scan_exclusive_add( ulong value );
405+float __ovld sub_group_non_uniform_scan_exclusive_add( float value );
406+
407+char __ovld sub_group_non_uniform_scan_exclusive_mul( char value );
408+uchar __ovld sub_group_non_uniform_scan_exclusive_mul( uchar value );
409+short __ovld sub_group_non_uniform_scan_exclusive_mul( short value );
410+ushort __ovld sub_group_non_uniform_scan_exclusive_mul( ushort value );
411+int __ovld sub_group_non_uniform_scan_exclusive_mul( int value );
412+uint __ovld sub_group_non_uniform_scan_exclusive_mul( uint value );
413+long __ovld sub_group_non_uniform_scan_exclusive_mul( long value );
414+ulong __ovld sub_group_non_uniform_scan_exclusive_mul( ulong value );
415+float __ovld sub_group_non_uniform_scan_exclusive_mul( float value );
416+
417+char __ovld sub_group_non_uniform_scan_exclusive_min( char value );
418+uchar __ovld sub_group_non_uniform_scan_exclusive_min( uchar value );
419+short __ovld sub_group_non_uniform_scan_exclusive_min( short value );
420+ushort __ovld sub_group_non_uniform_scan_exclusive_min( ushort value );
421+int __ovld sub_group_non_uniform_scan_exclusive_min( int value );
422+uint __ovld sub_group_non_uniform_scan_exclusive_min( uint value );
423+long __ovld sub_group_non_uniform_scan_exclusive_min( long value );
424+ulong __ovld sub_group_non_uniform_scan_exclusive_min( ulong value );
425+float __ovld sub_group_non_uniform_scan_exclusive_min( float value );
426+
427+char __ovld sub_group_non_uniform_scan_exclusive_max( char value );
428+uchar __ovld sub_group_non_uniform_scan_exclusive_max( uchar value );
429+short __ovld sub_group_non_uniform_scan_exclusive_max( short value );
430+ushort __ovld sub_group_non_uniform_scan_exclusive_max( ushort value );
431+int __ovld sub_group_non_uniform_scan_exclusive_max( int value );
432+uint __ovld sub_group_non_uniform_scan_exclusive_max( uint value );
433+long __ovld sub_group_non_uniform_scan_exclusive_max( long value );
434+ulong __ovld sub_group_non_uniform_scan_exclusive_max( ulong value );
435+float __ovld sub_group_non_uniform_scan_exclusive_max( float value );
436+
437+char __ovld sub_group_non_uniform_reduce_and( char value );
438+uchar __ovld sub_group_non_uniform_reduce_and( uchar value );
439+short __ovld sub_group_non_uniform_reduce_and( short value );
440+ushort __ovld sub_group_non_uniform_reduce_and( ushort value );
441+int __ovld sub_group_non_uniform_reduce_and( int value );
442+uint __ovld sub_group_non_uniform_reduce_and( uint value );
443+long __ovld sub_group_non_uniform_reduce_and( long value );
444+ulong __ovld sub_group_non_uniform_reduce_and( ulong value );
445+
446+char __ovld sub_group_non_uniform_reduce_or( char value );
447+uchar __ovld sub_group_non_uniform_reduce_or( uchar value );
448+short __ovld sub_group_non_uniform_reduce_or( short value );
449+ushort __ovld sub_group_non_uniform_reduce_or( ushort value );
450+int __ovld sub_group_non_uniform_reduce_or( int value );
451+uint __ovld sub_group_non_uniform_reduce_or( uint value );
452+long __ovld sub_group_non_uniform_reduce_or( long value );
453+ulong __ovld sub_group_non_uniform_reduce_or( ulong value );
454+
455+char __ovld sub_group_non_uniform_reduce_xor( char value );
456+uchar __ovld sub_group_non_uniform_reduce_xor( uchar value );
457+short __ovld sub_group_non_uniform_reduce_xor( short value );
458+ushort __ovld sub_group_non_uniform_reduce_xor( ushort value );
459+int __ovld sub_group_non_uniform_reduce_xor( int value );
460+uint __ovld sub_group_non_uniform_reduce_xor( uint value );
461+long __ovld sub_group_non_uniform_reduce_xor( long value );
462+ulong __ovld sub_group_non_uniform_reduce_xor( ulong value );
463+
464+char __ovld sub_group_non_uniform_scan_inclusive_and( char value );
465+uchar __ovld sub_group_non_uniform_scan_inclusive_and( uchar value );
466+short __ovld sub_group_non_uniform_scan_inclusive_and( short value );
467+ushort __ovld sub_group_non_uniform_scan_inclusive_and( ushort value );
468+int __ovld sub_group_non_uniform_scan_inclusive_and( int value );
469+uint __ovld sub_group_non_uniform_scan_inclusive_and( uint value );
470+long __ovld sub_group_non_uniform_scan_inclusive_and( long value );
471+ulong __ovld sub_group_non_uniform_scan_inclusive_and( ulong value );
472+
473+char __ovld sub_group_non_uniform_scan_inclusive_or( char value );
474+uchar __ovld sub_group_non_uniform_scan_inclusive_or( uchar value );
475+short __ovld sub_group_non_uniform_scan_inclusive_or( short value );
476+ushort __ovld sub_group_non_uniform_scan_inclusive_or( ushort value );
477+int __ovld sub_group_non_uniform_scan_inclusive_or( int value );
478+uint __ovld sub_group_non_uniform_scan_inclusive_or( uint value );
479+long __ovld sub_group_non_uniform_scan_inclusive_or( long value );
480+ulong __ovld sub_group_non_uniform_scan_inclusive_or( ulong value );
481+
482+char __ovld sub_group_non_uniform_scan_inclusive_xor( char value );
483+uchar __ovld sub_group_non_uniform_scan_inclusive_xor( uchar value );
484+short __ovld sub_group_non_uniform_scan_inclusive_xor( short value );
485+ushort __ovld sub_group_non_uniform_scan_inclusive_xor( ushort value );
486+int __ovld sub_group_non_uniform_scan_inclusive_xor( int value );
487+uint __ovld sub_group_non_uniform_scan_inclusive_xor( uint value );
488+long __ovld sub_group_non_uniform_scan_inclusive_xor( long value );
489+ulong __ovld sub_group_non_uniform_scan_inclusive_xor( ulong value );
490+
491+char __ovld sub_group_non_uniform_scan_exclusive_and( char value );
492+uchar __ovld sub_group_non_uniform_scan_exclusive_and( uchar value );
493+short __ovld sub_group_non_uniform_scan_exclusive_and( short value );
494+ushort __ovld sub_group_non_uniform_scan_exclusive_and( ushort value );
495+int __ovld sub_group_non_uniform_scan_exclusive_and( int value );
496+uint __ovld sub_group_non_uniform_scan_exclusive_and( uint value );
497+long __ovld sub_group_non_uniform_scan_exclusive_and( long value );
498+ulong __ovld sub_group_non_uniform_scan_exclusive_and( ulong value );
499+
500+char __ovld sub_group_non_uniform_scan_exclusive_or( char value );
501+uchar __ovld sub_group_non_uniform_scan_exclusive_or( uchar value );
502+short __ovld sub_group_non_uniform_scan_exclusive_or( short value );
503+ushort __ovld sub_group_non_uniform_scan_exclusive_or( ushort value );
504+int __ovld sub_group_non_uniform_scan_exclusive_or( int value );
505+uint __ovld sub_group_non_uniform_scan_exclusive_or( uint value );
506+long __ovld sub_group_non_uniform_scan_exclusive_or( long value );
507+ulong __ovld sub_group_non_uniform_scan_exclusive_or( ulong value );
508+
509+char __ovld sub_group_non_uniform_scan_exclusive_xor( char value );
510+uchar __ovld sub_group_non_uniform_scan_exclusive_xor( uchar value );
511+short __ovld sub_group_non_uniform_scan_exclusive_xor( short value );
512+ushort __ovld sub_group_non_uniform_scan_exclusive_xor( ushort value );
513+int __ovld sub_group_non_uniform_scan_exclusive_xor( int value );
514+uint __ovld sub_group_non_uniform_scan_exclusive_xor( uint value );
515+long __ovld sub_group_non_uniform_scan_exclusive_xor( long value );
516+ulong __ovld sub_group_non_uniform_scan_exclusive_xor( ulong value );
517+
518+int __ovld sub_group_non_uniform_reduce_logical_and( int predicate );
519+int __ovld sub_group_non_uniform_reduce_logical_or( int predicate );
520+int __ovld sub_group_non_uniform_reduce_logical_xor( int predicate );
521+
522+int __ovld sub_group_non_uniform_scan_inclusive_logical_and( int predicate );
523+int __ovld sub_group_non_uniform_scan_inclusive_logical_or( int predicate );
524+int __ovld sub_group_non_uniform_scan_inclusive_logical_xor( int predicate );
525+
526+int __ovld sub_group_non_uniform_scan_exclusive_logical_and( int predicate );
527+int __ovld sub_group_non_uniform_scan_exclusive_logical_or( int predicate );
528+int __ovld sub_group_non_uniform_scan_exclusive_logical_xor( int predicate );
529+
530+#if defined(cl_khr_fp16)
531+half __ovld sub_group_non_uniform_reduce_add( half value );
532+half __ovld sub_group_non_uniform_reduce_mul( half value );
533+half __ovld sub_group_non_uniform_reduce_min( half value );
534+half __ovld sub_group_non_uniform_reduce_max( half value );
535+half __ovld sub_group_non_uniform_scan_inclusive_add( half value );
536+half __ovld sub_group_non_uniform_scan_inclusive_mul( half value );
537+half __ovld sub_group_non_uniform_scan_inclusive_min( half value );
538+half __ovld sub_group_non_uniform_scan_inclusive_max( half value );
539+half __ovld sub_group_non_uniform_scan_exclusive_add( half value );
540+half __ovld sub_group_non_uniform_scan_exclusive_mul( half value );
541+half __ovld sub_group_non_uniform_scan_exclusive_min( half value );
542+half __ovld sub_group_non_uniform_scan_exclusive_max( half value );
543+#endif // cl_khr_fp16
544+
545+#if defined(cl_khr_fp64)
546+double __ovld sub_group_non_uniform_reduce_add( double value );
547+double __ovld sub_group_non_uniform_reduce_mul( double value );
548+double __ovld sub_group_non_uniform_reduce_min( double value );
549+double __ovld sub_group_non_uniform_reduce_max( double value );
550+double __ovld sub_group_non_uniform_scan_inclusive_add( double value );
551+double __ovld sub_group_non_uniform_scan_inclusive_mul( double value );
552+double __ovld sub_group_non_uniform_scan_inclusive_min( double value );
553+double __ovld sub_group_non_uniform_scan_inclusive_max( double value );
554+double __ovld sub_group_non_uniform_scan_exclusive_add( double value );
555+double __ovld sub_group_non_uniform_scan_exclusive_mul( double value );
556+double __ovld sub_group_non_uniform_scan_exclusive_min( double value );
557+double __ovld sub_group_non_uniform_scan_exclusive_max( double value );
558+#endif // cl_khr_fp64
559+
560+#endif // cl_khr_subgroup_non_uniform_arithmetic
561+
562+#if defined(cl_khr_subgroup_shuffle)
563+char __ovld sub_group_shuffle( char value, uint index );
564+uchar __ovld sub_group_shuffle( uchar value, uint index );
565+short __ovld sub_group_shuffle( short value, uint index );
566+ushort __ovld sub_group_shuffle( ushort value, uint index );
567+int __ovld sub_group_shuffle( int value, uint index );
568+uint __ovld sub_group_shuffle( uint value, uint index );
569+long __ovld sub_group_shuffle( long value, uint index );
570+ulong __ovld sub_group_shuffle( ulong value, uint index );
571+float __ovld sub_group_shuffle( float value, uint index );
572+
573+char __ovld sub_group_shuffle_xor( char value, uint mask );
574+uchar __ovld sub_group_shuffle_xor( uchar value, uint mask );
575+short __ovld sub_group_shuffle_xor( short value, uint mask );
576+ushort __ovld sub_group_shuffle_xor( ushort value, uint mask );
577+int __ovld sub_group_shuffle_xor( int value, uint mask );
578+uint __ovld sub_group_shuffle_xor( uint value, uint mask );
579+long __ovld sub_group_shuffle_xor( long value, uint mask );
580+ulong __ovld sub_group_shuffle_xor( ulong value, uint mask );
581+float __ovld sub_group_shuffle_xor( float value, uint mask );
582+
583+#if defined(cl_khr_fp16)
584+half __ovld sub_group_shuffle( half value, uint index );
585+half __ovld sub_group_shuffle_xor( half value, uint mask );
586+#endif // cl_khr_fp16
587+
588+#if defined(cl_khr_fp64)
589+double __ovld sub_group_shuffle( double value, uint index );
590+double __ovld sub_group_shuffle_xor( double value, uint mask );
591+#endif // cl_khr_fp64
592+
593+#endif // cl_khr_subgroup_shuffle
594+
595+#if defined(cl_khr_subgroup_shuffle_relative)
596+char __ovld sub_group_shuffle_up( char value, uint delta );
597+uchar __ovld sub_group_shuffle_up( uchar value, uint delta );
598+short __ovld sub_group_shuffle_up( short value, uint delta );
599+ushort __ovld sub_group_shuffle_up( ushort value, uint delta );
600+int __ovld sub_group_shuffle_up( int value, uint delta );
601+uint __ovld sub_group_shuffle_up( uint value, uint delta );
602+long __ovld sub_group_shuffle_up( long value, uint delta );
603+ulong __ovld sub_group_shuffle_up( ulong value, uint delta );
604+float __ovld sub_group_shuffle_up( float value, uint delta );
605+
606+char __ovld sub_group_shuffle_down( char value, uint delta );
607+uchar __ovld sub_group_shuffle_down( uchar value, uint delta );
608+short __ovld sub_group_shuffle_down( short value, uint delta );
609+ushort __ovld sub_group_shuffle_down( ushort value, uint delta );
610+int __ovld sub_group_shuffle_down( int value, uint delta );
611+uint __ovld sub_group_shuffle_down( uint value, uint delta );
612+long __ovld sub_group_shuffle_down( long value, uint delta );
613+ulong __ovld sub_group_shuffle_down( ulong value, uint delta );
614+float __ovld sub_group_shuffle_down( float value, uint delta );
615+
616+#if defined(cl_khr_fp16)
617+half __ovld sub_group_shuffle_up( half value, uint delta );
618+half __ovld sub_group_shuffle_down( half value, uint delta );
619+#endif // cl_khr_fp16
620+
621+#if defined(cl_khr_fp64)
622+double __ovld sub_group_shuffle_up( double value, uint delta );
623+double __ovld sub_group_shuffle_down( double value, uint delta );
624+#endif // cl_khr_fp64
625+
626+#endif // cl_khr_subgroup_shuffle_relative
627+
628+#if defined(cl_khr_subgroup_clustered_reduce)
629+char __ovld sub_group_clustered_reduce_add( char value, uint clustersize );
630+uchar __ovld sub_group_clustered_reduce_add( uchar value, uint clustersize );
631+short __ovld sub_group_clustered_reduce_add( short value, uint clustersize );
632+ushort __ovld sub_group_clustered_reduce_add( ushort value, uint clustersize );
633+int __ovld sub_group_clustered_reduce_add( int value, uint clustersize );
634+uint __ovld sub_group_clustered_reduce_add( uint value, uint clustersize );
635+long __ovld sub_group_clustered_reduce_add( long value, uint clustersize );
636+ulong __ovld sub_group_clustered_reduce_add( ulong value, uint clustersize );
637+float __ovld sub_group_clustered_reduce_add( float value, uint clustersize );
638+
639+char __ovld sub_group_clustered_reduce_mul( char value, uint clustersize );
640+uchar __ovld sub_group_clustered_reduce_mul( uchar value, uint clustersize );
641+short __ovld sub_group_clustered_reduce_mul( short value, uint clustersize );
642+ushort __ovld sub_group_clustered_reduce_mul( ushort value, uint clustersize );
643+int __ovld sub_group_clustered_reduce_mul( int value, uint clustersize );
644+uint __ovld sub_group_clustered_reduce_mul( uint value, uint clustersize );
645+long __ovld sub_group_clustered_reduce_mul( long value, uint clustersize );
646+ulong __ovld sub_group_clustered_reduce_mul( ulong value, uint clustersize );
647+float __ovld sub_group_clustered_reduce_mul( float value, uint clustersize );
648+
649+char __ovld sub_group_clustered_reduce_min( char value, uint clustersize );
650+uchar __ovld sub_group_clustered_reduce_min( uchar value, uint clustersize );
651+short __ovld sub_group_clustered_reduce_min( short value, uint clustersize );
652+ushort __ovld sub_group_clustered_reduce_min( ushort value, uint clustersize );
653+int __ovld sub_group_clustered_reduce_min( int value, uint clustersize );
654+uint __ovld sub_group_clustered_reduce_min( uint value, uint clustersize );
655+long __ovld sub_group_clustered_reduce_min( long value, uint clustersize );
656+ulong __ovld sub_group_clustered_reduce_min( ulong value, uint clustersize );
657+float __ovld sub_group_clustered_reduce_min( float value, uint clustersize );
658+
659+char __ovld sub_group_clustered_reduce_max( char value, uint clustersize );
660+uchar __ovld sub_group_clustered_reduce_max( uchar value, uint clustersize );
661+short __ovld sub_group_clustered_reduce_max( short value, uint clustersize );
662+ushort __ovld sub_group_clustered_reduce_max( ushort value, uint clustersize );
663+int __ovld sub_group_clustered_reduce_max( int value, uint clustersize );
664+uint __ovld sub_group_clustered_reduce_max( uint value, uint clustersize );
665+long __ovld sub_group_clustered_reduce_max( long value, uint clustersize );
666+ulong __ovld sub_group_clustered_reduce_max( ulong value, uint clustersize );
667+float __ovld sub_group_clustered_reduce_max( float value, uint clustersize );
668+
669+char __ovld sub_group_clustered_reduce_and( char value, uint clustersize );
670+uchar __ovld sub_group_clustered_reduce_and( uchar value, uint clustersize );
671+short __ovld sub_group_clustered_reduce_and( short value, uint clustersize );
672+ushort __ovld sub_group_clustered_reduce_and( ushort value, uint clustersize );
673+int __ovld sub_group_clustered_reduce_and( int value, uint clustersize );
674+uint __ovld sub_group_clustered_reduce_and( uint value, uint clustersize );
675+long __ovld sub_group_clustered_reduce_and( long value, uint clustersize );
676+ulong __ovld sub_group_clustered_reduce_and( ulong value, uint clustersize );
677+
678+char __ovld sub_group_clustered_reduce_or( char value, uint clustersize );
679+uchar __ovld sub_group_clustered_reduce_or( uchar value, uint clustersize );
680+short __ovld sub_group_clustered_reduce_or( short value, uint clustersize );
681+ushort __ovld sub_group_clustered_reduce_or( ushort value, uint clustersize );
682+int __ovld sub_group_clustered_reduce_or( int value, uint clustersize );
683+uint __ovld sub_group_clustered_reduce_or( uint value, uint clustersize );
684+long __ovld sub_group_clustered_reduce_or( long value, uint clustersize );
685+ulong __ovld sub_group_clustered_reduce_or( ulong value, uint clustersize );
686+
687+char __ovld sub_group_clustered_reduce_xor( char value, uint clustersize );
688+uchar __ovld sub_group_clustered_reduce_xor( uchar value, uint clustersize );
689+short __ovld sub_group_clustered_reduce_xor( short value, uint clustersize );
690+ushort __ovld sub_group_clustered_reduce_xor( ushort value, uint clustersize );
691+int __ovld sub_group_clustered_reduce_xor( int value, uint clustersize );
692+uint __ovld sub_group_clustered_reduce_xor( uint value, uint clustersize );
693+long __ovld sub_group_clustered_reduce_xor( long value, uint clustersize );
694+ulong __ovld sub_group_clustered_reduce_xor( ulong value, uint clustersize );
695+
696+int __ovld sub_group_clustered_reduce_logical_and( int predicate, uint clustersize );
697+int __ovld sub_group_clustered_reduce_logical_or( int predicate, uint clustersize );
698+int __ovld sub_group_clustered_reduce_logical_xor( int predicate, uint clustersize );
699+
700+#if defined(cl_khr_fp16)
701+half __ovld sub_group_clustered_reduce_add( half value, uint clustersize );
702+half __ovld sub_group_clustered_reduce_mul( half value, uint clustersize );
703+half __ovld sub_group_clustered_reduce_min( half value, uint clustersize );
704+half __ovld sub_group_clustered_reduce_max( half value, uint clustersize );
705+#endif // cl_khr_fp16
706+
707+#if defined(cl_khr_fp64)
708+double __ovld sub_group_clustered_reduce_add( double value, uint clustersize );
709+double __ovld sub_group_clustered_reduce_mul( double value, uint clustersize );
710+double __ovld sub_group_clustered_reduce_min( double value, uint clustersize );
711+double __ovld sub_group_clustered_reduce_max( double value, uint clustersize );
712+#endif // cl_khr_fp64
713+
714+#endif // cl_khr_subgroup_clustered_reduce
715+
716 #if defined(cl_intel_subgroups)
717 // Intel-Specific Sub Group Functions
718 float __ovld __conv intel_sub_group_shuffle( float x, uint c );
719diff --git a/clang/test/SemaOpenCL/extension-version.cl b/clang/test/SemaOpenCL/extension-version.cl
720index 0e6bbb7d3bcd..86c78143a0eb 100644
721--- a/clang/test/SemaOpenCL/extension-version.cl
722+++ b/clang/test/SemaOpenCL/extension-version.cl
723@@ -333,3 +333,86 @@
724 #endif
725 #pragma OPENCL EXTENSION cl_intel_device_side_avc_motion_estimation : enable
726
727+#if (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200)
728+#ifndef cl_khr_subgroup_extended_types
729+#error "Missing cl_khr_subgroup_extended_types"
730+#endif
731+#else
732+#ifdef cl_khr_subgroup_extended_types
733+#error "Incorrect cl_khr_subgroup_extended_types define"
734+#endif
735+// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_subgroup_extended_types' - ignoring}}
736+#endif
737+#pragma OPENCL EXTENSION cl_khr_subgroup_extended_types : enable
738+
739+#if (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200)
740+#ifndef cl_khr_subgroup_non_uniform_vote
741+#error "Missing cl_khr_subgroup_non_uniform_vote"
742+#endif
743+#else
744+#ifdef cl_khr_subgroup_non_uniform_vote
745+#error "Incorrect cl_khr_subgroup_non_uniform_vote define"
746+#endif
747+// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_subgroup_non_uniform_vote' - ignoring}}
748+#endif
749+#pragma OPENCL EXTENSION cl_khr_subgroup_non_uniform_vote : enable
750+
751+#if (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200)
752+#ifndef cl_khr_subgroup_ballot
753+#error "Missing cl_khr_subgroup_ballot"
754+#endif
755+#else
756+#ifdef cl_khr_subgroup_ballot
757+#error "Incorrect cl_khr_subgroup_ballot define"
758+#endif
759+// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_subgroup_ballot' - ignoring}}
760+#endif
761+#pragma OPENCL EXTENSION cl_khr_subgroup_ballot : enable
762+
763+#if (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200)
764+#ifndef cl_khr_subgroup_non_uniform_arithmetic
765+#error "Missing cl_khr_subgroup_non_uniform_arithmetic"
766+#endif
767+#else
768+#ifdef cl_khr_subgroup_non_uniform_arithmetic
769+#error "Incorrect cl_khr_subgroup_non_uniform_arithmetic define"
770+#endif
771+// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_subgroup_non_uniform_arithmetic' - ignoring}}
772+#endif
773+#pragma OPENCL EXTENSION cl_khr_subgroup_non_uniform_arithmetic : enable
774+
775+#if (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200)
776+#ifndef cl_khr_subgroup_shuffle
777+#error "Missing cl_khr_subgroup_shuffle"
778+#endif
779+#else
780+#ifdef cl_khr_subgroup_shuffle
781+#error "Incorrect cl_khr_subgroup_shuffle define"
782+#endif
783+// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_subgroup_shuffle' - ignoring}}
784+#endif
785+#pragma OPENCL EXTENSION cl_khr_subgroup_shuffle : enable
786+
787+#if (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200)
788+#ifndef cl_khr_subgroup_shuffle_relative
789+#error "Missing cl_khr_subgroup_shuffle_relative"
790+#endif
791+#else
792+#ifdef cl_khr_subgroup_shuffle_relative
793+#error "Incorrect cl_khr_subgroup_shuffle_relative define"
794+#endif
795+// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_subgroup_shuffle_relative' - ignoring}}
796+#endif
797+#pragma OPENCL EXTENSION cl_khr_subgroup_shuffle_relative : enable
798+
799+#if (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200)
800+#ifndef cl_khr_subgroup_clustered_reduce
801+#error "Missing cl_khr_subgroup_clustered_reduce"
802+#endif
803+#else
804+#ifdef cl_khr_subgroup_clustered_reduce
805+#error "Incorrect cl_khr_subgroup_clustered_reduce define"
806+#endif
807+// expected-warning@+2{{unsupported OpenCL extension 'cl_khr_subgroup_clustered_reduce' - ignoring}}
808+#endif
809+#pragma OPENCL EXTENSION cl_khr_subgroup_clustered_reduce : enable
810--
8112.17.1
812
diff --git a/dynamic-layers/clang-layer/recipes-devtools/clang/files/BasicBlockUtils-Add-metadata-fixing-in-SplitBlockPre.patch b/dynamic-layers/clang-layer/recipes-devtools/clang/files/BasicBlockUtils-Add-metadata-fixing-in-SplitBlockPre.patch
deleted file mode 100644
index cd519971..00000000
--- a/dynamic-layers/clang-layer/recipes-devtools/clang/files/BasicBlockUtils-Add-metadata-fixing-in-SplitBlockPre.patch
+++ /dev/null
@@ -1,111 +0,0 @@
1From eeb816d95f0910bd246e37bb2bb3923acf0edf6b Mon Sep 17 00:00:00 2001
2From: Aleksander Us <aleksander.us@intel.com>
3Date: Mon, 26 Aug 2019 15:47:41 +0300
4Subject: [PATCH] [BasicBlockUtils] Add metadata fixing in
5 SplitBlockPredecessors.
6
7In case when BB is header of some loop and predecessor is latch of
8this loop, metadata was not attached to newly created basic block.
9This led to loss of loop metadata for other passes.
10
11Upstream-Status: Submitted [https://reviews.llvm.org/D66892]
12
13https://github.com/intel/llvm-patches/commit/8af4449e2d201707f7f2f832b473a0439e255f32
14
15Signed-off-by: Naveen Saini <naveen.kumar.saini@intel.com>
16---
17 lib/Transforms/Utils/BasicBlockUtils.cpp | 23 ++++++++----
18 test/Transforms/LoopSimplify/loop_metadata.ll | 36 +++++++++++++++++++
19 2 files changed, 52 insertions(+), 7 deletions(-)
20 create mode 100644 test/Transforms/LoopSimplify/loop_metadata.ll
21
22diff --git a/lib/Transforms/Utils/BasicBlockUtils.cpp b/lib/Transforms/Utils/BasicBlockUtils.cpp
23index 5fa371377c8..3a90ae061fb 100644
24--- a/lib/Transforms/Utils/BasicBlockUtils.cpp
25+++ b/lib/Transforms/Utils/BasicBlockUtils.cpp
26@@ -579,24 +579,33 @@ BasicBlock *llvm::SplitBlockPredecessors(BasicBlock *BB,
27
28 // The new block unconditionally branches to the old block.
29 BranchInst *BI = BranchInst::Create(BB, NewBB);
30+ bool IsBBHeader = LI && LI->isLoopHeader(BB);
31+ Loop *BBLoop = LI ? LI->getLoopFor(BB) : nullptr;
32 // Splitting the predecessors of a loop header creates a preheader block.
33- if (LI && LI->isLoopHeader(BB))
34+ if (IsBBHeader)
35 // Using the loop start line number prevents debuggers stepping into the
36 // loop body for this instruction.
37- BI->setDebugLoc(LI->getLoopFor(BB)->getStartLoc());
38+ BI->setDebugLoc(BBLoop->getStartLoc());
39 else
40 BI->setDebugLoc(BB->getFirstNonPHIOrDbg()->getDebugLoc());
41
42 // Move the edges from Preds to point to NewBB instead of BB.
43- for (unsigned i = 0, e = Preds.size(); i != e; ++i) {
44+ for (BasicBlock *Pred : Preds) {
45+ Instruction *PI = Pred->getTerminator();
46 // This is slightly more strict than necessary; the minimum requirement
47 // is that there be no more than one indirectbr branching to BB. And
48 // all BlockAddress uses would need to be updated.
49- assert(!isa<IndirectBrInst>(Preds[i]->getTerminator()) &&
50+ assert(!isa<IndirectBrInst>(PI) &&
51 "Cannot split an edge from an IndirectBrInst");
52- assert(!isa<CallBrInst>(Preds[i]->getTerminator()) &&
53- "Cannot split an edge from a CallBrInst");
54- Preds[i]->getTerminator()->replaceUsesOfWith(BB, NewBB);
55+ assert(!isa<CallBrInst>(PI) && "Cannot split an edge from a CallBrInst");
56+ if (IsBBHeader && BBLoop->contains(Pred) && BBLoop->isLoopLatch(Pred)) {
57+ // Update loop metadata if it exists.
58+ if (MDNode *LoopMD = PI->getMetadata(LLVMContext::MD_loop)) {
59+ BI->setMetadata(LLVMContext::MD_loop, LoopMD);
60+ PI->setMetadata(LLVMContext::MD_loop, nullptr);
61+ }
62+ }
63+ PI->replaceUsesOfWith(BB, NewBB);
64 }
65
66 // Insert a new PHI node into NewBB for every PHI node in BB and that new PHI
67diff --git a/test/Transforms/LoopSimplify/loop_metadata.ll b/test/Transforms/LoopSimplify/loop_metadata.ll
68new file mode 100644
69index 00000000000..c15c92fe3ae
70--- /dev/null
71+++ b/test/Transforms/LoopSimplify/loop_metadata.ll
72@@ -0,0 +1,36 @@
73+; RUN: opt -S -loop-simplify < %s | FileCheck %s
74+
75+; CHECK: for.cond.loopexit:
76+; CHECK: br label %for.cond, !llvm.loop !0
77+; CHECK: br i1 %cmp1, label %for.body1, label %for.cond.loopexit
78+
79+define void @foo() {
80+entry:
81+ br label %for.cond
82+
83+for.cond: ; preds = %for.cond1, %entry
84+ %j = phi i32 [ 0, %entry ], [ %add, %for.cond1 ]
85+ %cmp = icmp ult i32 %j, 8
86+ br i1 %cmp, label %for.body, label %for.end
87+
88+for.body: ; preds = %for.cond
89+ %dummy1 = add i32 1, 1
90+ %add = add nuw nsw i32 %j, 1
91+ br label %for.cond1
92+
93+for.cond1: ; preds = %for.body1, %for.body
94+ %i.0 = phi i32 [ 1, %for.body ], [ %inc, %for.body1 ]
95+ %cmp1 = icmp ult i32 %i.0, 8
96+ br i1 %cmp1, label %for.body1, label %for.cond, !llvm.loop !0
97+
98+for.body1: ; preds = %for.cond1
99+ %dummy2 = add i32 1, 1
100+ %inc = add nuw nsw i32 %i.0, 1
101+ br label %for.cond1
102+
103+for.end: ; preds = %for.cond
104+ ret void
105+}
106+
107+!0 = distinct !{!0, !1}
108+!1 = !{!"llvm.loop.unroll.full"}
109--
1102.18.0
111
diff --git a/dynamic-layers/clang-layer/recipes-devtools/clang/files/IndVarSimplify-Do-not-use-SCEV-expander-for-IVCount-.patch b/dynamic-layers/clang-layer/recipes-devtools/clang/files/IndVarSimplify-Do-not-use-SCEV-expander-for-IVCount-.patch
deleted file mode 100644
index 48307deb..00000000
--- a/dynamic-layers/clang-layer/recipes-devtools/clang/files/IndVarSimplify-Do-not-use-SCEV-expander-for-IVCount-.patch
+++ /dev/null
@@ -1,146 +0,0 @@
1From 35e218a886f4c066eabd18685240d55270bd5a6d Mon Sep 17 00:00:00 2001
2From: Aleksander Us <aleksander.us@intel.com>
3Date: Mon, 26 Aug 2019 15:45:47 +0300
4Subject: [PATCH] [IndVarSimplify] Do not use SCEV expander for IVCount in
5 LFTR when possible.
6
7SCEV analysis cannot properly cache instruction with poison flags
8(for example, add nsw outside of loop will not be reused by expander).
9This can lead to generating of additional instructions by SCEV expander.
10
11Example IR:
12
13 ...
14 %maxval = add nuw nsw i32 %a1, %a2
15 ...
16for.body:
17 ...
18 %cmp22 = icmp ult i32 %ivadd, %maxval
19 br i1 %cmp22, label %for.body, label %for.end
20 ...
21
22SCEV expander will generate copy of %maxval in preheader but without
23nuw/nsw flags. This can be avoided by explicit check that iv count
24value gives the same SCEV expressions as calculated by LFTR.
25
26Upstream-Status: Submitted [https://reviews.llvm.org/D66890]
27
28https://github.com/intel/llvm-patches/commit/fd6a6c97341a56fd21bc32bc940afea751312e8f
29
30Signed-off-by: Naveen Saini <naveen.kumar.saini@intel.com>
31---
32 lib/Transforms/Scalar/IndVarSimplify.cpp | 12 +++++++++-
33 test/Transforms/IndVarSimplify/add_nsw.ll | 23 ++++++++++++++++++++
34 test/Transforms/IndVarSimplify/lftr-reuse.ll | 9 +++-----
35 test/Transforms/IndVarSimplify/udiv.ll | 1 +
36 4 files changed, 38 insertions(+), 7 deletions(-)
37 create mode 100644 test/Transforms/IndVarSimplify/add_nsw.ll
38
39diff --git a/lib/Transforms/Scalar/IndVarSimplify.cpp b/lib/Transforms/Scalar/IndVarSimplify.cpp
40index f9fc698a4a9..5e04dac8aa6 100644
41--- a/lib/Transforms/Scalar/IndVarSimplify.cpp
42+++ b/lib/Transforms/Scalar/IndVarSimplify.cpp
43@@ -2375,6 +2375,17 @@ static Value *genLoopLimit(PHINode *IndVar, BasicBlock *ExitingBB,
44 if (UsePostInc)
45 IVLimit = SE->getAddExpr(IVLimit, SE->getOne(IVLimit->getType()));
46
47+ // If computed limit is equal to old limit then do not use SCEV expander
48+ // because it can lost NUW/NSW flags and create extra instructions.
49+ BranchInst *BI = cast<BranchInst>(ExitingBB->getTerminator());
50+ if (ICmpInst *Cmp = dyn_cast<ICmpInst>(BI->getOperand(0))) {
51+ Value *Limit = Cmp->getOperand(0);
52+ if (!L->isLoopInvariant(Limit))
53+ Limit = Cmp->getOperand(1);
54+ if (SE->getSCEV(Limit) == IVLimit)
55+ return Limit;
56+ }
57+
58 // Expand the code for the iteration count.
59 assert(SE->isLoopInvariant(IVLimit, L) &&
60 "Computed iteration count is not loop invariant!");
61@@ -2383,7 +2394,6 @@ static Value *genLoopLimit(PHINode *IndVar, BasicBlock *ExitingBB,
62 // SCEV expression (IVInit) for a pointer type IV value (IndVar).
63 Type *LimitTy = ExitCount->getType()->isPointerTy() ?
64 IndVar->getType() : ExitCount->getType();
65- BranchInst *BI = cast<BranchInst>(ExitingBB->getTerminator());
66 return Rewriter.expandCodeFor(IVLimit, LimitTy, BI);
67 }
68 }
69diff --git a/test/Transforms/IndVarSimplify/add_nsw.ll b/test/Transforms/IndVarSimplify/add_nsw.ll
70new file mode 100644
71index 00000000000..abd1cbb6c51
72--- /dev/null
73+++ b/test/Transforms/IndVarSimplify/add_nsw.ll
74@@ -0,0 +1,23 @@
75+; RUN: opt -indvars -S %s | FileCheck %s
76+
77+target datalayout = "e-p:32:32-i64:64-n8:16:32"
78+
79+; CHECK: for.body.preheader:
80+; CHECK-NOT: add
81+; CHECK: for.body:
82+
83+define void @foo(i32 %a1, i32 %a2) {
84+entry:
85+ %maxval = add nuw nsw i32 %a1, %a2
86+ %cmp = icmp slt i32 %maxval, 1
87+ br i1 %cmp, label %for.end, label %for.body
88+
89+for.body: ; preds = %entry, %for.body
90+ %j.02 = phi i32 [ 0, %entry ], [ %add31, %for.body ]
91+ %add31 = add nuw nsw i32 %j.02, 1
92+ %cmp22 = icmp slt i32 %add31, %maxval
93+ br i1 %cmp22, label %for.body, label %for.end
94+
95+for.end: ; preds = %for.body
96+ ret void
97+}
98diff --git a/test/Transforms/IndVarSimplify/lftr-reuse.ll b/test/Transforms/IndVarSimplify/lftr-reuse.ll
99index 14ae9738696..509d662b767 100644
100--- a/test/Transforms/IndVarSimplify/lftr-reuse.ll
101+++ b/test/Transforms/IndVarSimplify/lftr-reuse.ll
102@@ -67,11 +67,9 @@ define void @expandOuterRecurrence(i32 %arg) nounwind {
103 ; CHECK-NEXT: [[CMP1:%.*]] = icmp slt i32 0, [[SUB1]]
104 ; CHECK-NEXT: br i1 [[CMP1]], label [[OUTER_PREHEADER:%.*]], label [[EXIT:%.*]]
105 ; CHECK: outer.preheader:
106-; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[ARG]], -1
107 ; CHECK-NEXT: br label [[OUTER:%.*]]
108 ; CHECK: outer:
109-; CHECK-NEXT: [[INDVARS_IV:%.*]] = phi i32 [ [[TMP0]], [[OUTER_PREHEADER]] ], [ [[INDVARS_IV_NEXT:%.*]], [[OUTER_INC:%.*]] ]
110-; CHECK-NEXT: [[I:%.*]] = phi i32 [ [[I_INC:%.*]], [[OUTER_INC]] ], [ 0, [[OUTER_PREHEADER]] ]
111+; CHECK-NEXT: [[I:%.*]] = phi i32 [ [[I_INC:%.*]], [[OUTER_INC:%.*]] ], [ 0, [[OUTER_PREHEADER]] ]
112 ; CHECK-NEXT: [[SUB2:%.*]] = sub nsw i32 [[ARG]], [[I]]
113 ; CHECK-NEXT: [[SUB3:%.*]] = sub nsw i32 [[SUB2]], 1
114 ; CHECK-NEXT: [[CMP2:%.*]] = icmp slt i32 0, [[SUB3]]
115@@ -81,14 +79,13 @@ define void @expandOuterRecurrence(i32 %arg) nounwind {
116 ; CHECK: inner:
117 ; CHECK-NEXT: [[J:%.*]] = phi i32 [ 0, [[INNER_PH]] ], [ [[J_INC:%.*]], [[INNER]] ]
118 ; CHECK-NEXT: [[J_INC]] = add nuw nsw i32 [[J]], 1
119-; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i32 [[J_INC]], [[INDVARS_IV]]
120+; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i32 [[J_INC]], [[SUB3]]
121 ; CHECK-NEXT: br i1 [[EXITCOND]], label [[INNER]], label [[OUTER_INC_LOOPEXIT:%.*]]
122 ; CHECK: outer.inc.loopexit:
123 ; CHECK-NEXT: br label [[OUTER_INC]]
124 ; CHECK: outer.inc:
125 ; CHECK-NEXT: [[I_INC]] = add nuw nsw i32 [[I]], 1
126-; CHECK-NEXT: [[INDVARS_IV_NEXT]] = add i32 [[INDVARS_IV]], -1
127-; CHECK-NEXT: [[EXITCOND1:%.*]] = icmp ne i32 [[I_INC]], [[TMP0]]
128+; CHECK-NEXT: [[EXITCOND1:%.*]] = icmp ne i32 [[I_INC]], [[SUB1]]
129 ; CHECK-NEXT: br i1 [[EXITCOND1]], label [[OUTER]], label [[EXIT_LOOPEXIT:%.*]]
130 ; CHECK: exit.loopexit:
131 ; CHECK-NEXT: br label [[EXIT]]
132diff --git a/test/Transforms/IndVarSimplify/udiv.ll b/test/Transforms/IndVarSimplify/udiv.ll
133index b3f2c2a6a66..3530343ef4a 100644
134--- a/test/Transforms/IndVarSimplify/udiv.ll
135+++ b/test/Transforms/IndVarSimplify/udiv.ll
136@@ -133,6 +133,7 @@ declare i32 @printf(i8* nocapture, ...) nounwind
137 ; CHECK-LABEL: @foo(
138 ; CHECK: for.body.preheader:
139 ; CHECK-NOT: udiv
140+; CHECK: for.body:
141
142 define void @foo(double* %p, i64 %n) nounwind {
143 entry:
144--
1452.18.0
146
diff --git a/dynamic-layers/clang-layer/recipes-devtools/clang/files/fix-shared-libs.patch b/dynamic-layers/clang-layer/recipes-devtools/clang/files/fix-shared-libs.patch
deleted file mode 100644
index d69d2a97..00000000
--- a/dynamic-layers/clang-layer/recipes-devtools/clang/files/fix-shared-libs.patch
+++ /dev/null
@@ -1,30 +0,0 @@
1From a6d4ccf082858e63e139ca06c02a071c343d2657 Mon Sep 17 00:00:00 2001
2From: Andrea Bocci <andrea.bocci@cern.ch>
3Date: Sun, 15 Mar 2020 17:35:44 +0100
4Subject: [PATCH] Fix building in-tree with cmake -DLLVM_LINK_LLVM_DYLIB=ON
5
6Building in-tree with LLVM 11.0 master with the LLVM_LINK_LLVM_DYLIB
7cmake flag fails to link with the LLVMSPIRVLib library.
8
9Add an explicit dependency to force the correct build order and linking.
10
11Signed-off-by: Andrea Bocci <andrea.bocci@cern.ch>
12Upstream-Status: Backport
13Signed-off-by: Anuj Mittal <anuj.mittal@intel.com>
14---
15 tools/llvm-spirv/CMakeLists.txt | 2 +-
16 1 file changed, 1 insertion(+), 1 deletion(-)
17
18diff --git a/tools/llvm-spirv/CMakeLists.txt b/tools/llvm-spirv/CMakeLists.txt
19index 9aa96d9c..501c0daf 100644
20--- a/tools/llvm-spirv/CMakeLists.txt
21+++ b/tools/llvm-spirv/CMakeLists.txt
22@@ -14,7 +14,7 @@ add_llvm_tool(llvm-spirv
23 NO_INSTALL_RPATH
24 )
25
26-if (LLVM_SPIRV_BUILD_EXTERNAL)
27+if (LLVM_SPIRV_BUILD_EXTERNAL OR LLVM_LINK_LLVM_DYLIB)
28 target_link_libraries(llvm-spirv PRIVATE LLVMSPIRVLib)
29 endif()
30
diff --git a/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm10-OpenCL-3.0-support.patch b/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm10-OpenCL-3.0-support.patch
deleted file mode 100644
index 53395ea0..00000000
--- a/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm10-OpenCL-3.0-support.patch
+++ /dev/null
@@ -1,8259 +0,0 @@
1From 31ec702cb365f4d02dd2146fb4329d642b8fc30b Mon Sep 17 00:00:00 2001
2From: Naveen Saini <naveen.kumar.saini@intel.com>
3Date: Wed, 7 Apr 2021 16:36:10 +0800
4Subject: [PATCH 1/2] OpenCL 3.0 support
5
6Upstream-Status: Backport [Taken from opencl-clang patches, https://github.com/intel/opencl-clang/blob/ocl-open-100/patches/clang/0001-OpenCL-3.0-support.patch]
7Signed-off-by: Anton Zabaznov <anton.zabaznov@intel.com>
8Signed-off-by: Naveen Saini <naveen.kumar.saini@intel.com>
9---
10 clang/include/clang/Basic/Builtins.def | 65 +-
11 clang/include/clang/Basic/Builtins.h | 13 +-
12 .../clang/Basic/DiagnosticParseKinds.td | 2 +
13 .../clang/Basic/DiagnosticSemaKinds.td | 7 +
14 clang/include/clang/Basic/LangOptions.def | 2 +
15 clang/include/clang/Basic/LangStandards.def | 4 +
16 .../include/clang/Basic/OpenCLExtensions.def | 15 +
17 clang/include/clang/Basic/OpenCLOptions.h | 175 +-
18 clang/include/clang/Driver/Options.td | 2 +-
19 clang/include/clang/Sema/Sema.h | 9 +
20 clang/lib/AST/ASTContext.cpp | 3 +-
21 clang/lib/Basic/Builtins.cpp | 28 +-
22 clang/lib/Basic/TargetInfo.cpp | 11 +
23 clang/lib/Basic/Targets.cpp | 1 -
24 clang/lib/CodeGen/CodeGenFunction.cpp | 6 +-
25 clang/lib/Frontend/CompilerInvocation.cpp | 22 +-
26 clang/lib/Frontend/InitPreprocessor.cpp | 6 +-
27 clang/lib/Headers/opencl-c-base.h | 75 +-
28 clang/lib/Headers/opencl-c.h | 3228 ++++++++++++++---
29 clang/lib/Parse/ParseDecl.cpp | 12 +-
30 clang/lib/Parse/ParsePragma.cpp | 10 +-
31 clang/lib/Sema/OpenCLBuiltins.td | 49 +-
32 clang/lib/Sema/Sema.cpp | 47 +-
33 clang/lib/Sema/SemaChecking.cpp | 38 +-
34 clang/lib/Sema/SemaDecl.cpp | 15 +-
35 clang/lib/Sema/SemaDeclAttr.cpp | 9 +-
36 clang/lib/Sema/SemaDeclCXX.cpp | 10 +
37 clang/lib/Sema/SemaLookup.cpp | 19 +-
38 clang/lib/Sema/SemaType.cpp | 14 +-
39 .../CodeGenOpenCL/addr-space-struct-arg.cl | 7 +-
40 .../address-spaces-conversions.cl | 2 +
41 .../CodeGenOpenCL/address-spaces-mangling.cl | 3 +-
42 clang/test/CodeGenOpenCL/address-spaces.cl | 4 +
43 .../amdgcn-automatic-variable.cl | 1 +
44 .../CodeGenOpenCL/amdgpu-sizeof-alignof.cl | 21 +-
45 .../CodeGenOpenCL/arm-integer-dot-product.cl | 1 +
46 .../test/CodeGenOpenCL/cl-uniform-wg-size.cl | 2 +
47 clang/test/CodeGenOpenCL/fpmath.cl | 2 +
48 .../generic-address-space-feature.cl | 28 +
49 .../intel-subgroups-avc-ext-types.cl | 1 +
50 .../kernels-have-spir-cc-by-default.cl | 3 +
51 clang/test/CodeGenOpenCL/logical-ops.cl | 1 +
52 clang/test/CodeGenOpenCL/no-half.cl | 1 +
53 clang/test/CodeGenOpenCL/pipe_builtin.cl | 3 +
54 clang/test/CodeGenOpenCL/pipe_types.cl | 1 +
55 clang/test/CodeGenOpenCL/printf.cl | 2 +
56 clang/test/CodeGenOpenCL/unroll-hint.cl | 1 +
57 clang/test/Driver/autocomplete.c | 2 +
58 clang/test/Driver/opencl.cl | 2 +
59 clang/test/Driver/unknown-std.cl | 1 +
60 clang/test/Frontend/stdlang.c | 1 +
61 clang/test/Headers/opencl-c-header.cl | 7 +-
62 clang/test/Index/pipe-size.cl | 7 +
63 clang/test/Preprocessor/predefined-macros.c | 13 +
64 .../Sema/feature-extensions-simult-support.cl | 75 +
65 clang/test/Sema/features-ignore-pragma.cl | 24 +
66 clang/test/Sema/opencl-features-pipes.cl | 18 +
67 clang/test/Sema/opencl-features.cl | 128 +
68 clang/test/Sema/pipe_builtins_feature.cl | 21 +
69 .../address-spaces-conversions-cl2.0.cl | 3 +
70 clang/test/SemaOpenCL/address-spaces.cl | 1 +
71 .../SemaOpenCL/cl20-device-side-enqueue.cl | 16 +-
72 .../SemaOpenCL/forget-unsupported-builtins.cl | 22 +
73 clang/test/SemaOpenCL/image-features.cl | 20 +
74 .../SemaOpenCL/invalid-pipe-builtin-cl2.0.cl | 1 +
75 clang/test/SemaOpenCL/storageclass-cl20.cl | 1 +
76 .../TableGen/ClangOpenCLBuiltinEmitter.cpp | 35 +-
77 67 files changed, 3656 insertions(+), 723 deletions(-)
78 create mode 100644 clang/test/CodeGenOpenCL/generic-address-space-feature.cl
79 create mode 100644 clang/test/Sema/feature-extensions-simult-support.cl
80 create mode 100644 clang/test/Sema/features-ignore-pragma.cl
81 create mode 100644 clang/test/Sema/opencl-features-pipes.cl
82 create mode 100644 clang/test/Sema/opencl-features.cl
83 create mode 100644 clang/test/Sema/pipe_builtins_feature.cl
84 create mode 100644 clang/test/SemaOpenCL/forget-unsupported-builtins.cl
85 create mode 100644 clang/test/SemaOpenCL/image-features.cl
86
87diff --git a/clang/include/clang/Basic/Builtins.def b/clang/include/clang/Basic/Builtins.def
88index 1a6c85ce2dd3..b76e277f0337 100644
89--- a/clang/include/clang/Basic/Builtins.def
90+++ b/clang/include/clang/Basic/Builtins.def
91@@ -106,6 +106,10 @@
92 # define LANGBUILTIN(ID, TYPE, ATTRS, BUILTIN_LANG) BUILTIN(ID, TYPE, ATTRS)
93 #endif
94
95+#if defined(BUILTIN) && !defined(OPENCLBUILTIN)
96+# define OPENCLBUILTIN(ID, TYPE, ATTRS, BUILTIN_LANG, FEATURE) BUILTIN(ID, TYPE, ATTRS)
97+#endif
98+
99 // Standard libc/libm functions:
100 BUILTIN(__builtin_atan2 , "ddd" , "Fne")
101 BUILTIN(__builtin_atan2f, "fff" , "Fne")
102@@ -1514,50 +1518,54 @@ BUILTIN(__builtin_coro_param, "bv*v*", "n")
103
104 // OpenCL v2.0 s6.13.16, s9.17.3.5 - Pipe functions.
105 // We need the generic prototype, since the packet type could be anything.
106-LANGBUILTIN(read_pipe, "i.", "tn", OCLC20_LANG)
107-LANGBUILTIN(write_pipe, "i.", "tn", OCLC20_LANG)
108+OPENCLBUILTIN(read_pipe, "i.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
109+OPENCLBUILTIN(write_pipe, "i.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
110
111-LANGBUILTIN(reserve_read_pipe, "i.", "tn", OCLC20_LANG)
112-LANGBUILTIN(reserve_write_pipe, "i.", "tn", OCLC20_LANG)
113+OPENCLBUILTIN(reserve_read_pipe, "i.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
114+OPENCLBUILTIN(reserve_write_pipe, "i.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
115
116-LANGBUILTIN(commit_write_pipe, "v.", "tn", OCLC20_LANG)
117-LANGBUILTIN(commit_read_pipe, "v.", "tn", OCLC20_LANG)
118+OPENCLBUILTIN(commit_write_pipe, "v.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
119+OPENCLBUILTIN(commit_read_pipe, "v.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
120
121-LANGBUILTIN(sub_group_reserve_read_pipe, "i.", "tn", OCLC20_LANG)
122-LANGBUILTIN(sub_group_reserve_write_pipe, "i.", "tn", OCLC20_LANG)
123+OPENCLBUILTIN(sub_group_reserve_read_pipe, "i.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
124+OPENCLBUILTIN(sub_group_reserve_write_pipe, "i.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
125
126-LANGBUILTIN(sub_group_commit_read_pipe, "v.", "tn", OCLC20_LANG)
127-LANGBUILTIN(sub_group_commit_write_pipe, "v.", "tn", OCLC20_LANG)
128+OPENCLBUILTIN(sub_group_commit_read_pipe, "v.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
129+OPENCLBUILTIN(sub_group_commit_write_pipe, "v.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
130
131-LANGBUILTIN(work_group_reserve_read_pipe, "i.", "tn", OCLC20_LANG)
132-LANGBUILTIN(work_group_reserve_write_pipe, "i.", "tn", OCLC20_LANG)
133+OPENCLBUILTIN(work_group_reserve_read_pipe, "i.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
134+OPENCLBUILTIN(work_group_reserve_write_pipe, "i.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
135
136-LANGBUILTIN(work_group_commit_read_pipe, "v.", "tn", OCLC20_LANG)
137-LANGBUILTIN(work_group_commit_write_pipe, "v.", "tn", OCLC20_LANG)
138+OPENCLBUILTIN(work_group_commit_read_pipe, "v.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
139+OPENCLBUILTIN(work_group_commit_write_pipe, "v.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
140
141-LANGBUILTIN(get_pipe_num_packets, "Ui.", "tn", OCLC20_LANG)
142-LANGBUILTIN(get_pipe_max_packets, "Ui.", "tn", OCLC20_LANG)
143+OPENCLBUILTIN(get_pipe_num_packets, "Ui.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
144+OPENCLBUILTIN(get_pipe_max_packets, "Ui.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
145
146 // OpenCL v2.0 s6.13.17 - Enqueue kernel functions.
147 // Custom builtin check allows to perform special check of passed block arguments.
148-LANGBUILTIN(enqueue_kernel, "i.", "tn", OCLC20_LANG)
149-LANGBUILTIN(get_kernel_work_group_size, "Ui.", "tn", OCLC20_LANG)
150-LANGBUILTIN(get_kernel_preferred_work_group_size_multiple, "Ui.", "tn", OCLC20_LANG)
151-LANGBUILTIN(get_kernel_max_sub_group_size_for_ndrange, "Ui.", "tn", OCLC20_LANG)
152-LANGBUILTIN(get_kernel_sub_group_count_for_ndrange, "Ui.", "tn", OCLC20_LANG)
153+OPENCLBUILTIN(enqueue_kernel, "i.", "tn", OCLC2P_LANG,
154+ "__opencl_c_device_enqueue")
155+OPENCLBUILTIN(get_kernel_work_group_size, "Ui.", "tn", OCLC2P_LANG,
156+ "__opencl_c_device_enqueue")
157+OPENCLBUILTIN(get_kernel_preferred_work_group_size_multiple, "Ui.", "tn",
158+ OCLC2P_LANG, "__opencl_c_device_enqueue")
159+OPENCLBUILTIN(get_kernel_max_sub_group_size_for_ndrange, "Ui.", "tn",
160+ OCLC2P_LANG, "__opencl_c_device_enqueue")
161+OPENCLBUILTIN(get_kernel_sub_group_count_for_ndrange, "Ui.", "tn", OCLC2P_LANG, "__opencl_c_device_enqueue")
162
163 // OpenCL v2.0 s6.13.9 - Address space qualifier functions.
164 // FIXME: Pointer parameters of OpenCL builtins should have their address space
165 // requirement defined.
166-LANGBUILTIN(to_global, "v*v*", "tn", OCLC20_LANG)
167-LANGBUILTIN(to_local, "v*v*", "tn", OCLC20_LANG)
168-LANGBUILTIN(to_private, "v*v*", "tn", OCLC20_LANG)
169+OPENCLBUILTIN(to_global, "v*v*", "tn", OCLC2P_LANG, "__opencl_c_generic_address_space")
170+OPENCLBUILTIN(to_local, "v*v*", "tn", OCLC2P_LANG, "__opencl_c_generic_address_space")
171+OPENCLBUILTIN(to_private, "v*v*", "tn", OCLC2P_LANG, "__opencl_c_generic_address_space")
172
173 // OpenCL half load/store builtin
174-LANGBUILTIN(__builtin_store_half, "vdh*", "n", ALL_OCLC_LANGUAGES)
175-LANGBUILTIN(__builtin_store_halff, "vfh*", "n", ALL_OCLC_LANGUAGES)
176-LANGBUILTIN(__builtin_load_half, "dhC*", "nc", ALL_OCLC_LANGUAGES)
177-LANGBUILTIN(__builtin_load_halff, "fhC*", "nc", ALL_OCLC_LANGUAGES)
178+OPENCLBUILTIN(__builtin_store_half, "vdh*", "n", ALL_OCLC_LANGUAGES, "")
179+OPENCLBUILTIN(__builtin_store_halff, "vfh*", "n", ALL_OCLC_LANGUAGES, "")
180+OPENCLBUILTIN(__builtin_load_half, "dhC*", "nc", ALL_OCLC_LANGUAGES, "")
181+OPENCLBUILTIN(__builtin_load_halff, "fhC*", "nc", ALL_OCLC_LANGUAGES, "")
182
183 // Builtins for os_log/os_trace
184 BUILTIN(__builtin_os_log_format_buffer_size, "zcC*.", "p:0:nut")
185@@ -1578,3 +1586,4 @@ BUILTIN(__builtin_ms_va_copy, "vc*&c*&", "n")
186 #undef BUILTIN
187 #undef LIBBUILTIN
188 #undef LANGBUILTIN
189+#undef OPENCLBUILTIN
190diff --git a/clang/include/clang/Basic/Builtins.h b/clang/include/clang/Basic/Builtins.h
191index e4ed482d9068..713ea4bc267d 100644
192--- a/clang/include/clang/Basic/Builtins.h
193+++ b/clang/include/clang/Basic/Builtins.h
194@@ -33,13 +33,13 @@ enum LanguageID {
195 CXX_LANG = 0x4, // builtin for cplusplus only.
196 OBJC_LANG = 0x8, // builtin for objective-c and objective-c++
197 MS_LANG = 0x10, // builtin requires MS mode.
198- OCLC20_LANG = 0x20, // builtin for OpenCL C 2.0 only.
199+ OCLC2P_LANG = 0x20, // builtin for OpenCL C 2.0+ versions.
200 OCLC1X_LANG = 0x40, // builtin for OpenCL C 1.x only.
201 OMP_LANG = 0x80, // builtin requires OpenMP.
202 ALL_LANGUAGES = C_LANG | CXX_LANG | OBJC_LANG, // builtin for all languages.
203 ALL_GNU_LANGUAGES = ALL_LANGUAGES | GNU_LANG, // builtin requires GNU mode.
204 ALL_MS_LANGUAGES = ALL_LANGUAGES | MS_LANG, // builtin requires MS mode.
205- ALL_OCLC_LANGUAGES = OCLC1X_LANG | OCLC20_LANG // builtin for OCLC languages.
206+ ALL_OCLC_LANGUAGES = OCLC1X_LANG | OCLC2P_LANG // builtin for OCLC languages.
207 };
208
209 namespace Builtin {
210@@ -228,6 +228,10 @@ public:
211 /// for non-builtins.
212 bool canBeRedeclared(unsigned ID) const;
213
214+ bool requiresFeatures(unsigned ID) const {
215+ return requiresFeatures(getRecord(ID));
216+ }
217+
218 private:
219 const Info &getRecord(unsigned ID) const;
220
221@@ -235,6 +239,11 @@ private:
222 bool builtinIsSupported(const Builtin::Info &BuiltinInfo,
223 const LangOptions &LangOpts);
224
225+ bool OclBuiltinIsSupported(const Builtin::Info &BuiltinInfo,
226+ const LangOptions &LangOpts) const;
227+
228+ bool requiresFeatures(const Builtin::Info &BuiltinInfo) const;
229+
230 /// Helper function for isPrintfLike and isScanfLike.
231 bool isLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg,
232 const char *Fmt) const;
233diff --git a/clang/include/clang/Basic/DiagnosticParseKinds.td b/clang/include/clang/Basic/DiagnosticParseKinds.td
234index 33adf093693f..43ea63586f91 100644
235--- a/clang/include/clang/Basic/DiagnosticParseKinds.td
236+++ b/clang/include/clang/Basic/DiagnosticParseKinds.td
237@@ -1199,6 +1199,8 @@ def warn_pragma_unsupported_extension : Warning<
238 "unsupported OpenCL extension %0 - ignoring">, InGroup<IgnoredPragmas>;
239 def warn_pragma_extension_is_core : Warning<
240 "OpenCL extension %0 is core feature or supported optional core feature - ignoring">, InGroup<DiagGroup<"pedantic-core-features">>, DefaultIgnore;
241+def warn_opencl_pragma_feature_ignore : Warning<
242+ "OpenCL feature support can't be controlled via pragma, ignoring">, InGroup<IgnoredPragmas>;
243
244 // OpenCL errors.
245 def err_opencl_taking_function_address_parser : Error<
246diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
247index 917377420505..91648aa27820 100644
248--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
249+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
250@@ -9378,6 +9378,13 @@ def ext_opencl_ext_vector_type_rgba_selector: ExtWarn<
251 def err_openclcxx_placement_new : Error<
252 "use of placement new requires explicit declaration">;
253
254+def err_opencl_pipes_require_feat : Error<
255+ "usage of OpenCL pipes requires feature support">;
256+def err_opencl_memory_scope_require_feat : Error<
257+ "usage of memory scope requires feature support">;
258+def err_opencl_memory_ordering_require_feat : Error<
259+ "usage of memory ordering requires feature support">;
260+
261 // MIG routine annotations.
262 def warn_mig_server_routine_does_not_return_kern_return_t : Warning<
263 "'mig_server_routine' attribute only applies to routines that return a kern_return_t">,
264diff --git a/clang/include/clang/Basic/LangOptions.def b/clang/include/clang/Basic/LangOptions.def
265index 3319a3123976..406f45c0be69 100644
266--- a/clang/include/clang/Basic/LangOptions.def
267+++ b/clang/include/clang/Basic/LangOptions.def
268@@ -203,6 +203,8 @@ LANGOPT(OpenCL , 1, 0, "OpenCL")
269 LANGOPT(OpenCLVersion , 32, 0, "OpenCL C version")
270 LANGOPT(OpenCLCPlusPlus , 1, 0, "C++ for OpenCL")
271 LANGOPT(OpenCLCPlusPlusVersion , 32, 0, "C++ for OpenCL version")
272+LANGOPT(OpenCLGenericKeyword , 1, 0, "OpenCL generic keyword")
273+LANGOPT(OpenCLPipeKeyword , 1, 0, "OpenCL pipe keyword")
274 LANGOPT(NativeHalfType , 1, 0, "Native half type support")
275 LANGOPT(NativeHalfArgsAndReturns, 1, 0, "Native half args and returns")
276 LANGOPT(HalfArgsAndReturns, 1, 0, "half args and returns")
277diff --git a/clang/include/clang/Basic/LangStandards.def b/clang/include/clang/Basic/LangStandards.def
278index 7f1a24db7e9b..69aaba3ff5a2 100644
279--- a/clang/include/clang/Basic/LangStandards.def
280+++ b/clang/include/clang/Basic/LangStandards.def
281@@ -167,6 +167,9 @@ LANGSTANDARD(opencl12, "cl1.2",
282 LANGSTANDARD(opencl20, "cl2.0",
283 OpenCL, "OpenCL 2.0",
284 LineComment | C99 | Digraphs | HexFloat | OpenCL)
285+LANGSTANDARD(opencl30, "cl3.0",
286+ OpenCL, "OpenCL 3.0",
287+ LineComment | C99 | Digraphs | HexFloat | OpenCL)
288 LANGSTANDARD(openclcpp, "clc++",
289 OpenCL, "C++ for OpenCL",
290 LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 |
291@@ -176,6 +179,7 @@ LANGSTANDARD_ALIAS_DEPR(opencl10, "CL")
292 LANGSTANDARD_ALIAS_DEPR(opencl11, "CL1.1")
293 LANGSTANDARD_ALIAS_DEPR(opencl12, "CL1.2")
294 LANGSTANDARD_ALIAS_DEPR(opencl20, "CL2.0")
295+LANGSTANDARD_ALIAS_DEPR(opencl30, "CL3.0")
296 LANGSTANDARD_ALIAS_DEPR(openclcpp, "CLC++")
297
298 // CUDA
299diff --git a/clang/include/clang/Basic/OpenCLExtensions.def b/clang/include/clang/Basic/OpenCLExtensions.def
300index 517481584313..608f78a13eef 100644
301--- a/clang/include/clang/Basic/OpenCLExtensions.def
302+++ b/clang/include/clang/Basic/OpenCLExtensions.def
303@@ -93,6 +93,21 @@ OPENCLEXT_INTERNAL(cl_intel_subgroups, 120, ~0U)
304 OPENCLEXT_INTERNAL(cl_intel_subgroups_short, 120, ~0U)
305 OPENCLEXT_INTERNAL(cl_intel_device_side_avc_motion_estimation, 120, ~0U)
306
307+OPENCLEXT_INTERNAL(__opencl_c_pipes, 200, ~0U)
308+OPENCLEXT_INTERNAL(__opencl_c_generic_address_space, 200, ~0U)
309+OPENCLEXT_INTERNAL(__opencl_c_work_group_collective_functions, 200, ~0U)
310+OPENCLEXT_INTERNAL(__opencl_c_atomic_order_acq_rel, 200, ~0U)
311+OPENCLEXT_INTERNAL(__opencl_c_atomic_order_seq_cst, 200, ~0U)
312+OPENCLEXT_INTERNAL(__opencl_c_atomic_scope_device, 200, ~0U)
313+OPENCLEXT_INTERNAL(__opencl_c_atomic_scope_all_devices, 200, ~0U)
314+OPENCLEXT_INTERNAL(__opencl_c_subgroups, 200, ~0U)
315+OPENCLEXT_INTERNAL(__opencl_c_3d_image_writes, 100, ~0U)
316+OPENCLEXT_INTERNAL(__opencl_c_device_enqueue, 200, ~0U)
317+OPENCLEXT_INTERNAL(__opencl_c_read_write_images, 200, ~0U)
318+OPENCLEXT_INTERNAL(__opencl_c_program_scope_global_variables, 200, ~0U)
319+OPENCLEXT_INTERNAL(__opencl_c_fp64, 120, ~0U)
320+OPENCLEXT_INTERNAL(__opencl_c_int64, 100, ~0U)
321+OPENCLEXT_INTERNAL(__opencl_c_images, 100, ~0U)
322 #undef OPENCLEXT_INTERNAL
323
324 #ifdef OPENCLEXT
325diff --git a/clang/include/clang/Basic/OpenCLOptions.h b/clang/include/clang/Basic/OpenCLOptions.h
326index 15661154eab5..9a3a8e33cadd 100644
327--- a/clang/include/clang/Basic/OpenCLOptions.h
328+++ b/clang/include/clang/Basic/OpenCLOptions.h
329@@ -16,11 +16,16 @@
330
331 #include "clang/Basic/LangOptions.h"
332 #include "llvm/ADT/StringMap.h"
333+#include "llvm/ADT/StringSwitch.h"
334
335 namespace clang {
336
337 /// OpenCL supported extensions and optional core features
338 class OpenCLOptions {
339+ // OpenCL Version
340+ unsigned CLVer = 120;
341+ bool IsOpenCLCPlusPlus = false;
342+
343 struct Info {
344 bool Supported; // Is this option supported
345 bool Enabled; // Is this option enabled
346@@ -31,7 +36,38 @@ class OpenCLOptions {
347 :Supported(S), Enabled(E), Avail(A), Core(C){}
348 };
349 llvm::StringMap<Info> OptMap;
350+
351 public:
352+ void setOpenCLVersion(const LangOptions &LO) {
353+ IsOpenCLCPlusPlus = LO.OpenCLCPlusPlus;
354+ CLVer = IsOpenCLCPlusPlus ? 200 : LO.OpenCLVersion;
355+ }
356+
357+ // Get extension which is semantically equivalent to a given feature
358+ // if exists (e.g. __opencl_c_subgroups -> cl_khr_subgroups)
359+ llvm::Optional<StringRef> getEquivalentExtension(StringRef Feature) const {
360+ return llvm::StringSwitch<llvm::Optional<StringRef>>(Feature)
361+ .Case("__opencl_c_3d_image_writes",
362+ Optional<StringRef>("cl_khr_3d_image_writes"))
363+ .Case("__opencl_c_subgroups", Optional<StringRef>("cl_khr_subgroups"))
364+ .Case("__opencl_c_fp64", Optional<StringRef>("cl_khr_fp64"))
365+ .Default(Optional<StringRef>());
366+ }
367+
368+ // Same as above but for extensions
369+ llvm::Optional<StringRef> getEquivalentFeature(StringRef Extension) const {
370+ return llvm::StringSwitch<llvm::Optional<StringRef>>(Extension)
371+ .Case("cl_khr_3d_image_writes",
372+ Optional<StringRef>("__opencl_c_3d_image_writes"))
373+ .Case("cl_khr_subgroups", Optional<StringRef>("__opencl_c_subgroups"))
374+ .Case("cl_khr_fp64", Optional<StringRef>("__opencl_c_fp64"))
375+ .Default(Optional<StringRef>());
376+ }
377+
378+ bool isFeature(llvm::StringRef Ext) const {
379+ return Ext.startswith("__opencl_c");
380+ }
381+
382 bool isKnown(llvm::StringRef Ext) const {
383 return OptMap.find(Ext) != OptMap.end();
384 }
385@@ -42,32 +78,88 @@ public:
386
387 // Is supported as either an extension or an (optional) core feature for
388 // OpenCL version \p CLVer.
389- bool isSupported(llvm::StringRef Ext, const LangOptions &LO) const {
390+ bool isSupported(llvm::StringRef Ext) const {
391 // In C++ mode all extensions should work at least as in v2.0.
392- auto CLVer = LO.OpenCLCPlusPlus ? 200 : LO.OpenCLVersion;
393 auto I = OptMap.find(Ext)->getValue();
394 return I.Supported && I.Avail <= CLVer;
395 }
396
397 // Is supported (optional) OpenCL core features for OpenCL version \p CLVer.
398 // For supported extension, return false.
399- bool isSupportedCore(llvm::StringRef Ext, const LangOptions &LO) const {
400+ bool isSupportedCore(llvm::StringRef Ext) const {
401 // In C++ mode all extensions should work at least as in v2.0.
402- auto CLVer = LO.OpenCLCPlusPlus ? 200 : LO.OpenCLVersion;
403 auto I = OptMap.find(Ext)->getValue();
404 return I.Supported && I.Avail <= CLVer && I.Core != ~0U && CLVer >= I.Core;
405 }
406
407 // Is supported OpenCL extension for OpenCL version \p CLVer.
408 // For supported (optional) core feature, return false.
409- bool isSupportedExtension(llvm::StringRef Ext, const LangOptions &LO) const {
410+ bool isSupportedExtension(llvm::StringRef Ext) const {
411 // In C++ mode all extensions should work at least as in v2.0.
412- auto CLVer = LO.OpenCLCPlusPlus ? 200 : LO.OpenCLVersion;
413 auto I = OptMap.find(Ext)->getValue();
414 return I.Supported && I.Avail <= CLVer && (I.Core == ~0U || CLVer < I.Core);
415 }
416
417+ // Support features whose support is directly related to the
418+ // specific OpenCL version. For example, OpenCL 2.0 supports
419+ // all features that are optional in 3.0
420+ void adjustFeatures() {
421+ // Support int64 by default (assume compiling for FULL profile)
422+ OptMap["__opencl_c_int64"].Supported = true;
423+
424+ if (CLVer >= 300) {
425+ // Simultaneously support extension and corresponding feature
426+ for (llvm::StringRef F :
427+ {"__opencl_c_subgroups", "__opencl_c_3d_image_writes",
428+ "__opencl_c_fp64"}) {
429+ auto Ext = getEquivalentExtension(F);
430+ OptMap[*Ext].Supported = OptMap[F].Supported;
431+ }
432+
433+ // OpenCL C compilers that define the feature macro __opencl_c_pipes or
434+ // or __opencl_c_device_enqueue must also define the
435+ // feature macro __opencl_c_generic_address_space.
436+ if (OptMap["__opencl_c_pipes"].Supported ||
437+ OptMap["__opencl_c_device_enqueue"].Supported)
438+ OptMap["__opencl_c_generic_address_space"].Supported = true;
439+
440+ // OpenCL C compilers that define the feature macro
441+ // __opencl_c_3d_image_writes or __opencl_c_read_write_images must also
442+ // define the feature macro __opencl_c_images
443+ if (OptMap["__opencl_c_3d_image_writes"].Supported ||
444+ OptMap["__opencl_c_read_write_images"].Supported)
445+ OptMap["__opencl_c_images"].Supported = true;
446+
447+ // All other features are already supported with options
448+ // or in target settings
449+ return;
450+ }
451+
452+ auto FeaturesRange = llvm::make_filter_range(
453+ OptMap, [&](llvm::StringMapEntry<Info> &OptVal) {
454+ auto Opt = OptVal.getKey();
455+ return isFeature(Opt);
456+ });
457+
458+ for (auto &It : FeaturesRange) {
459+ auto &Info = It.getValue();
460+ // For OpenCL version less then 3.0 some
461+ // features should be supported simulateneously
462+ // with specific extension
463+ if (Optional<llvm::StringRef> Ext = getEquivalentExtension(It.getKey()))
464+ Info.Supported = Info.Enabled = OptMap[*Ext].Supported;
465+ else if (Info.Avail <= CLVer)
466+ Info.Supported = Info.Enabled = true;
467+ }
468+ }
469+
470 void enable(llvm::StringRef Ext, bool V = true) {
471+ // Ignore disabling extensions if corresponding features
472+ // already supported for OpenCL version higher then 3.0
473+ if (CLVer >= 300)
474+ if (Optional<llvm::StringRef> F = getEquivalentFeature(Ext))
475+ if (V != OptMap[*F].Enabled)
476+ return;
477 OptMap[Ext].Enabled = V;
478 }
479
480@@ -96,7 +188,7 @@ public:
481 OptMap[Ext].Supported = V;
482 }
483
484- OpenCLOptions(){
485+ OpenCLOptions() {
486 #define OPENCLEXT_INTERNAL(Ext, AvailVer, CoreVer) \
487 OptMap[#Ext].Avail = AvailVer; \
488 OptMap[#Ext].Core = CoreVer;
489@@ -104,35 +196,86 @@ public:
490 }
491
492 void addSupport(const OpenCLOptions &Opts) {
493+ assert(IsOpenCLCPlusPlus == Opts.IsOpenCLCPlusPlus && CLVer == Opts.CLVer);
494 for (auto &I:Opts.OptMap)
495- if (I.second.Supported)
496+ if (I.second.Supported) {
497 OptMap[I.getKey()].Supported = true;
498+ // All features are enabled as they are supported
499+ if (isFeature(I.getKey()))
500+ OptMap[I.getKey()].Enabled = true;
501+ }
502+ if (CLVer >= 300) {
503+ // Enabling extensions with respect to features
504+ for (llvm::StringRef Ext :
505+ {"cl_khr_3d_image_writes", "cl_khr_subgroups", "cl_khr_fp64"}) {
506+ auto Feature = getEquivalentFeature(Ext);
507+ enable(Ext, OptMap[*Feature].Enabled);
508+ }
509+ }
510 }
511
512 void copy(const OpenCLOptions &Opts) {
513+ CLVer = Opts.CLVer;
514+ IsOpenCLCPlusPlus = Opts.IsOpenCLCPlusPlus;
515 OptMap = Opts.OptMap;
516 }
517
518 // Turn on or off support of all options.
519 void supportAll(bool On = true) {
520- for (llvm::StringMap<Info>::iterator I = OptMap.begin(),
521- E = OptMap.end(); I != E; ++I)
522- I->second.Supported = On;
523+ for (llvm::StringMap<Info>::iterator I = OptMap.begin(), E = OptMap.end();
524+ I != E; ++I)
525+ if (!isFeature(I->getKey()))
526+ I->second.Supported = On;
527 }
528
529 void disableAll() {
530- for (llvm::StringMap<Info>::iterator I = OptMap.begin(),
531- E = OptMap.end(); I != E; ++I)
532- I->second.Enabled = false;
533+ for (llvm::StringMap<Info>::iterator I = OptMap.begin(), E = OptMap.end();
534+ I != E; ++I) {
535+ auto Ext = I->getKey();
536+ if (!isFeature(Ext))
537+ enable(Ext, false);
538+ }
539 }
540
541- void enableSupportedCore(LangOptions LO) {
542+ void enableSupportedCore() {
543 for (llvm::StringMap<Info>::iterator I = OptMap.begin(), E = OptMap.end();
544 I != E; ++I)
545- if (isSupportedCore(I->getKey(), LO))
546+ if (isSupportedCore(I->getKey()))
547 I->second.Enabled = true;
548 }
549
550+ // This enum specifies how OpenCL versions map into values
551+ // for encoding. This is used when generating built-ins
552+ // from tablegen
553+ enum OpenCLVersionsEncodings : unsigned short {
554+ OPENCL_C_100_CODE = 0x1,
555+ OPENCL_C_110_CODE = 0x2,
556+ OPENCL_C_120_CODE = 0x4,
557+ OPENCL_C_200_CODE = 0x8,
558+ OPENCL_C_300_CODE = 0x10,
559+ OPENCL_C_ALL_CODE = 0x1f
560+ };
561+
562+ // Encode version into single integer
563+ static unsigned short EncodeVersion(unsigned OpenCLVersion) {
564+ switch (OpenCLVersion) {
565+ default:
566+ llvm_unreachable("Unknown OpenCL version");
567+ case 0:
568+ return OpenCLVersionsEncodings::OPENCL_C_ALL_CODE;
569+ case 100:
570+ return OpenCLVersionsEncodings::OPENCL_C_100_CODE;
571+ case 110:
572+ return OpenCLVersionsEncodings::OPENCL_C_110_CODE;
573+ case 120:
574+ return OpenCLVersionsEncodings::OPENCL_C_120_CODE;
575+ case 200:
576+ return OpenCLVersionsEncodings::OPENCL_C_200_CODE;
577+ case 300:
578+ return OpenCLVersionsEncodings::OPENCL_C_300_CODE;
579+ }
580+ }
581+
582 friend class ASTWriter;
583 friend class ASTReader;
584 };
585diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
586index 391c895a453b..e03c22c749ad 100644
587--- a/clang/include/clang/Driver/Options.td
588+++ b/clang/include/clang/Driver/Options.td
589@@ -522,7 +522,7 @@ def cl_mad_enable : Flag<["-"], "cl-mad-enable">, Group<opencl_Group>, Flags<[CC
590 def cl_no_signed_zeros : Flag<["-"], "cl-no-signed-zeros">, Group<opencl_Group>, Flags<[CC1Option]>,
591 HelpText<"OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.">;
592 def cl_std_EQ : Joined<["-"], "cl-std=">, Group<opencl_Group>, Flags<[CC1Option]>,
593- HelpText<"OpenCL language standard to compile for.">, Values<"cl,CL,cl1.1,CL1.1,cl1.2,CL1.2,cl2.0,CL2.0,clc++,CLC++">;
594+ HelpText<"OpenCL language standard to compile for.">, Values<"cl,CL,cl1.1,CL1.1,cl1.2,CL1.2,cl2.0,CL2.0,cl3.0,CL3.0,clc++,CLC++">;
595 def cl_denorms_are_zero : Flag<["-"], "cl-denorms-are-zero">, Group<opencl_Group>, Flags<[CC1Option]>,
596 HelpText<"OpenCL only. Allow denormals to be flushed to zero.">;
597 def cl_fp32_correctly_rounded_divide_sqrt : Flag<["-"], "cl-fp32-correctly-rounded-divide-sqrt">, Group<opencl_Group>, Flags<[CC1Option]>,
598diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
599index 842e49602274..d8ac91bc8a31 100644
600--- a/clang/include/clang/Sema/Sema.h
601+++ b/clang/include/clang/Sema/Sema.h
602@@ -9632,6 +9632,10 @@ public:
603 /// \return true if type is disabled.
604 bool checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E);
605
606+ bool checkOpenCLSubgroupExtForCallExpr(CallExpr *Call);
607+
608+ bool isSupportedOpenCLOMemoryOrdering(int64_t Ordering) const;
609+
610 //===--------------------------------------------------------------------===//
611 // OpenMP directives and clauses.
612 //
613@@ -11102,6 +11106,11 @@ public:
614 /// that the user intended an assignment used as condition.
615 void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE);
616
617+ template <typename DiagLocT, typename DiagInfoT>
618+ void DiagnoseOpenCLRequiresOption(llvm::StringRef OpenCLOptName,
619+ DiagLocT DiagLoc, DiagInfoT DiagInfo,
620+ unsigned Selector, SourceRange SrcRange);
621+
622 /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
623 ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr = false);
624
625diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
626index 1be72efe4de8..2a81fbcde79d 100644
627--- a/clang/lib/AST/ASTContext.cpp
628+++ b/clang/lib/AST/ASTContext.cpp
629@@ -1490,7 +1490,8 @@ void ASTContext::InitBuiltinTypes(const TargetInfo &Target,
630 ObjCSuperType = QualType();
631
632 // void * type
633- if (LangOpts.OpenCLVersion >= 200) {
634+ if (Target.getSupportedOpenCLOpts().isEnabled(
635+ "__opencl_c_generic_address_space")) {
636 auto Q = VoidTy.getQualifiers();
637 Q.setAddressSpace(LangAS::opencl_generic);
638 VoidPtrTy = getPointerType(getCanonicalType(
639diff --git a/clang/lib/Basic/Builtins.cpp b/clang/lib/Basic/Builtins.cpp
640index 0cd89df41b67..7a3067345098 100644
641--- a/clang/lib/Basic/Builtins.cpp
642+++ b/clang/lib/Basic/Builtins.cpp
643@@ -23,6 +23,8 @@ static const Builtin::Info BuiltinInfo[] = {
644 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
645 #define LANGBUILTIN(ID, TYPE, ATTRS, LANGS) \
646 { #ID, TYPE, ATTRS, nullptr, LANGS, nullptr },
647+#define OPENCLBUILTIN(ID, TYPE, ATTRS, LANGS, FEATURE) \
648+ {#ID, TYPE, ATTRS, nullptr, LANGS, FEATURE},
649 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER, LANGS) \
650 { #ID, TYPE, ATTRS, HEADER, LANGS, nullptr },
651 #include "clang/Basic/Builtins.def"
652@@ -69,16 +71,17 @@ bool Builtin::Context::builtinIsSupported(const Builtin::Info &BuiltinInfo,
653 bool ObjCUnsupported = !LangOpts.ObjC && BuiltinInfo.Langs == OBJC_LANG;
654 bool OclC1Unsupported = (LangOpts.OpenCLVersion / 100) != 1 &&
655 (BuiltinInfo.Langs & ALL_OCLC_LANGUAGES ) == OCLC1X_LANG;
656- bool OclC2Unsupported =
657- (LangOpts.OpenCLVersion != 200 && !LangOpts.OpenCLCPlusPlus) &&
658- (BuiltinInfo.Langs & ALL_OCLC_LANGUAGES) == OCLC20_LANG;
659+ bool OclC2PUnsupported =
660+ (BuiltinInfo.Langs & ALL_OCLC_LANGUAGES) == OCLC2P_LANG &&
661+ ((LangOpts.OpenCLVersion < 200 && !LangOpts.OpenCLCPlusPlus) ||
662+ !OclBuiltinIsSupported(BuiltinInfo, LangOpts));
663 bool OclCUnsupported = !LangOpts.OpenCL &&
664 (BuiltinInfo.Langs & ALL_OCLC_LANGUAGES);
665 bool OpenMPUnsupported = !LangOpts.OpenMP && BuiltinInfo.Langs == OMP_LANG;
666 bool CPlusPlusUnsupported =
667 !LangOpts.CPlusPlus && BuiltinInfo.Langs == CXX_LANG;
668 return !BuiltinsUnsupported && !MathBuiltinsUnsupported && !OclCUnsupported &&
669- !OclC1Unsupported && !OclC2Unsupported && !OpenMPUnsupported &&
670+ !OclC1Unsupported && !OclC2PUnsupported && !OpenMPUnsupported &&
671 !GnuModeUnsupported && !MSModeUnsupported && !ObjCUnsupported &&
672 !CPlusPlusUnsupported;
673 }
674@@ -191,3 +194,20 @@ bool Builtin::Context::canBeRedeclared(unsigned ID) const {
675 (!hasReferenceArgsOrResult(ID) &&
676 !hasCustomTypechecking(ID));
677 }
678+
679+bool Builtin::Context::OclBuiltinIsSupported(
680+ const Builtin::Info &BuiltinInfo, const LangOptions &LangOpts) const {
681+ if (!requiresFeatures(BuiltinInfo))
682+ return true;
683+
684+ return llvm::StringSwitch<bool>(BuiltinInfo.Features)
685+ .Case("__opencl_c_device_enqueue", LangOpts.Blocks)
686+ .Case("__opencl_c_generic_address_space", LangOpts.OpenCLGenericKeyword)
687+ .Case("__opencl_c_pipes", LangOpts.OpenCLPipeKeyword)
688+ .Default(false);
689+}
690+
691+bool Builtin::Context::requiresFeatures(
692+ const Builtin::Info &BuiltinInfo) const {
693+ return BuiltinInfo.Features && llvm::StringRef(BuiltinInfo.Features) != "";
694+}
695diff --git a/clang/lib/Basic/TargetInfo.cpp b/clang/lib/Basic/TargetInfo.cpp
696index 3a21a19e1f19..795311d5934e 100644
697--- a/clang/lib/Basic/TargetInfo.cpp
698+++ b/clang/lib/Basic/TargetInfo.cpp
699@@ -377,6 +377,17 @@ void TargetInfo::adjust(LangOptions &Opts) {
700 HalfFormat = &llvm::APFloat::IEEEhalf();
701 FloatFormat = &llvm::APFloat::IEEEsingle();
702 LongDoubleFormat = &llvm::APFloat::IEEEquad();
703+
704+ auto &SupportedOCLOpts = getTargetOpts().SupportedOpenCLOptions;
705+
706+ SupportedOCLOpts.setOpenCLVersion(Opts);
707+ SupportedOCLOpts.adjustFeatures();
708+
709+ if (!Opts.OpenCLCPlusPlus && Opts.OpenCLVersion >= 200)
710+ Opts.Blocks = SupportedOCLOpts.isSupported("__opencl_c_device_enqueue");
711+ Opts.OpenCLGenericKeyword =
712+ SupportedOCLOpts.isSupported("__opencl_c_generic_address_space");
713+ Opts.OpenCLPipeKeyword = SupportedOCLOpts.isSupported("__opencl_c_pipes");
714 }
715
716 if (Opts.LongDoubleSize) {
717diff --git a/clang/lib/Basic/Targets.cpp b/clang/lib/Basic/Targets.cpp
718index c063f8ca4472..b394be18a234 100644
719--- a/clang/lib/Basic/Targets.cpp
720+++ b/clang/lib/Basic/Targets.cpp
721@@ -39,7 +39,6 @@
722 #include "clang/Basic/Diagnostic.h"
723 #include "llvm/ADT/StringExtras.h"
724 #include "llvm/ADT/Triple.h"
725-
726 using namespace clang;
727
728 namespace clang {
729diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp
730index 648e6d9c214a..6d839fa61abc 100644
731--- a/clang/lib/CodeGen/CodeGenFunction.cpp
732+++ b/clang/lib/CodeGen/CodeGenFunction.cpp
733@@ -2303,11 +2303,11 @@ void CodeGenFunction::checkTargetFeatures(SourceLocation Loc,
734 std::string MissingFeature;
735 if (BuiltinID) {
736 SmallVector<StringRef, 1> ReqFeatures;
737- const char *FeatureList =
738- CGM.getContext().BuiltinInfo.getRequiredFeatures(BuiltinID);
739 // Return if the builtin doesn't have any required features.
740- if (!FeatureList || StringRef(FeatureList) == "")
741+ if (!CGM.getContext().BuiltinInfo.requiresFeatures(BuiltinID))
742 return;
743+ const char *FeatureList =
744+ CGM.getContext().BuiltinInfo.getRequiredFeatures(BuiltinID);
745 StringRef(FeatureList).split(ReqFeatures, ',');
746 if (!hasRequiredFeatures(ReqFeatures, CGM, FD, MissingFeature))
747 CGM.getDiags().Report(Loc, diag::err_builtin_needs_feature)
748diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp
749index e98a407ac42f..18fa06bf3c6d 100644
750--- a/clang/lib/Frontend/CompilerInvocation.cpp
751+++ b/clang/lib/Frontend/CompilerInvocation.cpp
752@@ -2298,6 +2298,8 @@ void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK,
753 Opts.OpenCLVersion = 120;
754 else if (LangStd == LangStandard::lang_opencl20)
755 Opts.OpenCLVersion = 200;
756+ else if (LangStd == LangStandard::lang_opencl30)
757+ Opts.OpenCLVersion = 300;
758 else if (LangStd == LangStandard::lang_openclcpp)
759 Opts.OpenCLCPlusPlusVersion = 100;
760
761@@ -2498,14 +2500,15 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
762 // -cl-std only applies for OpenCL language standards.
763 // Override the -std option in this case.
764 if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
765- LangStandard::Kind OpenCLLangStd
766- = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
767- .Cases("cl", "CL", LangStandard::lang_opencl10)
768- .Cases("cl1.1", "CL1.1", LangStandard::lang_opencl11)
769- .Cases("cl1.2", "CL1.2", LangStandard::lang_opencl12)
770- .Cases("cl2.0", "CL2.0", LangStandard::lang_opencl20)
771- .Cases("clc++", "CLC++", LangStandard::lang_openclcpp)
772- .Default(LangStandard::lang_unspecified);
773+ LangStandard::Kind OpenCLLangStd =
774+ llvm::StringSwitch<LangStandard::Kind>(A->getValue())
775+ .Cases("cl", "CL", LangStandard::lang_opencl10)
776+ .Cases("cl1.1", "CL1.1", LangStandard::lang_opencl11)
777+ .Cases("cl1.2", "CL1.2", LangStandard::lang_opencl12)
778+ .Cases("cl2.0", "CL2.0", LangStandard::lang_opencl20)
779+ .Cases("cl3.0", "CL3.0", LangStandard::lang_opencl30)
780+ .Cases("clc++", "CLC++", LangStandard::lang_openclcpp)
781+ .Default(LangStandard::lang_unspecified);
782
783 if (OpenCLLangStd == LangStandard::lang_unspecified) {
784 Diags.Report(diag::err_drv_invalid_value)
785@@ -2787,8 +2790,7 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
786
787 Opts.RTTI = Opts.CPlusPlus && !Args.hasArg(OPT_fno_rtti);
788 Opts.RTTIData = Opts.RTTI && !Args.hasArg(OPT_fno_rtti_data);
789- Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
790- && Opts.OpenCLVersion == 200);
791+ Opts.Blocks = Args.hasArg(OPT_fblocks);
792 Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
793 Opts.Coroutines = Opts.CPlusPlus2a || Args.hasArg(OPT_fcoroutines_ts);
794
795diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp
796index c273cb96d9b9..aefd208e6cd3 100644
797--- a/clang/lib/Frontend/InitPreprocessor.cpp
798+++ b/clang/lib/Frontend/InitPreprocessor.cpp
799@@ -445,6 +445,9 @@ static void InitializeStandardPredefinedMacros(const TargetInfo &TI,
800 case 200:
801 Builder.defineMacro("__OPENCL_C_VERSION__", "200");
802 break;
803+ case 300:
804+ Builder.defineMacro("__OPENCL_C_VERSION__", "300");
805+ break;
806 default:
807 llvm_unreachable("Unsupported OpenCL version");
808 }
809@@ -453,6 +456,7 @@ static void InitializeStandardPredefinedMacros(const TargetInfo &TI,
810 Builder.defineMacro("CL_VERSION_1_1", "110");
811 Builder.defineMacro("CL_VERSION_1_2", "120");
812 Builder.defineMacro("CL_VERSION_2_0", "200");
813+ Builder.defineMacro("CL_VERSION_3_0", "300");
814
815 if (TI.isLittleEndian())
816 Builder.defineMacro("__ENDIAN_LITTLE__");
817@@ -1101,7 +1105,7 @@ static void InitializePredefinedMacros(const TargetInfo &TI,
818 // OpenCL definitions.
819 if (LangOpts.OpenCL) {
820 #define OPENCLEXT(Ext) \
821- if (TI.getSupportedOpenCLOpts().isSupported(#Ext, LangOpts)) \
822+ if (TI.getSupportedOpenCLOpts().isSupported(#Ext)) \
823 Builder.defineMacro(#Ext);
824 #include "clang/Basic/OpenCLExtensions.def"
825
826diff --git a/clang/lib/Headers/opencl-c-base.h b/clang/lib/Headers/opencl-c-base.h
827index 430e07d36f62..2cc688ccc3da 100644
828--- a/clang/lib/Headers/opencl-c-base.h
829+++ b/clang/lib/Headers/opencl-c-base.h
830@@ -9,6 +9,59 @@
831 #ifndef _OPENCL_BASE_H_
832 #define _OPENCL_BASE_H_
833
834+// Add predefined macros to build headers with standalone executable
835+#ifndef CL_VERSION_3_0
836+ #define CL_VERSION_3_0 300
837+#endif
838+
839+// Define features for 2.0 for header backward compatibility
840+#ifndef __opencl_c_int64
841+ #define __opencl_c_int64 1
842+#endif
843+#if __OPENCL_C_VERSION__ != CL_VERSION_3_0
844+ #ifndef __opencl_c_images
845+ #define __opencl_c_images 1
846+ #endif
847+#endif
848+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ == CL_VERSION_2_0)
849+#ifndef __opencl_c_pipes
850+ #define __opencl_c_pipes 1
851+#endif
852+#ifndef __opencl_c_generic_address_space
853+ #define __opencl_c_generic_address_space 1
854+#endif
855+#ifndef __opencl_c_work_group_collective_functions
856+ #define __opencl_c_work_group_collective_functions 1
857+#endif
858+#ifndef __opencl_c_atomic_order_acq_rel
859+ #define __opencl_c_atomic_order_acq_rel 1
860+#endif
861+#ifndef __opencl_c_atomic_order_seq_cst
862+ #define __opencl_c_atomic_order_seq_cst 1
863+#endif
864+#ifndef __opencl_c_atomic_scope_device
865+ #define __opencl_c_atomic_scope_device 1
866+#endif
867+#ifndef __opencl_c_atomic_scope_all_devices
868+ #define __opencl_c_atomic_scope_all_devices 1
869+#endif
870+#ifndef __opencl_c_subgroups
871+ #define __opencl_c_subgroups 1
872+#endif
873+#ifndef __opencl_c_3d_image_writes
874+ #define __opencl_c_3d_image_writes 1
875+#endif
876+#ifndef __opencl_c_device_enqueue
877+ #define __opencl_c_device_enqueue 1
878+#endif
879+#ifndef __opencl_c_read_write_images
880+ #define __opencl_c_read_write_images 1
881+#endif
882+#ifndef __opencl_c_program_scope_global_variables
883+ #define __opencl_c_program_scope_global_variables 1
884+#endif
885+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ == CL_VERSION_2_0)
886+
887 // built-in scalar data types:
888
889 /**
890@@ -115,7 +168,12 @@ typedef half half4 __attribute__((ext_vector_type(4)));
891 typedef half half8 __attribute__((ext_vector_type(8)));
892 typedef half half16 __attribute__((ext_vector_type(16)));
893 #endif
894-#ifdef cl_khr_fp64
895+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
896+
897+#ifndef __opencl_c_fp64
898+ #define __opencl_c_fp64 1
899+#endif
900+
901 #if __OPENCL_C_VERSION__ < CL_VERSION_1_2
902 #pragma OPENCL EXTENSION cl_khr_fp64 : enable
903 #endif
904@@ -281,9 +339,17 @@ typedef uint cl_mem_fence_flags;
905 typedef enum memory_scope {
906 memory_scope_work_item = __OPENCL_MEMORY_SCOPE_WORK_ITEM,
907 memory_scope_work_group = __OPENCL_MEMORY_SCOPE_WORK_GROUP,
908+#ifdef __opencl_c_atomic_scope_device
909 memory_scope_device = __OPENCL_MEMORY_SCOPE_DEVICE,
910+#endif
911+#ifdef __opencl_c_atomic_scope_all_devices
912+ #if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
913+ memory_scope_all_devices = __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES,
914+ #endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
915 memory_scope_all_svm_devices = __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES,
916-#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups)
917+#endif
918+#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups) || \
919+ defined(__opencl_c_subgroups)
920 memory_scope_sub_group = __OPENCL_MEMORY_SCOPE_SUB_GROUP
921 #endif
922 } memory_scope;
923@@ -301,13 +367,14 @@ typedef enum memory_scope {
924 #define ATOMIC_FLAG_INIT 0
925
926 // enum values aligned with what clang uses in EmitAtomicExpr()
927-typedef enum memory_order
928-{
929+typedef enum memory_order {
930 memory_order_relaxed = __ATOMIC_RELAXED,
931 memory_order_acquire = __ATOMIC_ACQUIRE,
932 memory_order_release = __ATOMIC_RELEASE,
933 memory_order_acq_rel = __ATOMIC_ACQ_REL,
934+#ifdef __opencl_c_atomic_order_seq_cst
935 memory_order_seq_cst = __ATOMIC_SEQ_CST
936+#endif //__opencl_c_atomic_order_seq_cst
937 } memory_order;
938
939 #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
940diff --git a/clang/lib/Headers/opencl-c.h b/clang/lib/Headers/opencl-c.h
941index 3210f93cc851..93a946cec5b1 100644
942--- a/clang/lib/Headers/opencl-c.h
943+++ b/clang/lib/Headers/opencl-c.h
944@@ -35,7 +35,6 @@
945 #define __purefn __attribute__((pure))
946 #define __cnfn __attribute__((const))
947
948-
949 // OpenCL v1.1/1.2/2.0 s6.2.3 - Explicit conversions
950
951 char __ovld __cnfn convert_char_rte(char);
952@@ -4632,7 +4631,7 @@ float16 __ovld __cnfn convert_float16(float16);
953
954 // Conversions with double data type parameters or return value.
955
956-#ifdef cl_khr_fp64
957+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
958 char __ovld __cnfn convert_char(double);
959 char __ovld __cnfn convert_char_rte(double);
960 char __ovld __cnfn convert_char_rtn(double);
961@@ -5452,7 +5451,7 @@ double16 __ovld __cnfn convert_double16_rtz(uchar16);
962 double16 __ovld __cnfn convert_double16_rtz(uint16);
963 double16 __ovld __cnfn convert_double16_rtz(ulong16);
964 double16 __ovld __cnfn convert_double16_rtz(ushort16);
965-#endif //cl_khr_fp64
966+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
967
968 #ifdef cl_khr_fp16
969 // Convert half types to non-double types.
970@@ -6270,7 +6269,7 @@ half16 __ovld __cnfn convert_half16_rtz(float16);
971 half16 __ovld __cnfn convert_half16_rtz(half16);
972
973 // Convert half types to double types.
974-#ifdef cl_khr_fp64
975+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
976 double __ovld __cnfn convert_double(half);
977 double __ovld __cnfn convert_double_rte(half);
978 double __ovld __cnfn convert_double_rtp(half);
979@@ -6333,7 +6332,7 @@ half16 __ovld __cnfn convert_half16_rte(double16);
980 half16 __ovld __cnfn convert_half16_rtp(double16);
981 half16 __ovld __cnfn convert_half16_rtn(double16);
982 half16 __ovld __cnfn convert_half16_rtz(double16);
983-#endif //cl_khr_fp64
984+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
985
986 #endif // cl_khr_fp16
987
988@@ -6404,14 +6403,14 @@ half16 __ovld __cnfn convert_half16_rtz(double16);
989 #define as_float8(x) __builtin_astype((x), float8)
990 #define as_float16(x) __builtin_astype((x), float16)
991
992-#ifdef cl_khr_fp64
993+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
994 #define as_double(x) __builtin_astype((x), double)
995 #define as_double2(x) __builtin_astype((x), double2)
996 #define as_double3(x) __builtin_astype((x), double3)
997 #define as_double4(x) __builtin_astype((x), double4)
998 #define as_double8(x) __builtin_astype((x), double8)
999 #define as_double16(x) __builtin_astype((x), double16)
1000-#endif //cl_khr_fp64
1001+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1002
1003 #ifdef cl_khr_fp16
1004 #define as_half(x) __builtin_astype((x), half)
1005@@ -6534,14 +6533,14 @@ float3 __ovld __cnfn acos(float3);
1006 float4 __ovld __cnfn acos(float4);
1007 float8 __ovld __cnfn acos(float8);
1008 float16 __ovld __cnfn acos(float16);
1009-#ifdef cl_khr_fp64
1010+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1011 double __ovld __cnfn acos(double);
1012 double2 __ovld __cnfn acos(double2);
1013 double3 __ovld __cnfn acos(double3);
1014 double4 __ovld __cnfn acos(double4);
1015 double8 __ovld __cnfn acos(double8);
1016 double16 __ovld __cnfn acos(double16);
1017-#endif //cl_khr_fp64
1018+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1019 #ifdef cl_khr_fp16
1020 half __ovld __cnfn acos(half);
1021 half2 __ovld __cnfn acos(half2);
1022@@ -6560,14 +6559,14 @@ float3 __ovld __cnfn acosh(float3);
1023 float4 __ovld __cnfn acosh(float4);
1024 float8 __ovld __cnfn acosh(float8);
1025 float16 __ovld __cnfn acosh(float16);
1026-#ifdef cl_khr_fp64
1027+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1028 double __ovld __cnfn acosh(double);
1029 double2 __ovld __cnfn acosh(double2);
1030 double3 __ovld __cnfn acosh(double3);
1031 double4 __ovld __cnfn acosh(double4);
1032 double8 __ovld __cnfn acosh(double8);
1033 double16 __ovld __cnfn acosh(double16);
1034-#endif //cl_khr_fp64
1035+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1036 #ifdef cl_khr_fp16
1037 half __ovld __cnfn acosh(half);
1038 half2 __ovld __cnfn acosh(half2);
1039@@ -6586,14 +6585,14 @@ float3 __ovld __cnfn acospi(float3 x);
1040 float4 __ovld __cnfn acospi(float4 x);
1041 float8 __ovld __cnfn acospi(float8 x);
1042 float16 __ovld __cnfn acospi(float16 x);
1043-#ifdef cl_khr_fp64
1044+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1045 double __ovld __cnfn acospi(double x);
1046 double2 __ovld __cnfn acospi(double2 x);
1047 double3 __ovld __cnfn acospi(double3 x);
1048 double4 __ovld __cnfn acospi(double4 x);
1049 double8 __ovld __cnfn acospi(double8 x);
1050 double16 __ovld __cnfn acospi(double16 x);
1051-#endif //cl_khr_fp64
1052+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1053 #ifdef cl_khr_fp16
1054 half __ovld __cnfn acospi(half x);
1055 half2 __ovld __cnfn acospi(half2 x);
1056@@ -6612,14 +6611,14 @@ float3 __ovld __cnfn asin(float3);
1057 float4 __ovld __cnfn asin(float4);
1058 float8 __ovld __cnfn asin(float8);
1059 float16 __ovld __cnfn asin(float16);
1060-#ifdef cl_khr_fp64
1061+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1062 double __ovld __cnfn asin(double);
1063 double2 __ovld __cnfn asin(double2);
1064 double3 __ovld __cnfn asin(double3);
1065 double4 __ovld __cnfn asin(double4);
1066 double8 __ovld __cnfn asin(double8);
1067 double16 __ovld __cnfn asin(double16);
1068-#endif //cl_khr_fp64
1069+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1070 #ifdef cl_khr_fp16
1071 half __ovld __cnfn asin(half);
1072 half2 __ovld __cnfn asin(half2);
1073@@ -6638,14 +6637,14 @@ float3 __ovld __cnfn asinh(float3);
1074 float4 __ovld __cnfn asinh(float4);
1075 float8 __ovld __cnfn asinh(float8);
1076 float16 __ovld __cnfn asinh(float16);
1077-#ifdef cl_khr_fp64
1078+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1079 double __ovld __cnfn asinh(double);
1080 double2 __ovld __cnfn asinh(double2);
1081 double3 __ovld __cnfn asinh(double3);
1082 double4 __ovld __cnfn asinh(double4);
1083 double8 __ovld __cnfn asinh(double8);
1084 double16 __ovld __cnfn asinh(double16);
1085-#endif //cl_khr_fp64
1086+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1087 #ifdef cl_khr_fp16
1088 half __ovld __cnfn asinh(half);
1089 half2 __ovld __cnfn asinh(half2);
1090@@ -6664,14 +6663,14 @@ float3 __ovld __cnfn asinpi(float3 x);
1091 float4 __ovld __cnfn asinpi(float4 x);
1092 float8 __ovld __cnfn asinpi(float8 x);
1093 float16 __ovld __cnfn asinpi(float16 x);
1094-#ifdef cl_khr_fp64
1095+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1096 double __ovld __cnfn asinpi(double x);
1097 double2 __ovld __cnfn asinpi(double2 x);
1098 double3 __ovld __cnfn asinpi(double3 x);
1099 double4 __ovld __cnfn asinpi(double4 x);
1100 double8 __ovld __cnfn asinpi(double8 x);
1101 double16 __ovld __cnfn asinpi(double16 x);
1102-#endif //cl_khr_fp64
1103+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1104 #ifdef cl_khr_fp16
1105 half __ovld __cnfn asinpi(half x);
1106 half2 __ovld __cnfn asinpi(half2 x);
1107@@ -6690,14 +6689,14 @@ float3 __ovld __cnfn atan(float3 y_over_x);
1108 float4 __ovld __cnfn atan(float4 y_over_x);
1109 float8 __ovld __cnfn atan(float8 y_over_x);
1110 float16 __ovld __cnfn atan(float16 y_over_x);
1111-#ifdef cl_khr_fp64
1112+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1113 double __ovld __cnfn atan(double y_over_x);
1114 double2 __ovld __cnfn atan(double2 y_over_x);
1115 double3 __ovld __cnfn atan(double3 y_over_x);
1116 double4 __ovld __cnfn atan(double4 y_over_x);
1117 double8 __ovld __cnfn atan(double8 y_over_x);
1118 double16 __ovld __cnfn atan(double16 y_over_x);
1119-#endif //cl_khr_fp64
1120+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1121 #ifdef cl_khr_fp16
1122 half __ovld __cnfn atan(half y_over_x);
1123 half2 __ovld __cnfn atan(half2 y_over_x);
1124@@ -6716,14 +6715,14 @@ float3 __ovld __cnfn atan2(float3 y, float3 x);
1125 float4 __ovld __cnfn atan2(float4 y, float4 x);
1126 float8 __ovld __cnfn atan2(float8 y, float8 x);
1127 float16 __ovld __cnfn atan2(float16 y, float16 x);
1128-#ifdef cl_khr_fp64
1129+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1130 double __ovld __cnfn atan2(double y, double x);
1131 double2 __ovld __cnfn atan2(double2 y, double2 x);
1132 double3 __ovld __cnfn atan2(double3 y, double3 x);
1133 double4 __ovld __cnfn atan2(double4 y, double4 x);
1134 double8 __ovld __cnfn atan2(double8 y, double8 x);
1135 double16 __ovld __cnfn atan2(double16 y, double16 x);
1136-#endif //cl_khr_fp64
1137+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1138 #ifdef cl_khr_fp16
1139 half __ovld __cnfn atan2(half y, half x);
1140 half2 __ovld __cnfn atan2(half2 y, half2 x);
1141@@ -6742,14 +6741,14 @@ float3 __ovld __cnfn atanh(float3);
1142 float4 __ovld __cnfn atanh(float4);
1143 float8 __ovld __cnfn atanh(float8);
1144 float16 __ovld __cnfn atanh(float16);
1145-#ifdef cl_khr_fp64
1146+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1147 double __ovld __cnfn atanh(double);
1148 double2 __ovld __cnfn atanh(double2);
1149 double3 __ovld __cnfn atanh(double3);
1150 double4 __ovld __cnfn atanh(double4);
1151 double8 __ovld __cnfn atanh(double8);
1152 double16 __ovld __cnfn atanh(double16);
1153-#endif //cl_khr_fp64
1154+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1155 #ifdef cl_khr_fp16
1156 half __ovld __cnfn atanh(half);
1157 half2 __ovld __cnfn atanh(half2);
1158@@ -6768,14 +6767,14 @@ float3 __ovld __cnfn atanpi(float3 x);
1159 float4 __ovld __cnfn atanpi(float4 x);
1160 float8 __ovld __cnfn atanpi(float8 x);
1161 float16 __ovld __cnfn atanpi(float16 x);
1162-#ifdef cl_khr_fp64
1163+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1164 double __ovld __cnfn atanpi(double x);
1165 double2 __ovld __cnfn atanpi(double2 x);
1166 double3 __ovld __cnfn atanpi(double3 x);
1167 double4 __ovld __cnfn atanpi(double4 x);
1168 double8 __ovld __cnfn atanpi(double8 x);
1169 double16 __ovld __cnfn atanpi(double16 x);
1170-#endif //cl_khr_fp64
1171+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1172 #ifdef cl_khr_fp16
1173 half __ovld __cnfn atanpi(half x);
1174 half2 __ovld __cnfn atanpi(half2 x);
1175@@ -6794,14 +6793,14 @@ float3 __ovld __cnfn atan2pi(float3 y, float3 x);
1176 float4 __ovld __cnfn atan2pi(float4 y, float4 x);
1177 float8 __ovld __cnfn atan2pi(float8 y, float8 x);
1178 float16 __ovld __cnfn atan2pi(float16 y, float16 x);
1179-#ifdef cl_khr_fp64
1180+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1181 double __ovld __cnfn atan2pi(double y, double x);
1182 double2 __ovld __cnfn atan2pi(double2 y, double2 x);
1183 double3 __ovld __cnfn atan2pi(double3 y, double3 x);
1184 double4 __ovld __cnfn atan2pi(double4 y, double4 x);
1185 double8 __ovld __cnfn atan2pi(double8 y, double8 x);
1186 double16 __ovld __cnfn atan2pi(double16 y, double16 x);
1187-#endif //cl_khr_fp64
1188+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1189 #ifdef cl_khr_fp16
1190 half __ovld __cnfn atan2pi(half y, half x);
1191 half2 __ovld __cnfn atan2pi(half2 y, half2 x);
1192@@ -6820,14 +6819,14 @@ float3 __ovld __cnfn cbrt(float3);
1193 float4 __ovld __cnfn cbrt(float4);
1194 float8 __ovld __cnfn cbrt(float8);
1195 float16 __ovld __cnfn cbrt(float16);
1196-#ifdef cl_khr_fp64
1197+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1198 double __ovld __cnfn cbrt(double);
1199 double2 __ovld __cnfn cbrt(double2);
1200 double3 __ovld __cnfn cbrt(double3);
1201 double4 __ovld __cnfn cbrt(double4);
1202 double8 __ovld __cnfn cbrt(double8);
1203 double16 __ovld __cnfn cbrt(double16);
1204-#endif //cl_khr_fp64
1205+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1206 #ifdef cl_khr_fp16
1207 half __ovld __cnfn cbrt(half);
1208 half2 __ovld __cnfn cbrt(half2);
1209@@ -6847,14 +6846,14 @@ float3 __ovld __cnfn ceil(float3);
1210 float4 __ovld __cnfn ceil(float4);
1211 float8 __ovld __cnfn ceil(float8);
1212 float16 __ovld __cnfn ceil(float16);
1213-#ifdef cl_khr_fp64
1214+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1215 double __ovld __cnfn ceil(double);
1216 double2 __ovld __cnfn ceil(double2);
1217 double3 __ovld __cnfn ceil(double3);
1218 double4 __ovld __cnfn ceil(double4);
1219 double8 __ovld __cnfn ceil(double8);
1220 double16 __ovld __cnfn ceil(double16);
1221-#endif //cl_khr_fp64
1222+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1223 #ifdef cl_khr_fp16
1224 half __ovld __cnfn ceil(half);
1225 half2 __ovld __cnfn ceil(half2);
1226@@ -6873,14 +6872,14 @@ float3 __ovld __cnfn copysign(float3 x, float3 y);
1227 float4 __ovld __cnfn copysign(float4 x, float4 y);
1228 float8 __ovld __cnfn copysign(float8 x, float8 y);
1229 float16 __ovld __cnfn copysign(float16 x, float16 y);
1230-#ifdef cl_khr_fp64
1231+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1232 double __ovld __cnfn copysign(double x, double y);
1233 double2 __ovld __cnfn copysign(double2 x, double2 y);
1234 double3 __ovld __cnfn copysign(double3 x, double3 y);
1235 double4 __ovld __cnfn copysign(double4 x, double4 y);
1236 double8 __ovld __cnfn copysign(double8 x, double8 y);
1237 double16 __ovld __cnfn copysign(double16 x, double16 y);
1238-#endif //cl_khr_fp64
1239+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1240 #ifdef cl_khr_fp16
1241 half __ovld __cnfn copysign(half x, half y);
1242 half2 __ovld __cnfn copysign(half2 x, half2 y);
1243@@ -6899,14 +6898,14 @@ float3 __ovld __cnfn cos(float3);
1244 float4 __ovld __cnfn cos(float4);
1245 float8 __ovld __cnfn cos(float8);
1246 float16 __ovld __cnfn cos(float16);
1247-#ifdef cl_khr_fp64
1248+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1249 double __ovld __cnfn cos(double);
1250 double2 __ovld __cnfn cos(double2);
1251 double3 __ovld __cnfn cos(double3);
1252 double4 __ovld __cnfn cos(double4);
1253 double8 __ovld __cnfn cos(double8);
1254 double16 __ovld __cnfn cos(double16);
1255-#endif //cl_khr_fp64
1256+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1257 #ifdef cl_khr_fp16
1258 half __ovld __cnfn cos(half);
1259 half2 __ovld __cnfn cos(half2);
1260@@ -6925,14 +6924,14 @@ float3 __ovld __cnfn cosh(float3);
1261 float4 __ovld __cnfn cosh(float4);
1262 float8 __ovld __cnfn cosh(float8);
1263 float16 __ovld __cnfn cosh(float16);
1264-#ifdef cl_khr_fp64
1265+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1266 double __ovld __cnfn cosh(double);
1267 double2 __ovld __cnfn cosh(double2);
1268 double3 __ovld __cnfn cosh(double3);
1269 double4 __ovld __cnfn cosh(double4);
1270 double8 __ovld __cnfn cosh(double8);
1271 double16 __ovld __cnfn cosh(double16);
1272-#endif //cl_khr_fp64
1273+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1274 #ifdef cl_khr_fp16
1275 half __ovld __cnfn cosh(half);
1276 half2 __ovld __cnfn cosh(half2);
1277@@ -6951,14 +6950,14 @@ float3 __ovld __cnfn cospi(float3 x);
1278 float4 __ovld __cnfn cospi(float4 x);
1279 float8 __ovld __cnfn cospi(float8 x);
1280 float16 __ovld __cnfn cospi(float16 x);
1281-#ifdef cl_khr_fp64
1282+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1283 double __ovld __cnfn cospi(double x);
1284 double2 __ovld __cnfn cospi(double2 x);
1285 double3 __ovld __cnfn cospi(double3 x);
1286 double4 __ovld __cnfn cospi(double4 x);
1287 double8 __ovld __cnfn cospi(double8 x);
1288 double16 __ovld __cnfn cospi(double16 x);
1289-#endif //cl_khr_fp64
1290+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1291 #ifdef cl_khr_fp16
1292 half __ovld __cnfn cospi(half x);
1293 half2 __ovld __cnfn cospi(half2 x);
1294@@ -6977,14 +6976,14 @@ float3 __ovld __cnfn erfc(float3);
1295 float4 __ovld __cnfn erfc(float4);
1296 float8 __ovld __cnfn erfc(float8);
1297 float16 __ovld __cnfn erfc(float16);
1298-#ifdef cl_khr_fp64
1299+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1300 double __ovld __cnfn erfc(double);
1301 double2 __ovld __cnfn erfc(double2);
1302 double3 __ovld __cnfn erfc(double3);
1303 double4 __ovld __cnfn erfc(double4);
1304 double8 __ovld __cnfn erfc(double8);
1305 double16 __ovld __cnfn erfc(double16);
1306-#endif //cl_khr_fp64
1307+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1308 #ifdef cl_khr_fp16
1309 half __ovld __cnfn erfc(half);
1310 half2 __ovld __cnfn erfc(half2);
1311@@ -7004,14 +7003,14 @@ float3 __ovld __cnfn erf(float3);
1312 float4 __ovld __cnfn erf(float4);
1313 float8 __ovld __cnfn erf(float8);
1314 float16 __ovld __cnfn erf(float16);
1315-#ifdef cl_khr_fp64
1316+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1317 double __ovld __cnfn erf(double);
1318 double2 __ovld __cnfn erf(double2);
1319 double3 __ovld __cnfn erf(double3);
1320 double4 __ovld __cnfn erf(double4);
1321 double8 __ovld __cnfn erf(double8);
1322 double16 __ovld __cnfn erf(double16);
1323-#endif //cl_khr_fp64
1324+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1325 #ifdef cl_khr_fp16
1326 half __ovld __cnfn erf(half);
1327 half2 __ovld __cnfn erf(half2);
1328@@ -7030,14 +7029,14 @@ float3 __ovld __cnfn exp(float3 x);
1329 float4 __ovld __cnfn exp(float4 x);
1330 float8 __ovld __cnfn exp(float8 x);
1331 float16 __ovld __cnfn exp(float16 x);
1332-#ifdef cl_khr_fp64
1333+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1334 double __ovld __cnfn exp(double x);
1335 double2 __ovld __cnfn exp(double2 x);
1336 double3 __ovld __cnfn exp(double3 x);
1337 double4 __ovld __cnfn exp(double4 x);
1338 double8 __ovld __cnfn exp(double8 x);
1339 double16 __ovld __cnfn exp(double16 x);
1340-#endif //cl_khr_fp64
1341+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1342 #ifdef cl_khr_fp16
1343 half __ovld __cnfn exp(half x);
1344 half2 __ovld __cnfn exp(half2 x);
1345@@ -7056,14 +7055,14 @@ float3 __ovld __cnfn exp2(float3);
1346 float4 __ovld __cnfn exp2(float4);
1347 float8 __ovld __cnfn exp2(float8);
1348 float16 __ovld __cnfn exp2(float16);
1349-#ifdef cl_khr_fp64
1350+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1351 double __ovld __cnfn exp2(double);
1352 double2 __ovld __cnfn exp2(double2);
1353 double3 __ovld __cnfn exp2(double3);
1354 double4 __ovld __cnfn exp2(double4);
1355 double8 __ovld __cnfn exp2(double8);
1356 double16 __ovld __cnfn exp2(double16);
1357-#endif //cl_khr_fp64
1358+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1359 #ifdef cl_khr_fp16
1360 half __ovld __cnfn exp2(half);
1361 half2 __ovld __cnfn exp2(half2);
1362@@ -7082,14 +7081,14 @@ float3 __ovld __cnfn exp10(float3);
1363 float4 __ovld __cnfn exp10(float4);
1364 float8 __ovld __cnfn exp10(float8);
1365 float16 __ovld __cnfn exp10(float16);
1366-#ifdef cl_khr_fp64
1367+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1368 double __ovld __cnfn exp10(double);
1369 double2 __ovld __cnfn exp10(double2);
1370 double3 __ovld __cnfn exp10(double3);
1371 double4 __ovld __cnfn exp10(double4);
1372 double8 __ovld __cnfn exp10(double8);
1373 double16 __ovld __cnfn exp10(double16);
1374-#endif //cl_khr_fp64
1375+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1376 #ifdef cl_khr_fp16
1377 half __ovld __cnfn exp10(half);
1378 half2 __ovld __cnfn exp10(half2);
1379@@ -7108,14 +7107,14 @@ float3 __ovld __cnfn expm1(float3 x);
1380 float4 __ovld __cnfn expm1(float4 x);
1381 float8 __ovld __cnfn expm1(float8 x);
1382 float16 __ovld __cnfn expm1(float16 x);
1383-#ifdef cl_khr_fp64
1384+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1385 double __ovld __cnfn expm1(double x);
1386 double2 __ovld __cnfn expm1(double2 x);
1387 double3 __ovld __cnfn expm1(double3 x);
1388 double4 __ovld __cnfn expm1(double4 x);
1389 double8 __ovld __cnfn expm1(double8 x);
1390 double16 __ovld __cnfn expm1(double16 x);
1391-#endif //cl_khr_fp64
1392+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1393 #ifdef cl_khr_fp16
1394 half __ovld __cnfn expm1(half x);
1395 half2 __ovld __cnfn expm1(half2 x);
1396@@ -7134,14 +7133,14 @@ float3 __ovld __cnfn fabs(float3);
1397 float4 __ovld __cnfn fabs(float4);
1398 float8 __ovld __cnfn fabs(float8);
1399 float16 __ovld __cnfn fabs(float16);
1400-#ifdef cl_khr_fp64
1401+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1402 double __ovld __cnfn fabs(double);
1403 double2 __ovld __cnfn fabs(double2);
1404 double3 __ovld __cnfn fabs(double3);
1405 double4 __ovld __cnfn fabs(double4);
1406 double8 __ovld __cnfn fabs(double8);
1407 double16 __ovld __cnfn fabs(double16);
1408-#endif //cl_khr_fp64
1409+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1410 #ifdef cl_khr_fp16
1411 half __ovld __cnfn fabs(half);
1412 half2 __ovld __cnfn fabs(half2);
1413@@ -7160,14 +7159,14 @@ float3 __ovld __cnfn fdim(float3 x, float3 y);
1414 float4 __ovld __cnfn fdim(float4 x, float4 y);
1415 float8 __ovld __cnfn fdim(float8 x, float8 y);
1416 float16 __ovld __cnfn fdim(float16 x, float16 y);
1417-#ifdef cl_khr_fp64
1418+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1419 double __ovld __cnfn fdim(double x, double y);
1420 double2 __ovld __cnfn fdim(double2 x, double2 y);
1421 double3 __ovld __cnfn fdim(double3 x, double3 y);
1422 double4 __ovld __cnfn fdim(double4 x, double4 y);
1423 double8 __ovld __cnfn fdim(double8 x, double8 y);
1424 double16 __ovld __cnfn fdim(double16 x, double16 y);
1425-#endif //cl_khr_fp64
1426+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1427 #ifdef cl_khr_fp16
1428 half __ovld __cnfn fdim(half x, half y);
1429 half2 __ovld __cnfn fdim(half2 x, half2 y);
1430@@ -7187,14 +7186,14 @@ float3 __ovld __cnfn floor(float3);
1431 float4 __ovld __cnfn floor(float4);
1432 float8 __ovld __cnfn floor(float8);
1433 float16 __ovld __cnfn floor(float16);
1434-#ifdef cl_khr_fp64
1435+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1436 double __ovld __cnfn floor(double);
1437 double2 __ovld __cnfn floor(double2);
1438 double3 __ovld __cnfn floor(double3);
1439 double4 __ovld __cnfn floor(double4);
1440 double8 __ovld __cnfn floor(double8);
1441 double16 __ovld __cnfn floor(double16);
1442-#endif //cl_khr_fp64
1443+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1444 #ifdef cl_khr_fp16
1445 half __ovld __cnfn floor(half);
1446 half2 __ovld __cnfn floor(half2);
1447@@ -7217,14 +7216,14 @@ float3 __ovld __cnfn fma(float3 a, float3 b, float3 c);
1448 float4 __ovld __cnfn fma(float4 a, float4 b, float4 c);
1449 float8 __ovld __cnfn fma(float8 a, float8 b, float8 c);
1450 float16 __ovld __cnfn fma(float16 a, float16 b, float16 c);
1451-#ifdef cl_khr_fp64
1452+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1453 double __ovld __cnfn fma(double a, double b, double c);
1454 double2 __ovld __cnfn fma(double2 a, double2 b, double2 c);
1455 double3 __ovld __cnfn fma(double3 a, double3 b, double3 c);
1456 double4 __ovld __cnfn fma(double4 a, double4 b, double4 c);
1457 double8 __ovld __cnfn fma(double8 a, double8 b, double8 c);
1458 double16 __ovld __cnfn fma(double16 a, double16 b, double16 c);
1459-#endif //cl_khr_fp64
1460+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1461 #ifdef cl_khr_fp16
1462 half __ovld __cnfn fma(half a, half b, half c);
1463 half2 __ovld __cnfn fma(half2 a, half2 b, half2 c);
1464@@ -7251,7 +7250,7 @@ float3 __ovld __cnfn fmax(float3 x, float y);
1465 float4 __ovld __cnfn fmax(float4 x, float y);
1466 float8 __ovld __cnfn fmax(float8 x, float y);
1467 float16 __ovld __cnfn fmax(float16 x, float y);
1468-#ifdef cl_khr_fp64
1469+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1470 double __ovld __cnfn fmax(double x, double y);
1471 double2 __ovld __cnfn fmax(double2 x, double2 y);
1472 double3 __ovld __cnfn fmax(double3 x, double3 y);
1473@@ -7263,7 +7262,7 @@ double3 __ovld __cnfn fmax(double3 x, double y);
1474 double4 __ovld __cnfn fmax(double4 x, double y);
1475 double8 __ovld __cnfn fmax(double8 x, double y);
1476 double16 __ovld __cnfn fmax(double16 x, double y);
1477-#endif //cl_khr_fp64
1478+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1479 #ifdef cl_khr_fp16
1480 half __ovld __cnfn fmax(half x, half y);
1481 half2 __ovld __cnfn fmax(half2 x, half2 y);
1482@@ -7295,7 +7294,7 @@ float3 __ovld __cnfn fmin(float3 x, float y);
1483 float4 __ovld __cnfn fmin(float4 x, float y);
1484 float8 __ovld __cnfn fmin(float8 x, float y);
1485 float16 __ovld __cnfn fmin(float16 x, float y);
1486-#ifdef cl_khr_fp64
1487+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1488 double __ovld __cnfn fmin(double x, double y);
1489 double2 __ovld __cnfn fmin(double2 x, double2 y);
1490 double3 __ovld __cnfn fmin(double3 x, double3 y);
1491@@ -7307,7 +7306,7 @@ double3 __ovld __cnfn fmin(double3 x, double y);
1492 double4 __ovld __cnfn fmin(double4 x, double y);
1493 double8 __ovld __cnfn fmin(double8 x, double y);
1494 double16 __ovld __cnfn fmin(double16 x, double y);
1495-#endif //cl_khr_fp64
1496+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1497 #ifdef cl_khr_fp16
1498 half __ovld __cnfn fmin(half x, half y);
1499 half2 __ovld __cnfn fmin(half2 x, half2 y);
1500@@ -7331,14 +7330,14 @@ float3 __ovld __cnfn fmod(float3 x, float3 y);
1501 float4 __ovld __cnfn fmod(float4 x, float4 y);
1502 float8 __ovld __cnfn fmod(float8 x, float8 y);
1503 float16 __ovld __cnfn fmod(float16 x, float16 y);
1504-#ifdef cl_khr_fp64
1505+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1506 double __ovld __cnfn fmod(double x, double y);
1507 double2 __ovld __cnfn fmod(double2 x, double2 y);
1508 double3 __ovld __cnfn fmod(double3 x, double3 y);
1509 double4 __ovld __cnfn fmod(double4 x, double4 y);
1510 double8 __ovld __cnfn fmod(double8 x, double8 y);
1511 double16 __ovld __cnfn fmod(double16 x, double16 y);
1512-#endif //cl_khr_fp64
1513+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1514 #ifdef cl_khr_fp16
1515 half __ovld __cnfn fmod(half x, half y);
1516 half2 __ovld __cnfn fmod(half2 x, half2 y);
1517@@ -7352,21 +7351,21 @@ half16 __ovld __cnfn fmod(half16 x, half16 y);
1518 * Returns fmin(x - floor (x), 0x1.fffffep-1f ).
1519 * floor(x) is returned in iptr.
1520 */
1521-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
1522+#ifdef __opencl_c_generic_address_space
1523 float __ovld fract(float x, float *iptr);
1524 float2 __ovld fract(float2 x, float2 *iptr);
1525 float3 __ovld fract(float3 x, float3 *iptr);
1526 float4 __ovld fract(float4 x, float4 *iptr);
1527 float8 __ovld fract(float8 x, float8 *iptr);
1528 float16 __ovld fract(float16 x, float16 *iptr);
1529-#ifdef cl_khr_fp64
1530+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1531 double __ovld fract(double x, double *iptr);
1532 double2 __ovld fract(double2 x, double2 *iptr);
1533 double3 __ovld fract(double3 x, double3 *iptr);
1534 double4 __ovld fract(double4 x, double4 *iptr);
1535 double8 __ovld fract(double8 x, double8 *iptr);
1536 double16 __ovld fract(double16 x, double16 *iptr);
1537-#endif //cl_khr_fp64
1538+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1539 #ifdef cl_khr_fp16
1540 half __ovld fract(half x, half *iptr);
1541 half2 __ovld fract(half2 x, half2 *iptr);
1542@@ -7375,7 +7374,9 @@ half4 __ovld fract(half4 x, half4 *iptr);
1543 half8 __ovld fract(half8 x, half8 *iptr);
1544 half16 __ovld fract(half16 x, half16 *iptr);
1545 #endif //cl_khr_fp16
1546-#else
1547+#endif //__opencl_c_generic_address_space
1548+
1549+#if !defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ != CL_VERSION_2_0)
1550 float __ovld fract(float x, __global float *iptr);
1551 float2 __ovld fract(float2 x, __global float2 *iptr);
1552 float3 __ovld fract(float3 x, __global float3 *iptr);
1553@@ -7394,7 +7395,7 @@ float3 __ovld fract(float3 x, __private float3 *iptr);
1554 float4 __ovld fract(float4 x, __private float4 *iptr);
1555 float8 __ovld fract(float8 x, __private float8 *iptr);
1556 float16 __ovld fract(float16 x, __private float16 *iptr);
1557-#ifdef cl_khr_fp64
1558+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1559 double __ovld fract(double x, __global double *iptr);
1560 double2 __ovld fract(double2 x, __global double2 *iptr);
1561 double3 __ovld fract(double3 x, __global double3 *iptr);
1562@@ -7413,7 +7414,7 @@ double3 __ovld fract(double3 x, __private double3 *iptr);
1563 double4 __ovld fract(double4 x, __private double4 *iptr);
1564 double8 __ovld fract(double8 x, __private double8 *iptr);
1565 double16 __ovld fract(double16 x, __private double16 *iptr);
1566-#endif //cl_khr_fp64
1567+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1568 #ifdef cl_khr_fp16
1569 half __ovld fract(half x, __global half *iptr);
1570 half2 __ovld fract(half2 x, __global half2 *iptr);
1571@@ -7434,29 +7435,29 @@ half4 __ovld fract(half4 x, __private half4 *iptr);
1572 half8 __ovld fract(half8 x, __private half8 *iptr);
1573 half16 __ovld fract(half16 x, __private half16 *iptr);
1574 #endif //cl_khr_fp16
1575-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
1576-
1577+#endif //! defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ !=
1578+ //! CL_VERSION_2_0)
1579 /**
1580 * Extract mantissa and exponent from x. For each
1581 * component the mantissa returned is a float with
1582 * magnitude in the interval [1/2, 1) or 0. Each
1583 * component of x equals mantissa returned * 2^exp.
1584 */
1585-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
1586+#ifdef __opencl_c_generic_address_space
1587 float __ovld frexp(float x, int *exp);
1588 float2 __ovld frexp(float2 x, int2 *exp);
1589 float3 __ovld frexp(float3 x, int3 *exp);
1590 float4 __ovld frexp(float4 x, int4 *exp);
1591 float8 __ovld frexp(float8 x, int8 *exp);
1592 float16 __ovld frexp(float16 x, int16 *exp);
1593-#ifdef cl_khr_fp64
1594+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1595 double __ovld frexp(double x, int *exp);
1596 double2 __ovld frexp(double2 x, int2 *exp);
1597 double3 __ovld frexp(double3 x, int3 *exp);
1598 double4 __ovld frexp(double4 x, int4 *exp);
1599 double8 __ovld frexp(double8 x, int8 *exp);
1600 double16 __ovld frexp(double16 x, int16 *exp);
1601-#endif //cl_khr_fp64
1602+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1603 #ifdef cl_khr_fp16
1604 half __ovld frexp(half x, int *exp);
1605 half2 __ovld frexp(half2 x, int2 *exp);
1606@@ -7465,7 +7466,9 @@ half4 __ovld frexp(half4 x, int4 *exp);
1607 half8 __ovld frexp(half8 x, int8 *exp);
1608 half16 __ovld frexp(half16 x, int16 *exp);
1609 #endif //cl_khr_fp16
1610-#else
1611+#endif //__opencl_c_generic_address_space
1612+
1613+#if !defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ != CL_VERSION_2_0)
1614 float __ovld frexp(float x, __global int *exp);
1615 float2 __ovld frexp(float2 x, __global int2 *exp);
1616 float3 __ovld frexp(float3 x, __global int3 *exp);
1617@@ -7484,7 +7487,7 @@ float3 __ovld frexp(float3 x, __private int3 *exp);
1618 float4 __ovld frexp(float4 x, __private int4 *exp);
1619 float8 __ovld frexp(float8 x, __private int8 *exp);
1620 float16 __ovld frexp(float16 x, __private int16 *exp);
1621-#ifdef cl_khr_fp64
1622+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1623 double __ovld frexp(double x, __global int *exp);
1624 double2 __ovld frexp(double2 x, __global int2 *exp);
1625 double3 __ovld frexp(double3 x, __global int3 *exp);
1626@@ -7503,7 +7506,7 @@ double3 __ovld frexp(double3 x, __private int3 *exp);
1627 double4 __ovld frexp(double4 x, __private int4 *exp);
1628 double8 __ovld frexp(double8 x, __private int8 *exp);
1629 double16 __ovld frexp(double16 x, __private int16 *exp);
1630-#endif //cl_khr_fp64
1631+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1632 #ifdef cl_khr_fp16
1633 half __ovld frexp(half x, __global int *exp);
1634 half2 __ovld frexp(half2 x, __global int2 *exp);
1635@@ -7524,7 +7527,8 @@ half4 __ovld frexp(half4 x, __private int4 *exp);
1636 half8 __ovld frexp(half8 x, __private int8 *exp);
1637 half16 __ovld frexp(half16 x, __private int16 *exp);
1638 #endif //cl_khr_fp16
1639-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
1640+#endif //! defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ !=
1641+ //! CL_VERSION_2_0)
1642
1643 /**
1644 * Compute the value of the square root of x^2 + y^2
1645@@ -7536,14 +7540,14 @@ float3 __ovld __cnfn hypot(float3 x, float3 y);
1646 float4 __ovld __cnfn hypot(float4 x, float4 y);
1647 float8 __ovld __cnfn hypot(float8 x, float8 y);
1648 float16 __ovld __cnfn hypot(float16 x, float16 y);
1649-#ifdef cl_khr_fp64
1650+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1651 double __ovld __cnfn hypot(double x, double y);
1652 double2 __ovld __cnfn hypot(double2 x, double2 y);
1653 double3 __ovld __cnfn hypot(double3 x, double3 y);
1654 double4 __ovld __cnfn hypot(double4 x, double4 y);
1655 double8 __ovld __cnfn hypot(double8 x, double8 y);
1656 double16 __ovld __cnfn hypot(double16 x, double16 y);
1657-#endif //cl_khr_fp64
1658+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1659 #ifdef cl_khr_fp16
1660 half __ovld __cnfn hypot(half x, half y);
1661 half2 __ovld __cnfn hypot(half2 x, half2 y);
1662@@ -7562,14 +7566,14 @@ int3 __ovld __cnfn ilogb(float3 x);
1663 int4 __ovld __cnfn ilogb(float4 x);
1664 int8 __ovld __cnfn ilogb(float8 x);
1665 int16 __ovld __cnfn ilogb(float16 x);
1666-#ifdef cl_khr_fp64
1667+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1668 int __ovld __cnfn ilogb(double x);
1669 int2 __ovld __cnfn ilogb(double2 x);
1670 int3 __ovld __cnfn ilogb(double3 x);
1671 int4 __ovld __cnfn ilogb(double4 x);
1672 int8 __ovld __cnfn ilogb(double8 x);
1673 int16 __ovld __cnfn ilogb(double16 x);
1674-#endif //cl_khr_fp64
1675+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1676 #ifdef cl_khr_fp16
1677 int __ovld __cnfn ilogb(half x);
1678 int2 __ovld __cnfn ilogb(half2 x);
1679@@ -7593,7 +7597,7 @@ float3 __ovld __cnfn ldexp(float3 x, int n);
1680 float4 __ovld __cnfn ldexp(float4 x, int n);
1681 float8 __ovld __cnfn ldexp(float8 x, int n);
1682 float16 __ovld __cnfn ldexp(float16 x, int n);
1683-#ifdef cl_khr_fp64
1684+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1685 double __ovld __cnfn ldexp(double x, int n);
1686 double2 __ovld __cnfn ldexp(double2 x, int2 n);
1687 double3 __ovld __cnfn ldexp(double3 x, int3 n);
1688@@ -7605,7 +7609,7 @@ double3 __ovld __cnfn ldexp(double3 x, int n);
1689 double4 __ovld __cnfn ldexp(double4 x, int n);
1690 double8 __ovld __cnfn ldexp(double8 x, int n);
1691 double16 __ovld __cnfn ldexp(double16 x, int n);
1692-#endif //cl_khr_fp64
1693+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1694 #ifdef cl_khr_fp16
1695 half __ovld __cnfn ldexp(half x, int n);
1696 half2 __ovld __cnfn ldexp(half2 x, int2 n);
1697@@ -7632,14 +7636,14 @@ float3 __ovld __cnfn lgamma(float3 x);
1698 float4 __ovld __cnfn lgamma(float4 x);
1699 float8 __ovld __cnfn lgamma(float8 x);
1700 float16 __ovld __cnfn lgamma(float16 x);
1701-#ifdef cl_khr_fp64
1702+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1703 double __ovld __cnfn lgamma(double x);
1704 double2 __ovld __cnfn lgamma(double2 x);
1705 double3 __ovld __cnfn lgamma(double3 x);
1706 double4 __ovld __cnfn lgamma(double4 x);
1707 double8 __ovld __cnfn lgamma(double8 x);
1708 double16 __ovld __cnfn lgamma(double16 x);
1709-#endif //cl_khr_fp64
1710+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1711 #ifdef cl_khr_fp16
1712 half __ovld __cnfn lgamma(half x);
1713 half2 __ovld __cnfn lgamma(half2 x);
1714@@ -7649,21 +7653,21 @@ half8 __ovld __cnfn lgamma(half8 x);
1715 half16 __ovld __cnfn lgamma(half16 x);
1716 #endif //cl_khr_fp16
1717
1718-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
1719+#ifdef __opencl_c_generic_address_space
1720 float __ovld lgamma_r(float x, int *signp);
1721 float2 __ovld lgamma_r(float2 x, int2 *signp);
1722 float3 __ovld lgamma_r(float3 x, int3 *signp);
1723 float4 __ovld lgamma_r(float4 x, int4 *signp);
1724 float8 __ovld lgamma_r(float8 x, int8 *signp);
1725 float16 __ovld lgamma_r(float16 x, int16 *signp);
1726-#ifdef cl_khr_fp64
1727+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1728 double __ovld lgamma_r(double x, int *signp);
1729 double2 __ovld lgamma_r(double2 x, int2 *signp);
1730 double3 __ovld lgamma_r(double3 x, int3 *signp);
1731 double4 __ovld lgamma_r(double4 x, int4 *signp);
1732 double8 __ovld lgamma_r(double8 x, int8 *signp);
1733 double16 __ovld lgamma_r(double16 x, int16 *signp);
1734-#endif //cl_khr_fp64
1735+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1736 #ifdef cl_khr_fp16
1737 half __ovld lgamma_r(half x, int *signp);
1738 half2 __ovld lgamma_r(half2 x, int2 *signp);
1739@@ -7672,7 +7676,9 @@ half4 __ovld lgamma_r(half4 x, int4 *signp);
1740 half8 __ovld lgamma_r(half8 x, int8 *signp);
1741 half16 __ovld lgamma_r(half16 x, int16 *signp);
1742 #endif //cl_khr_fp16
1743-#else
1744+#endif //__opencl_c_generic_address_space
1745+
1746+#if !defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ != CL_VERSION_2_0)
1747 float __ovld lgamma_r(float x, __global int *signp);
1748 float2 __ovld lgamma_r(float2 x, __global int2 *signp);
1749 float3 __ovld lgamma_r(float3 x, __global int3 *signp);
1750@@ -7691,7 +7697,7 @@ float3 __ovld lgamma_r(float3 x, __private int3 *signp);
1751 float4 __ovld lgamma_r(float4 x, __private int4 *signp);
1752 float8 __ovld lgamma_r(float8 x, __private int8 *signp);
1753 float16 __ovld lgamma_r(float16 x, __private int16 *signp);
1754-#ifdef cl_khr_fp64
1755+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1756 double __ovld lgamma_r(double x, __global int *signp);
1757 double2 __ovld lgamma_r(double2 x, __global int2 *signp);
1758 double3 __ovld lgamma_r(double3 x, __global int3 *signp);
1759@@ -7710,7 +7716,7 @@ double3 __ovld lgamma_r(double3 x, __private int3 *signp);
1760 double4 __ovld lgamma_r(double4 x, __private int4 *signp);
1761 double8 __ovld lgamma_r(double8 x, __private int8 *signp);
1762 double16 __ovld lgamma_r(double16 x, __private int16 *signp);
1763-#endif //cl_khr_fp64
1764+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1765 #ifdef cl_khr_fp16
1766 half __ovld lgamma_r(half x, __global int *signp);
1767 half2 __ovld lgamma_r(half2 x, __global int2 *signp);
1768@@ -7731,8 +7737,8 @@ half4 __ovld lgamma_r(half4 x, __private int4 *signp);
1769 half8 __ovld lgamma_r(half8 x, __private int8 *signp);
1770 half16 __ovld lgamma_r(half16 x, __private int16 *signp);
1771 #endif //cl_khr_fp16
1772-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
1773-
1774+#endif //! defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ !=
1775+ //! CL_VERSION_2_0)
1776 /**
1777 * Compute natural logarithm.
1778 */
1779@@ -7742,14 +7748,14 @@ float3 __ovld __cnfn log(float3);
1780 float4 __ovld __cnfn log(float4);
1781 float8 __ovld __cnfn log(float8);
1782 float16 __ovld __cnfn log(float16);
1783-#ifdef cl_khr_fp64
1784+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1785 double __ovld __cnfn log(double);
1786 double2 __ovld __cnfn log(double2);
1787 double3 __ovld __cnfn log(double3);
1788 double4 __ovld __cnfn log(double4);
1789 double8 __ovld __cnfn log(double8);
1790 double16 __ovld __cnfn log(double16);
1791-#endif //cl_khr_fp64
1792+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1793 #ifdef cl_khr_fp16
1794 half __ovld __cnfn log(half);
1795 half2 __ovld __cnfn log(half2);
1796@@ -7760,7 +7766,7 @@ half16 __ovld __cnfn log(half16);
1797 #endif //cl_khr_fp16
1798
1799 /**
1800- * Compute a base 2 logarithm.
1801+ * Compute a base 2 logarithm
1802 */
1803 float __ovld __cnfn log2(float);
1804 float2 __ovld __cnfn log2(float2);
1805@@ -7768,14 +7774,14 @@ float3 __ovld __cnfn log2(float3);
1806 float4 __ovld __cnfn log2(float4);
1807 float8 __ovld __cnfn log2(float8);
1808 float16 __ovld __cnfn log2(float16);
1809-#ifdef cl_khr_fp64
1810+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1811 double __ovld __cnfn log2(double);
1812 double2 __ovld __cnfn log2(double2);
1813 double3 __ovld __cnfn log2(double3);
1814 double4 __ovld __cnfn log2(double4);
1815 double8 __ovld __cnfn log2(double8);
1816 double16 __ovld __cnfn log2(double16);
1817-#endif //cl_khr_fp64
1818+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1819 #ifdef cl_khr_fp16
1820 half __ovld __cnfn log2(half);
1821 half2 __ovld __cnfn log2(half2);
1822@@ -7794,14 +7800,14 @@ float3 __ovld __cnfn log10(float3);
1823 float4 __ovld __cnfn log10(float4);
1824 float8 __ovld __cnfn log10(float8);
1825 float16 __ovld __cnfn log10(float16);
1826-#ifdef cl_khr_fp64
1827+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1828 double __ovld __cnfn log10(double);
1829 double2 __ovld __cnfn log10(double2);
1830 double3 __ovld __cnfn log10(double3);
1831 double4 __ovld __cnfn log10(double4);
1832 double8 __ovld __cnfn log10(double8);
1833 double16 __ovld __cnfn log10(double16);
1834-#endif //cl_khr_fp64
1835+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1836 #ifdef cl_khr_fp16
1837 half __ovld __cnfn log10(half);
1838 half2 __ovld __cnfn log10(half2);
1839@@ -7820,14 +7826,14 @@ float3 __ovld __cnfn log1p(float3 x);
1840 float4 __ovld __cnfn log1p(float4 x);
1841 float8 __ovld __cnfn log1p(float8 x);
1842 float16 __ovld __cnfn log1p(float16 x);
1843-#ifdef cl_khr_fp64
1844+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1845 double __ovld __cnfn log1p(double x);
1846 double2 __ovld __cnfn log1p(double2 x);
1847 double3 __ovld __cnfn log1p(double3 x);
1848 double4 __ovld __cnfn log1p(double4 x);
1849 double8 __ovld __cnfn log1p(double8 x);
1850 double16 __ovld __cnfn log1p(double16 x);
1851-#endif //cl_khr_fp64
1852+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1853 #ifdef cl_khr_fp16
1854 half __ovld __cnfn log1p(half x);
1855 half2 __ovld __cnfn log1p(half2 x);
1856@@ -7847,14 +7853,14 @@ float3 __ovld __cnfn logb(float3 x);
1857 float4 __ovld __cnfn logb(float4 x);
1858 float8 __ovld __cnfn logb(float8 x);
1859 float16 __ovld __cnfn logb(float16 x);
1860-#ifdef cl_khr_fp64
1861+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1862 double __ovld __cnfn logb(double x);
1863 double2 __ovld __cnfn logb(double2 x);
1864 double3 __ovld __cnfn logb(double3 x);
1865 double4 __ovld __cnfn logb(double4 x);
1866 double8 __ovld __cnfn logb(double8 x);
1867 double16 __ovld __cnfn logb(double16 x);
1868-#endif //cl_khr_fp64
1869+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1870 #ifdef cl_khr_fp16
1871 half __ovld __cnfn logb(half x);
1872 half2 __ovld __cnfn logb(half2 x);
1873@@ -7877,14 +7883,14 @@ float3 __ovld __cnfn mad(float3 a, float3 b, float3 c);
1874 float4 __ovld __cnfn mad(float4 a, float4 b, float4 c);
1875 float8 __ovld __cnfn mad(float8 a, float8 b, float8 c);
1876 float16 __ovld __cnfn mad(float16 a, float16 b, float16 c);
1877-#ifdef cl_khr_fp64
1878+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1879 double __ovld __cnfn mad(double a, double b, double c);
1880 double2 __ovld __cnfn mad(double2 a, double2 b, double2 c);
1881 double3 __ovld __cnfn mad(double3 a, double3 b, double3 c);
1882 double4 __ovld __cnfn mad(double4 a, double4 b, double4 c);
1883 double8 __ovld __cnfn mad(double8 a, double8 b, double8 c);
1884 double16 __ovld __cnfn mad(double16 a, double16 b, double16 c);
1885-#endif //cl_khr_fp64
1886+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1887 #ifdef cl_khr_fp16
1888 half __ovld __cnfn mad(half a, half b, half c);
1889 half2 __ovld __cnfn mad(half2 a, half2 b, half2 c);
1890@@ -7904,14 +7910,14 @@ float3 __ovld __cnfn maxmag(float3 x, float3 y);
1891 float4 __ovld __cnfn maxmag(float4 x, float4 y);
1892 float8 __ovld __cnfn maxmag(float8 x, float8 y);
1893 float16 __ovld __cnfn maxmag(float16 x, float16 y);
1894-#ifdef cl_khr_fp64
1895+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1896 double __ovld __cnfn maxmag(double x, double y);
1897 double2 __ovld __cnfn maxmag(double2 x, double2 y);
1898 double3 __ovld __cnfn maxmag(double3 x, double3 y);
1899 double4 __ovld __cnfn maxmag(double4 x, double4 y);
1900 double8 __ovld __cnfn maxmag(double8 x, double8 y);
1901 double16 __ovld __cnfn maxmag(double16 x, double16 y);
1902-#endif //cl_khr_fp64
1903+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1904 #ifdef cl_khr_fp16
1905 half __ovld __cnfn maxmag(half x, half y);
1906 half2 __ovld __cnfn maxmag(half2 x, half2 y);
1907@@ -7931,14 +7937,14 @@ float3 __ovld __cnfn minmag(float3 x, float3 y);
1908 float4 __ovld __cnfn minmag(float4 x, float4 y);
1909 float8 __ovld __cnfn minmag(float8 x, float8 y);
1910 float16 __ovld __cnfn minmag(float16 x, float16 y);
1911-#ifdef cl_khr_fp64
1912+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1913 double __ovld __cnfn minmag(double x, double y);
1914 double2 __ovld __cnfn minmag(double2 x, double2 y);
1915 double3 __ovld __cnfn minmag(double3 x, double3 y);
1916 double4 __ovld __cnfn minmag(double4 x, double4 y);
1917 double8 __ovld __cnfn minmag(double8 x, double8 y);
1918 double16 __ovld __cnfn minmag(double16 x, double16 y);
1919-#endif //cl_khr_fp64
1920+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1921 #ifdef cl_khr_fp16
1922 half __ovld __cnfn minmag(half x, half y);
1923 half2 __ovld __cnfn minmag(half2 x, half2 y);
1924@@ -7955,21 +7961,21 @@ half16 __ovld __cnfn minmag(half16 x, half16 y);
1925 * the argument. It stores the integral part in the object
1926 * pointed to by iptr.
1927 */
1928-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
1929+#ifdef __opencl_c_generic_address_space
1930 float __ovld modf(float x, float *iptr);
1931 float2 __ovld modf(float2 x, float2 *iptr);
1932 float3 __ovld modf(float3 x, float3 *iptr);
1933 float4 __ovld modf(float4 x, float4 *iptr);
1934 float8 __ovld modf(float8 x, float8 *iptr);
1935 float16 __ovld modf(float16 x, float16 *iptr);
1936-#ifdef cl_khr_fp64
1937+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1938 double __ovld modf(double x, double *iptr);
1939 double2 __ovld modf(double2 x, double2 *iptr);
1940 double3 __ovld modf(double3 x, double3 *iptr);
1941 double4 __ovld modf(double4 x, double4 *iptr);
1942 double8 __ovld modf(double8 x, double8 *iptr);
1943 double16 __ovld modf(double16 x, double16 *iptr);
1944-#endif //cl_khr_fp64
1945+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1946 #ifdef cl_khr_fp16
1947 half __ovld modf(half x, half *iptr);
1948 half2 __ovld modf(half2 x, half2 *iptr);
1949@@ -7978,7 +7984,9 @@ half4 __ovld modf(half4 x, half4 *iptr);
1950 half8 __ovld modf(half8 x, half8 *iptr);
1951 half16 __ovld modf(half16 x, half16 *iptr);
1952 #endif //cl_khr_fp16
1953-#else
1954+#endif //__opencl_c_generic_address_space
1955+
1956+#if !defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ != CL_VERSION_2_0)
1957 float __ovld modf(float x, __global float *iptr);
1958 float2 __ovld modf(float2 x, __global float2 *iptr);
1959 float3 __ovld modf(float3 x, __global float3 *iptr);
1960@@ -7997,7 +8005,7 @@ float3 __ovld modf(float3 x, __private float3 *iptr);
1961 float4 __ovld modf(float4 x, __private float4 *iptr);
1962 float8 __ovld modf(float8 x, __private float8 *iptr);
1963 float16 __ovld modf(float16 x, __private float16 *iptr);
1964-#ifdef cl_khr_fp64
1965+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1966 double __ovld modf(double x, __global double *iptr);
1967 double2 __ovld modf(double2 x, __global double2 *iptr);
1968 double3 __ovld modf(double3 x, __global double3 *iptr);
1969@@ -8016,7 +8024,7 @@ double3 __ovld modf(double3 x, __private double3 *iptr);
1970 double4 __ovld modf(double4 x, __private double4 *iptr);
1971 double8 __ovld modf(double8 x, __private double8 *iptr);
1972 double16 __ovld modf(double16 x, __private double16 *iptr);
1973-#endif //cl_khr_fp64
1974+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1975 #ifdef cl_khr_fp16
1976 half __ovld modf(half x, __global half *iptr);
1977 half2 __ovld modf(half2 x, __global half2 *iptr);
1978@@ -8037,7 +8045,8 @@ half4 __ovld modf(half4 x, __private half4 *iptr);
1979 half8 __ovld modf(half8 x, __private half8 *iptr);
1980 half16 __ovld modf(half16 x, __private half16 *iptr);
1981 #endif //cl_khr_fp16
1982-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
1983+#endif //! defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ !=
1984+ //! CL_VERSION_2_0)
1985
1986 /**
1987 * Returns a quiet NaN. The nancode may be placed
1988@@ -8049,14 +8058,14 @@ float3 __ovld __cnfn nan(uint3 nancode);
1989 float4 __ovld __cnfn nan(uint4 nancode);
1990 float8 __ovld __cnfn nan(uint8 nancode);
1991 float16 __ovld __cnfn nan(uint16 nancode);
1992-#ifdef cl_khr_fp64
1993+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1994 double __ovld __cnfn nan(ulong nancode);
1995 double2 __ovld __cnfn nan(ulong2 nancode);
1996 double3 __ovld __cnfn nan(ulong3 nancode);
1997 double4 __ovld __cnfn nan(ulong4 nancode);
1998 double8 __ovld __cnfn nan(ulong8 nancode);
1999 double16 __ovld __cnfn nan(ulong16 nancode);
2000-#endif //cl_khr_fp64
2001+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2002 #ifdef cl_khr_fp16
2003 half __ovld __cnfn nan(ushort nancode);
2004 half2 __ovld __cnfn nan(ushort2 nancode);
2005@@ -8079,14 +8088,14 @@ float3 __ovld __cnfn nextafter(float3 x, float3 y);
2006 float4 __ovld __cnfn nextafter(float4 x, float4 y);
2007 float8 __ovld __cnfn nextafter(float8 x, float8 y);
2008 float16 __ovld __cnfn nextafter(float16 x, float16 y);
2009-#ifdef cl_khr_fp64
2010+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2011 double __ovld __cnfn nextafter(double x, double y);
2012 double2 __ovld __cnfn nextafter(double2 x, double2 y);
2013 double3 __ovld __cnfn nextafter(double3 x, double3 y);
2014 double4 __ovld __cnfn nextafter(double4 x, double4 y);
2015 double8 __ovld __cnfn nextafter(double8 x, double8 y);
2016 double16 __ovld __cnfn nextafter(double16 x, double16 y);
2017-#endif //cl_khr_fp64
2018+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2019 #ifdef cl_khr_fp16
2020 half __ovld __cnfn nextafter(half x, half y);
2021 half2 __ovld __cnfn nextafter(half2 x, half2 y);
2022@@ -8105,14 +8114,14 @@ float3 __ovld __cnfn pow(float3 x, float3 y);
2023 float4 __ovld __cnfn pow(float4 x, float4 y);
2024 float8 __ovld __cnfn pow(float8 x, float8 y);
2025 float16 __ovld __cnfn pow(float16 x, float16 y);
2026-#ifdef cl_khr_fp64
2027+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2028 double __ovld __cnfn pow(double x, double y);
2029 double2 __ovld __cnfn pow(double2 x, double2 y);
2030 double3 __ovld __cnfn pow(double3 x, double3 y);
2031 double4 __ovld __cnfn pow(double4 x, double4 y);
2032 double8 __ovld __cnfn pow(double8 x, double8 y);
2033 double16 __ovld __cnfn pow(double16 x, double16 y);
2034-#endif //cl_khr_fp64
2035+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2036 #ifdef cl_khr_fp16
2037 half __ovld __cnfn pow(half x, half y);
2038 half2 __ovld __cnfn pow(half2 x, half2 y);
2039@@ -8131,14 +8140,14 @@ float3 __ovld __cnfn pown(float3 x, int3 y);
2040 float4 __ovld __cnfn pown(float4 x, int4 y);
2041 float8 __ovld __cnfn pown(float8 x, int8 y);
2042 float16 __ovld __cnfn pown(float16 x, int16 y);
2043-#ifdef cl_khr_fp64
2044+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2045 double __ovld __cnfn pown(double x, int y);
2046 double2 __ovld __cnfn pown(double2 x, int2 y);
2047 double3 __ovld __cnfn pown(double3 x, int3 y);
2048 double4 __ovld __cnfn pown(double4 x, int4 y);
2049 double8 __ovld __cnfn pown(double8 x, int8 y);
2050 double16 __ovld __cnfn pown(double16 x, int16 y);
2051-#endif //cl_khr_fp64
2052+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2053 #ifdef cl_khr_fp16
2054 half __ovld __cnfn pown(half x, int y);
2055 half2 __ovld __cnfn pown(half2 x, int2 y);
2056@@ -8157,14 +8166,14 @@ float3 __ovld __cnfn powr(float3 x, float3 y);
2057 float4 __ovld __cnfn powr(float4 x, float4 y);
2058 float8 __ovld __cnfn powr(float8 x, float8 y);
2059 float16 __ovld __cnfn powr(float16 x, float16 y);
2060-#ifdef cl_khr_fp64
2061+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2062 double __ovld __cnfn powr(double x, double y);
2063 double2 __ovld __cnfn powr(double2 x, double2 y);
2064 double3 __ovld __cnfn powr(double3 x, double3 y);
2065 double4 __ovld __cnfn powr(double4 x, double4 y);
2066 double8 __ovld __cnfn powr(double8 x, double8 y);
2067 double16 __ovld __cnfn powr(double16 x, double16 y);
2068-#endif //cl_khr_fp64
2069+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2070 #ifdef cl_khr_fp16
2071 half __ovld __cnfn powr(half x, half y);
2072 half2 __ovld __cnfn powr(half2 x, half2 y);
2073@@ -8186,14 +8195,14 @@ float3 __ovld __cnfn remainder(float3 x, float3 y);
2074 float4 __ovld __cnfn remainder(float4 x, float4 y);
2075 float8 __ovld __cnfn remainder(float8 x, float8 y);
2076 float16 __ovld __cnfn remainder(float16 x, float16 y);
2077-#ifdef cl_khr_fp64
2078+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2079 double __ovld __cnfn remainder(double x, double y);
2080 double2 __ovld __cnfn remainder(double2 x, double2 y);
2081 double3 __ovld __cnfn remainder(double3 x, double3 y);
2082 double4 __ovld __cnfn remainder(double4 x, double4 y);
2083 double8 __ovld __cnfn remainder(double8 x, double8 y);
2084 double16 __ovld __cnfn remainder(double16 x, double16 y);
2085-#endif //cl_khr_fp64
2086+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2087 #ifdef cl_khr_fp16
2088 half __ovld __cnfn remainder(half x, half y);
2089 half2 __ovld __cnfn remainder(half2 x, half2 y);
2090@@ -8215,21 +8224,21 @@ half16 __ovld __cnfn remainder(half16 x, half16 y);
2091 * sign as x/y. It stores this signed value in the object
2092 * pointed to by quo.
2093 */
2094-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
2095+#ifdef __opencl_c_generic_address_space
2096 float __ovld remquo(float x, float y, int *quo);
2097 float2 __ovld remquo(float2 x, float2 y, int2 *quo);
2098 float3 __ovld remquo(float3 x, float3 y, int3 *quo);
2099 float4 __ovld remquo(float4 x, float4 y, int4 *quo);
2100 float8 __ovld remquo(float8 x, float8 y, int8 *quo);
2101 float16 __ovld remquo(float16 x, float16 y, int16 *quo);
2102-#ifdef cl_khr_fp64
2103+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2104 double __ovld remquo(double x, double y, int *quo);
2105 double2 __ovld remquo(double2 x, double2 y, int2 *quo);
2106 double3 __ovld remquo(double3 x, double3 y, int3 *quo);
2107 double4 __ovld remquo(double4 x, double4 y, int4 *quo);
2108 double8 __ovld remquo(double8 x, double8 y, int8 *quo);
2109 double16 __ovld remquo(double16 x, double16 y, int16 *quo);
2110-#endif //cl_khr_fp64
2111+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2112 #ifdef cl_khr_fp16
2113 half __ovld remquo(half x, half y, int *quo);
2114 half2 __ovld remquo(half2 x, half2 y, int2 *quo);
2115@@ -8237,9 +8246,10 @@ half3 __ovld remquo(half3 x, half3 y, int3 *quo);
2116 half4 __ovld remquo(half4 x, half4 y, int4 *quo);
2117 half8 __ovld remquo(half8 x, half8 y, int8 *quo);
2118 half16 __ovld remquo(half16 x, half16 y, int16 *quo);
2119-
2120 #endif //cl_khr_fp16
2121-#else
2122+#endif //__opencl_c_generic_address_space
2123+
2124+#if !defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ != CL_VERSION_2_0)
2125 float __ovld remquo(float x, float y, __global int *quo);
2126 float2 __ovld remquo(float2 x, float2 y, __global int2 *quo);
2127 float3 __ovld remquo(float3 x, float3 y, __global int3 *quo);
2128@@ -8258,7 +8268,7 @@ float3 __ovld remquo(float3 x, float3 y, __private int3 *quo);
2129 float4 __ovld remquo(float4 x, float4 y, __private int4 *quo);
2130 float8 __ovld remquo(float8 x, float8 y, __private int8 *quo);
2131 float16 __ovld remquo(float16 x, float16 y, __private int16 *quo);
2132-#ifdef cl_khr_fp64
2133+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2134 double __ovld remquo(double x, double y, __global int *quo);
2135 double2 __ovld remquo(double2 x, double2 y, __global int2 *quo);
2136 double3 __ovld remquo(double3 x, double3 y, __global int3 *quo);
2137@@ -8277,7 +8287,7 @@ double3 __ovld remquo(double3 x, double3 y, __private int3 *quo);
2138 double4 __ovld remquo(double4 x, double4 y, __private int4 *quo);
2139 double8 __ovld remquo(double8 x, double8 y, __private int8 *quo);
2140 double16 __ovld remquo(double16 x, double16 y, __private int16 *quo);
2141-#endif //cl_khr_fp64
2142+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2143 #ifdef cl_khr_fp16
2144 half __ovld remquo(half x, half y, __global int *quo);
2145 half2 __ovld remquo(half2 x, half2 y, __global int2 *quo);
2146@@ -8298,7 +8308,8 @@ half4 __ovld remquo(half4 x, half4 y, __private int4 *quo);
2147 half8 __ovld remquo(half8 x, half8 y, __private int8 *quo);
2148 half16 __ovld remquo(half16 x, half16 y, __private int16 *quo);
2149 #endif //cl_khr_fp16
2150-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
2151+#endif //! defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ !=
2152+ //! CL_VERSION_2_0)
2153 /**
2154 * Round to integral value (using round to nearest
2155 * even rounding mode) in floating-point format.
2156@@ -8311,14 +8322,14 @@ float3 __ovld __cnfn rint(float3);
2157 float4 __ovld __cnfn rint(float4);
2158 float8 __ovld __cnfn rint(float8);
2159 float16 __ovld __cnfn rint(float16);
2160-#ifdef cl_khr_fp64
2161+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2162 double __ovld __cnfn rint(double);
2163 double2 __ovld __cnfn rint(double2);
2164 double3 __ovld __cnfn rint(double3);
2165 double4 __ovld __cnfn rint(double4);
2166 double8 __ovld __cnfn rint(double8);
2167 double16 __ovld __cnfn rint(double16);
2168-#endif //cl_khr_fp64
2169+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2170 #ifdef cl_khr_fp16
2171 half __ovld __cnfn rint(half);
2172 half2 __ovld __cnfn rint(half2);
2173@@ -8337,14 +8348,14 @@ float3 __ovld __cnfn rootn(float3 x, int3 y);
2174 float4 __ovld __cnfn rootn(float4 x, int4 y);
2175 float8 __ovld __cnfn rootn(float8 x, int8 y);
2176 float16 __ovld __cnfn rootn(float16 x, int16 y);
2177-#ifdef cl_khr_fp64
2178+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2179 double __ovld __cnfn rootn(double x, int y);
2180 double2 __ovld __cnfn rootn(double2 x, int2 y);
2181 double3 __ovld __cnfn rootn(double3 x, int3 y);
2182 double4 __ovld __cnfn rootn(double4 x, int4 y);
2183 double8 __ovld __cnfn rootn(double8 x, int8 y);
2184 double16 __ovld __cnfn rootn(double16 x, int16 y);
2185-#endif //cl_khr_fp64
2186+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2187 #ifdef cl_khr_fp16
2188 half __ovld __cnfn rootn(half x, int y);
2189 half2 __ovld __cnfn rootn(half2 x, int2 y);
2190@@ -8365,14 +8376,14 @@ float3 __ovld __cnfn round(float3 x);
2191 float4 __ovld __cnfn round(float4 x);
2192 float8 __ovld __cnfn round(float8 x);
2193 float16 __ovld __cnfn round(float16 x);
2194-#ifdef cl_khr_fp64
2195+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2196 double __ovld __cnfn round(double x);
2197 double2 __ovld __cnfn round(double2 x);
2198 double3 __ovld __cnfn round(double3 x);
2199 double4 __ovld __cnfn round(double4 x);
2200 double8 __ovld __cnfn round(double8 x);
2201 double16 __ovld __cnfn round(double16 x);
2202-#endif //cl_khr_fp64
2203+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2204 #ifdef cl_khr_fp16
2205 half __ovld __cnfn round(half x);
2206 half2 __ovld __cnfn round(half2 x);
2207@@ -8391,14 +8402,14 @@ float3 __ovld __cnfn rsqrt(float3);
2208 float4 __ovld __cnfn rsqrt(float4);
2209 float8 __ovld __cnfn rsqrt(float8);
2210 float16 __ovld __cnfn rsqrt(float16);
2211-#ifdef cl_khr_fp64
2212+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2213 double __ovld __cnfn rsqrt(double);
2214 double2 __ovld __cnfn rsqrt(double2);
2215 double3 __ovld __cnfn rsqrt(double3);
2216 double4 __ovld __cnfn rsqrt(double4);
2217 double8 __ovld __cnfn rsqrt(double8);
2218 double16 __ovld __cnfn rsqrt(double16);
2219-#endif //cl_khr_fp64
2220+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2221 #ifdef cl_khr_fp16
2222 half __ovld __cnfn rsqrt(half);
2223 half2 __ovld __cnfn rsqrt(half2);
2224@@ -8417,14 +8428,14 @@ float3 __ovld __cnfn sin(float3);
2225 float4 __ovld __cnfn sin(float4);
2226 float8 __ovld __cnfn sin(float8);
2227 float16 __ovld __cnfn sin(float16);
2228-#ifdef cl_khr_fp64
2229+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2230 double __ovld __cnfn sin(double);
2231 double2 __ovld __cnfn sin(double2);
2232 double3 __ovld __cnfn sin(double3);
2233 double4 __ovld __cnfn sin(double4);
2234 double8 __ovld __cnfn sin(double8);
2235 double16 __ovld __cnfn sin(double16);
2236-#endif //cl_khr_fp64
2237+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2238 #ifdef cl_khr_fp16
2239 half __ovld __cnfn sin(half);
2240 half2 __ovld __cnfn sin(half2);
2241@@ -8439,21 +8450,21 @@ half16 __ovld __cnfn sin(half16);
2242 * is the return value and computed cosine is returned
2243 * in cosval.
2244 */
2245-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
2246+#ifdef __opencl_c_generic_address_space
2247 float __ovld sincos(float x, float *cosval);
2248 float2 __ovld sincos(float2 x, float2 *cosval);
2249 float3 __ovld sincos(float3 x, float3 *cosval);
2250 float4 __ovld sincos(float4 x, float4 *cosval);
2251 float8 __ovld sincos(float8 x, float8 *cosval);
2252 float16 __ovld sincos(float16 x, float16 *cosval);
2253-#ifdef cl_khr_fp64
2254+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2255 double __ovld sincos(double x, double *cosval);
2256 double2 __ovld sincos(double2 x, double2 *cosval);
2257 double3 __ovld sincos(double3 x, double3 *cosval);
2258 double4 __ovld sincos(double4 x, double4 *cosval);
2259 double8 __ovld sincos(double8 x, double8 *cosval);
2260 double16 __ovld sincos(double16 x, double16 *cosval);
2261-#endif //cl_khr_fp64
2262+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2263 #ifdef cl_khr_fp16
2264 half __ovld sincos(half x, half *cosval);
2265 half2 __ovld sincos(half2 x, half2 *cosval);
2266@@ -8462,7 +8473,9 @@ half4 __ovld sincos(half4 x, half4 *cosval);
2267 half8 __ovld sincos(half8 x, half8 *cosval);
2268 half16 __ovld sincos(half16 x, half16 *cosval);
2269 #endif //cl_khr_fp16
2270-#else
2271+#endif //__opencl_c_generic_address_space
2272+
2273+#if !defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ != CL_VERSION_2_0)
2274 float __ovld sincos(float x, __global float *cosval);
2275 float2 __ovld sincos(float2 x, __global float2 *cosval);
2276 float3 __ovld sincos(float3 x, __global float3 *cosval);
2277@@ -8481,7 +8494,7 @@ float3 __ovld sincos(float3 x, __private float3 *cosval);
2278 float4 __ovld sincos(float4 x, __private float4 *cosval);
2279 float8 __ovld sincos(float8 x, __private float8 *cosval);
2280 float16 __ovld sincos(float16 x, __private float16 *cosval);
2281-#ifdef cl_khr_fp64
2282+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2283 double __ovld sincos(double x, __global double *cosval);
2284 double2 __ovld sincos(double2 x, __global double2 *cosval);
2285 double3 __ovld sincos(double3 x, __global double3 *cosval);
2286@@ -8500,7 +8513,7 @@ double3 __ovld sincos(double3 x, __private double3 *cosval);
2287 double4 __ovld sincos(double4 x, __private double4 *cosval);
2288 double8 __ovld sincos(double8 x, __private double8 *cosval);
2289 double16 __ovld sincos(double16 x, __private double16 *cosval);
2290-#endif //cl_khr_fp64
2291+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2292 #ifdef cl_khr_fp16
2293 half __ovld sincos(half x, __global half *cosval);
2294 half2 __ovld sincos(half2 x, __global half2 *cosval);
2295@@ -8521,8 +8534,8 @@ half4 __ovld sincos(half4 x, __private half4 *cosval);
2296 half8 __ovld sincos(half8 x, __private half8 *cosval);
2297 half16 __ovld sincos(half16 x, __private half16 *cosval);
2298 #endif //cl_khr_fp16
2299-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
2300-
2301+#endif //! defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ !=
2302+ //! CL_VERSION_2_0)
2303 /**
2304 * Compute hyperbolic sine.
2305 */
2306@@ -8532,14 +8545,14 @@ float3 __ovld __cnfn sinh(float3);
2307 float4 __ovld __cnfn sinh(float4);
2308 float8 __ovld __cnfn sinh(float8);
2309 float16 __ovld __cnfn sinh(float16);
2310-#ifdef cl_khr_fp64
2311+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2312 double __ovld __cnfn sinh(double);
2313 double2 __ovld __cnfn sinh(double2);
2314 double3 __ovld __cnfn sinh(double3);
2315 double4 __ovld __cnfn sinh(double4);
2316 double8 __ovld __cnfn sinh(double8);
2317 double16 __ovld __cnfn sinh(double16);
2318-#endif //cl_khr_fp64
2319+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2320 #ifdef cl_khr_fp16
2321 half __ovld __cnfn sinh(half);
2322 half2 __ovld __cnfn sinh(half2);
2323@@ -8558,14 +8571,14 @@ float3 __ovld __cnfn sinpi(float3 x);
2324 float4 __ovld __cnfn sinpi(float4 x);
2325 float8 __ovld __cnfn sinpi(float8 x);
2326 float16 __ovld __cnfn sinpi(float16 x);
2327-#ifdef cl_khr_fp64
2328+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2329 double __ovld __cnfn sinpi(double x);
2330 double2 __ovld __cnfn sinpi(double2 x);
2331 double3 __ovld __cnfn sinpi(double3 x);
2332 double4 __ovld __cnfn sinpi(double4 x);
2333 double8 __ovld __cnfn sinpi(double8 x);
2334 double16 __ovld __cnfn sinpi(double16 x);
2335-#endif //cl_khr_fp64
2336+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2337 #ifdef cl_khr_fp16
2338 half __ovld __cnfn sinpi(half x);
2339 half2 __ovld __cnfn sinpi(half2 x);
2340@@ -8584,14 +8597,14 @@ float3 __ovld __cnfn sqrt(float3);
2341 float4 __ovld __cnfn sqrt(float4);
2342 float8 __ovld __cnfn sqrt(float8);
2343 float16 __ovld __cnfn sqrt(float16);
2344-#ifdef cl_khr_fp64
2345+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2346 double __ovld __cnfn sqrt(double);
2347 double2 __ovld __cnfn sqrt(double2);
2348 double3 __ovld __cnfn sqrt(double3);
2349 double4 __ovld __cnfn sqrt(double4);
2350 double8 __ovld __cnfn sqrt(double8);
2351 double16 __ovld __cnfn sqrt(double16);
2352-#endif //cl_khr_fp64
2353+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2354 #ifdef cl_khr_fp16
2355 half __ovld __cnfn sqrt(half);
2356 half2 __ovld __cnfn sqrt(half2);
2357@@ -8610,14 +8623,14 @@ float3 __ovld __cnfn tan(float3);
2358 float4 __ovld __cnfn tan(float4);
2359 float8 __ovld __cnfn tan(float8);
2360 float16 __ovld __cnfn tan(float16);
2361-#ifdef cl_khr_fp64
2362+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2363 double __ovld __cnfn tan(double);
2364 double2 __ovld __cnfn tan(double2);
2365 double3 __ovld __cnfn tan(double3);
2366 double4 __ovld __cnfn tan(double4);
2367 double8 __ovld __cnfn tan(double8);
2368 double16 __ovld __cnfn tan(double16);
2369-#endif //cl_khr_fp64
2370+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2371 #ifdef cl_khr_fp16
2372 half __ovld __cnfn tan(half);
2373 half2 __ovld __cnfn tan(half2);
2374@@ -8636,14 +8649,14 @@ float3 __ovld __cnfn tanh(float3);
2375 float4 __ovld __cnfn tanh(float4);
2376 float8 __ovld __cnfn tanh(float8);
2377 float16 __ovld __cnfn tanh(float16);
2378-#ifdef cl_khr_fp64
2379+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2380 double __ovld __cnfn tanh(double);
2381 double2 __ovld __cnfn tanh(double2);
2382 double3 __ovld __cnfn tanh(double3);
2383 double4 __ovld __cnfn tanh(double4);
2384 double8 __ovld __cnfn tanh(double8);
2385 double16 __ovld __cnfn tanh(double16);
2386-#endif //cl_khr_fp64
2387+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2388 #ifdef cl_khr_fp16
2389 half __ovld __cnfn tanh(half);
2390 half2 __ovld __cnfn tanh(half2);
2391@@ -8662,14 +8675,14 @@ float3 __ovld __cnfn tanpi(float3 x);
2392 float4 __ovld __cnfn tanpi(float4 x);
2393 float8 __ovld __cnfn tanpi(float8 x);
2394 float16 __ovld __cnfn tanpi(float16 x);
2395-#ifdef cl_khr_fp64
2396+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2397 double __ovld __cnfn tanpi(double x);
2398 double2 __ovld __cnfn tanpi(double2 x);
2399 double3 __ovld __cnfn tanpi(double3 x);
2400 double4 __ovld __cnfn tanpi(double4 x);
2401 double8 __ovld __cnfn tanpi(double8 x);
2402 double16 __ovld __cnfn tanpi(double16 x);
2403-#endif //cl_khr_fp64
2404+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2405 #ifdef cl_khr_fp16
2406 half __ovld __cnfn tanpi(half x);
2407 half2 __ovld __cnfn tanpi(half2 x);
2408@@ -8688,14 +8701,14 @@ float3 __ovld __cnfn tgamma(float3);
2409 float4 __ovld __cnfn tgamma(float4);
2410 float8 __ovld __cnfn tgamma(float8);
2411 float16 __ovld __cnfn tgamma(float16);
2412-#ifdef cl_khr_fp64
2413+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2414 double __ovld __cnfn tgamma(double);
2415 double2 __ovld __cnfn tgamma(double2);
2416 double3 __ovld __cnfn tgamma(double3);
2417 double4 __ovld __cnfn tgamma(double4);
2418 double8 __ovld __cnfn tgamma(double8);
2419 double16 __ovld __cnfn tgamma(double16);
2420-#endif //cl_khr_fp64
2421+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2422 #ifdef cl_khr_fp16
2423 half __ovld __cnfn tgamma(half);
2424 half2 __ovld __cnfn tgamma(half2);
2425@@ -8715,14 +8728,14 @@ float3 __ovld __cnfn trunc(float3);
2426 float4 __ovld __cnfn trunc(float4);
2427 float8 __ovld __cnfn trunc(float8);
2428 float16 __ovld __cnfn trunc(float16);
2429-#ifdef cl_khr_fp64
2430+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2431 double __ovld __cnfn trunc(double);
2432 double2 __ovld __cnfn trunc(double2);
2433 double3 __ovld __cnfn trunc(double3);
2434 double4 __ovld __cnfn trunc(double4);
2435 double8 __ovld __cnfn trunc(double8);
2436 double16 __ovld __cnfn trunc(double16);
2437-#endif //cl_khr_fp64
2438+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2439 #ifdef cl_khr_fp16
2440 half __ovld __cnfn trunc(half);
2441 half2 __ovld __cnfn trunc(half2);
2442@@ -10108,7 +10121,7 @@ float3 __ovld __cnfn clamp(float3 x, float minval, float maxval);
2443 float4 __ovld __cnfn clamp(float4 x, float minval, float maxval);
2444 float8 __ovld __cnfn clamp(float8 x, float minval, float maxval);
2445 float16 __ovld __cnfn clamp(float16 x, float minval, float maxval);
2446-#ifdef cl_khr_fp64
2447+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2448 double __ovld __cnfn clamp(double x, double minval, double maxval);
2449 double2 __ovld __cnfn clamp(double2 x, double2 minval, double2 maxval);
2450 double3 __ovld __cnfn clamp(double3 x, double3 minval, double3 maxval);
2451@@ -10120,7 +10133,7 @@ double3 __ovld __cnfn clamp(double3 x, double minval, double maxval);
2452 double4 __ovld __cnfn clamp(double4 x, double minval, double maxval);
2453 double8 __ovld __cnfn clamp(double8 x, double minval, double maxval);
2454 double16 __ovld __cnfn clamp(double16 x, double minval, double maxval);
2455-#endif //cl_khr_fp64
2456+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2457 #ifdef cl_khr_fp16
2458 half __ovld __cnfn clamp(half x, half minval, half maxval);
2459 half2 __ovld __cnfn clamp(half2 x, half2 minval, half2 maxval);
2460@@ -10145,14 +10158,14 @@ float3 __ovld __cnfn degrees(float3 radians);
2461 float4 __ovld __cnfn degrees(float4 radians);
2462 float8 __ovld __cnfn degrees(float8 radians);
2463 float16 __ovld __cnfn degrees(float16 radians);
2464-#ifdef cl_khr_fp64
2465+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2466 double __ovld __cnfn degrees(double radians);
2467 double2 __ovld __cnfn degrees(double2 radians);
2468 double3 __ovld __cnfn degrees(double3 radians);
2469 double4 __ovld __cnfn degrees(double4 radians);
2470 double8 __ovld __cnfn degrees(double8 radians);
2471 double16 __ovld __cnfn degrees(double16 radians);
2472-#endif //cl_khr_fp64
2473+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2474 #ifdef cl_khr_fp16
2475 half __ovld __cnfn degrees(half radians);
2476 half2 __ovld __cnfn degrees(half2 radians);
2477@@ -10177,7 +10190,7 @@ float3 __ovld __cnfn max(float3 x, float y);
2478 float4 __ovld __cnfn max(float4 x, float y);
2479 float8 __ovld __cnfn max(float8 x, float y);
2480 float16 __ovld __cnfn max(float16 x, float y);
2481-#ifdef cl_khr_fp64
2482+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2483 double __ovld __cnfn max(double x, double y);
2484 double2 __ovld __cnfn max(double2 x, double2 y);
2485 double3 __ovld __cnfn max(double3 x, double3 y);
2486@@ -10189,7 +10202,7 @@ double3 __ovld __cnfn max(double3 x, double y);
2487 double4 __ovld __cnfn max(double4 x, double y);
2488 double8 __ovld __cnfn max(double8 x, double y);
2489 double16 __ovld __cnfn max(double16 x, double y);
2490-#endif //cl_khr_fp64
2491+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2492 #ifdef cl_khr_fp16
2493 half __ovld __cnfn max(half x, half y);
2494 half2 __ovld __cnfn max(half2 x, half2 y);
2495@@ -10219,7 +10232,7 @@ float3 __ovld __cnfn min(float3 x, float y);
2496 float4 __ovld __cnfn min(float4 x, float y);
2497 float8 __ovld __cnfn min(float8 x, float y);
2498 float16 __ovld __cnfn min(float16 x, float y);
2499-#ifdef cl_khr_fp64
2500+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2501 double __ovld __cnfn min(double x, double y);
2502 double2 __ovld __cnfn min(double2 x, double2 y);
2503 double3 __ovld __cnfn min(double3 x, double3 y);
2504@@ -10231,7 +10244,7 @@ double3 __ovld __cnfn min(double3 x, double y);
2505 double4 __ovld __cnfn min(double4 x, double y);
2506 double8 __ovld __cnfn min(double8 x, double y);
2507 double16 __ovld __cnfn min(double16 x, double y);
2508-#endif //cl_khr_fp64
2509+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2510 #ifdef cl_khr_fp16
2511 half __ovld __cnfn min(half x, half y);
2512 half2 __ovld __cnfn min(half2 x, half2 y);
2513@@ -10264,7 +10277,7 @@ float3 __ovld __cnfn mix(float3 x, float3 y, float a);
2514 float4 __ovld __cnfn mix(float4 x, float4 y, float a);
2515 float8 __ovld __cnfn mix(float8 x, float8 y, float a);
2516 float16 __ovld __cnfn mix(float16 x, float16 y, float a);
2517-#ifdef cl_khr_fp64
2518+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2519 double __ovld __cnfn mix(double x, double y, double a);
2520 double2 __ovld __cnfn mix(double2 x, double2 y, double2 a);
2521 double3 __ovld __cnfn mix(double3 x, double3 y, double3 a);
2522@@ -10276,7 +10289,7 @@ double3 __ovld __cnfn mix(double3 x, double3 y, double a);
2523 double4 __ovld __cnfn mix(double4 x, double4 y, double a);
2524 double8 __ovld __cnfn mix(double8 x, double8 y, double a);
2525 double16 __ovld __cnfn mix(double16 x, double16 y, double a);
2526-#endif //cl_khr_fp64
2527+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2528 #ifdef cl_khr_fp16
2529 half __ovld __cnfn mix(half x, half y, half a);
2530 half2 __ovld __cnfn mix(half2 x, half2 y, half2 a);
2531@@ -10301,14 +10314,14 @@ float3 __ovld __cnfn radians(float3 degrees);
2532 float4 __ovld __cnfn radians(float4 degrees);
2533 float8 __ovld __cnfn radians(float8 degrees);
2534 float16 __ovld __cnfn radians(float16 degrees);
2535-#ifdef cl_khr_fp64
2536+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2537 double __ovld __cnfn radians(double degrees);
2538 double2 __ovld __cnfn radians(double2 degrees);
2539 double3 __ovld __cnfn radians(double3 degrees);
2540 double4 __ovld __cnfn radians(double4 degrees);
2541 double8 __ovld __cnfn radians(double8 degrees);
2542 double16 __ovld __cnfn radians(double16 degrees);
2543-#endif //cl_khr_fp64
2544+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2545 #ifdef cl_khr_fp16
2546 half __ovld __cnfn radians(half degrees);
2547 half2 __ovld __cnfn radians(half2 degrees);
2548@@ -10332,7 +10345,7 @@ float3 __ovld __cnfn step(float edge, float3 x);
2549 float4 __ovld __cnfn step(float edge, float4 x);
2550 float8 __ovld __cnfn step(float edge, float8 x);
2551 float16 __ovld __cnfn step(float edge, float16 x);
2552-#ifdef cl_khr_fp64
2553+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2554 double __ovld __cnfn step(double edge, double x);
2555 double2 __ovld __cnfn step(double2 edge, double2 x);
2556 double3 __ovld __cnfn step(double3 edge, double3 x);
2557@@ -10344,7 +10357,7 @@ double3 __ovld __cnfn step(double edge, double3 x);
2558 double4 __ovld __cnfn step(double edge, double4 x);
2559 double8 __ovld __cnfn step(double edge, double8 x);
2560 double16 __ovld __cnfn step(double edge, double16 x);
2561-#endif //cl_khr_fp64
2562+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2563 #ifdef cl_khr_fp16
2564 half __ovld __cnfn step(half edge, half x);
2565 half2 __ovld __cnfn step(half2 edge, half2 x);
2566@@ -10383,7 +10396,7 @@ float3 __ovld __cnfn smoothstep(float edge0, float edge1, float3 x);
2567 float4 __ovld __cnfn smoothstep(float edge0, float edge1, float4 x);
2568 float8 __ovld __cnfn smoothstep(float edge0, float edge1, float8 x);
2569 float16 __ovld __cnfn smoothstep(float edge0, float edge1, float16 x);
2570-#ifdef cl_khr_fp64
2571+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2572 double __ovld __cnfn smoothstep(double edge0, double edge1, double x);
2573 double2 __ovld __cnfn smoothstep(double2 edge0, double2 edge1, double2 x);
2574 double3 __ovld __cnfn smoothstep(double3 edge0, double3 edge1, double3 x);
2575@@ -10395,7 +10408,7 @@ double3 __ovld __cnfn smoothstep(double edge0, double edge1, double3 x);
2576 double4 __ovld __cnfn smoothstep(double edge0, double edge1, double4 x);
2577 double8 __ovld __cnfn smoothstep(double edge0, double edge1, double8 x);
2578 double16 __ovld __cnfn smoothstep(double edge0, double edge1, double16 x);
2579-#endif //cl_khr_fp64
2580+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2581 #ifdef cl_khr_fp16
2582 half __ovld __cnfn smoothstep(half edge0, half edge1, half x);
2583 half2 __ovld __cnfn smoothstep(half2 edge0, half2 edge1, half2 x);
2584@@ -10420,14 +10433,14 @@ float3 __ovld __cnfn sign(float3 x);
2585 float4 __ovld __cnfn sign(float4 x);
2586 float8 __ovld __cnfn sign(float8 x);
2587 float16 __ovld __cnfn sign(float16 x);
2588-#ifdef cl_khr_fp64
2589+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2590 double __ovld __cnfn sign(double x);
2591 double2 __ovld __cnfn sign(double2 x);
2592 double3 __ovld __cnfn sign(double3 x);
2593 double4 __ovld __cnfn sign(double4 x);
2594 double8 __ovld __cnfn sign(double8 x);
2595 double16 __ovld __cnfn sign(double16 x);
2596-#endif //cl_khr_fp64
2597+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2598 #ifdef cl_khr_fp16
2599 half __ovld __cnfn sign(half x);
2600 half2 __ovld __cnfn sign(half2 x);
2601@@ -10445,10 +10458,10 @@ half16 __ovld __cnfn sign(half16 x);
2602 */
2603 float4 __ovld __cnfn cross(float4 p0, float4 p1);
2604 float3 __ovld __cnfn cross(float3 p0, float3 p1);
2605-#ifdef cl_khr_fp64
2606+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2607 double4 __ovld __cnfn cross(double4 p0, double4 p1);
2608 double3 __ovld __cnfn cross(double3 p0, double3 p1);
2609-#endif //cl_khr_fp64
2610+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2611 #ifdef cl_khr_fp16
2612 half4 __ovld __cnfn cross(half4 p0, half4 p1);
2613 half3 __ovld __cnfn cross(half3 p0, half3 p1);
2614@@ -10461,12 +10474,12 @@ float __ovld __cnfn dot(float p0, float p1);
2615 float __ovld __cnfn dot(float2 p0, float2 p1);
2616 float __ovld __cnfn dot(float3 p0, float3 p1);
2617 float __ovld __cnfn dot(float4 p0, float4 p1);
2618-#ifdef cl_khr_fp64
2619+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2620 double __ovld __cnfn dot(double p0, double p1);
2621 double __ovld __cnfn dot(double2 p0, double2 p1);
2622 double __ovld __cnfn dot(double3 p0, double3 p1);
2623 double __ovld __cnfn dot(double4 p0, double4 p1);
2624-#endif //cl_khr_fp64
2625+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2626 #ifdef cl_khr_fp16
2627 half __ovld __cnfn dot(half p0, half p1);
2628 half __ovld __cnfn dot(half2 p0, half2 p1);
2629@@ -10482,12 +10495,12 @@ float __ovld __cnfn distance(float p0, float p1);
2630 float __ovld __cnfn distance(float2 p0, float2 p1);
2631 float __ovld __cnfn distance(float3 p0, float3 p1);
2632 float __ovld __cnfn distance(float4 p0, float4 p1);
2633-#ifdef cl_khr_fp64
2634+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2635 double __ovld __cnfn distance(double p0, double p1);
2636 double __ovld __cnfn distance(double2 p0, double2 p1);
2637 double __ovld __cnfn distance(double3 p0, double3 p1);
2638 double __ovld __cnfn distance(double4 p0, double4 p1);
2639-#endif //cl_khr_fp64
2640+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2641 #ifdef cl_khr_fp16
2642 half __ovld __cnfn distance(half p0, half p1);
2643 half __ovld __cnfn distance(half2 p0, half2 p1);
2644@@ -10503,12 +10516,12 @@ float __ovld __cnfn length(float p);
2645 float __ovld __cnfn length(float2 p);
2646 float __ovld __cnfn length(float3 p);
2647 float __ovld __cnfn length(float4 p);
2648-#ifdef cl_khr_fp64
2649+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2650 double __ovld __cnfn length(double p);
2651 double __ovld __cnfn length(double2 p);
2652 double __ovld __cnfn length(double3 p);
2653 double __ovld __cnfn length(double4 p);
2654-#endif //cl_khr_fp64
2655+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2656 #ifdef cl_khr_fp16
2657 half __ovld __cnfn length(half p);
2658 half __ovld __cnfn length(half2 p);
2659@@ -10524,12 +10537,12 @@ float __ovld __cnfn normalize(float p);
2660 float2 __ovld __cnfn normalize(float2 p);
2661 float3 __ovld __cnfn normalize(float3 p);
2662 float4 __ovld __cnfn normalize(float4 p);
2663-#ifdef cl_khr_fp64
2664+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2665 double __ovld __cnfn normalize(double p);
2666 double2 __ovld __cnfn normalize(double2 p);
2667 double3 __ovld __cnfn normalize(double3 p);
2668 double4 __ovld __cnfn normalize(double4 p);
2669-#endif //cl_khr_fp64
2670+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2671 #ifdef cl_khr_fp16
2672 half __ovld __cnfn normalize(half p);
2673 half2 __ovld __cnfn normalize(half2 p);
2674@@ -10610,14 +10623,14 @@ int3 __ovld __cnfn isequal(float3 x, float3 y);
2675 int4 __ovld __cnfn isequal(float4 x, float4 y);
2676 int8 __ovld __cnfn isequal(float8 x, float8 y);
2677 int16 __ovld __cnfn isequal(float16 x, float16 y);
2678-#ifdef cl_khr_fp64
2679+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2680 int __ovld __cnfn isequal(double x, double y);
2681 long2 __ovld __cnfn isequal(double2 x, double2 y);
2682 long3 __ovld __cnfn isequal(double3 x, double3 y);
2683 long4 __ovld __cnfn isequal(double4 x, double4 y);
2684 long8 __ovld __cnfn isequal(double8 x, double8 y);
2685 long16 __ovld __cnfn isequal(double16 x, double16 y);
2686-#endif //cl_khr_fp64
2687+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2688 #ifdef cl_khr_fp16
2689 int __ovld __cnfn isequal(half x, half y);
2690 short2 __ovld __cnfn isequal(half2 x, half2 y);
2691@@ -10636,14 +10649,14 @@ int3 __ovld __cnfn isnotequal(float3 x, float3 y);
2692 int4 __ovld __cnfn isnotequal(float4 x, float4 y);
2693 int8 __ovld __cnfn isnotequal(float8 x, float8 y);
2694 int16 __ovld __cnfn isnotequal(float16 x, float16 y);
2695-#ifdef cl_khr_fp64
2696+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2697 int __ovld __cnfn isnotequal(double x, double y);
2698 long2 __ovld __cnfn isnotequal(double2 x, double2 y);
2699 long3 __ovld __cnfn isnotequal(double3 x, double3 y);
2700 long4 __ovld __cnfn isnotequal(double4 x, double4 y);
2701 long8 __ovld __cnfn isnotequal(double8 x, double8 y);
2702 long16 __ovld __cnfn isnotequal(double16 x, double16 y);
2703-#endif //cl_khr_fp64
2704+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2705 #ifdef cl_khr_fp16
2706 int __ovld __cnfn isnotequal(half x, half y);
2707 short2 __ovld __cnfn isnotequal(half2 x, half2 y);
2708@@ -10662,14 +10675,14 @@ int3 __ovld __cnfn isgreater(float3 x, float3 y);
2709 int4 __ovld __cnfn isgreater(float4 x, float4 y);
2710 int8 __ovld __cnfn isgreater(float8 x, float8 y);
2711 int16 __ovld __cnfn isgreater(float16 x, float16 y);
2712-#ifdef cl_khr_fp64
2713+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2714 int __ovld __cnfn isgreater(double x, double y);
2715 long2 __ovld __cnfn isgreater(double2 x, double2 y);
2716 long3 __ovld __cnfn isgreater(double3 x, double3 y);
2717 long4 __ovld __cnfn isgreater(double4 x, double4 y);
2718 long8 __ovld __cnfn isgreater(double8 x, double8 y);
2719 long16 __ovld __cnfn isgreater(double16 x, double16 y);
2720-#endif //cl_khr_fp64
2721+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2722 #ifdef cl_khr_fp16
2723 int __ovld __cnfn isgreater(half x, half y);
2724 short2 __ovld __cnfn isgreater(half2 x, half2 y);
2725@@ -10688,14 +10701,14 @@ int3 __ovld __cnfn isgreaterequal(float3 x, float3 y);
2726 int4 __ovld __cnfn isgreaterequal(float4 x, float4 y);
2727 int8 __ovld __cnfn isgreaterequal(float8 x, float8 y);
2728 int16 __ovld __cnfn isgreaterequal(float16 x, float16 y);
2729-#ifdef cl_khr_fp64
2730+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2731 int __ovld __cnfn isgreaterequal(double x, double y);
2732 long2 __ovld __cnfn isgreaterequal(double2 x, double2 y);
2733 long3 __ovld __cnfn isgreaterequal(double3 x, double3 y);
2734 long4 __ovld __cnfn isgreaterequal(double4 x, double4 y);
2735 long8 __ovld __cnfn isgreaterequal(double8 x, double8 y);
2736 long16 __ovld __cnfn isgreaterequal(double16 x, double16 y);
2737-#endif //cl_khr_fp64
2738+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2739 #ifdef cl_khr_fp16
2740 int __ovld __cnfn isgreaterequal(half x, half y);
2741 short2 __ovld __cnfn isgreaterequal(half2 x, half2 y);
2742@@ -10714,14 +10727,14 @@ int3 __ovld __cnfn isless(float3 x, float3 y);
2743 int4 __ovld __cnfn isless(float4 x, float4 y);
2744 int8 __ovld __cnfn isless(float8 x, float8 y);
2745 int16 __ovld __cnfn isless(float16 x, float16 y);
2746-#ifdef cl_khr_fp64
2747+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2748 int __ovld __cnfn isless(double x, double y);
2749 long2 __ovld __cnfn isless(double2 x, double2 y);
2750 long3 __ovld __cnfn isless(double3 x, double3 y);
2751 long4 __ovld __cnfn isless(double4 x, double4 y);
2752 long8 __ovld __cnfn isless(double8 x, double8 y);
2753 long16 __ovld __cnfn isless(double16 x, double16 y);
2754-#endif //cl_khr_fp64
2755+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2756 #ifdef cl_khr_fp16
2757 int __ovld __cnfn isless(half x, half y);
2758 short2 __ovld __cnfn isless(half2 x, half2 y);
2759@@ -10740,14 +10753,14 @@ int3 __ovld __cnfn islessequal(float3 x, float3 y);
2760 int4 __ovld __cnfn islessequal(float4 x, float4 y);
2761 int8 __ovld __cnfn islessequal(float8 x, float8 y);
2762 int16 __ovld __cnfn islessequal(float16 x, float16 y);
2763-#ifdef cl_khr_fp64
2764+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2765 int __ovld __cnfn islessequal(double x, double y);
2766 long2 __ovld __cnfn islessequal(double2 x, double2 y);
2767 long3 __ovld __cnfn islessequal(double3 x, double3 y);
2768 long4 __ovld __cnfn islessequal(double4 x, double4 y);
2769 long8 __ovld __cnfn islessequal(double8 x, double8 y);
2770 long16 __ovld __cnfn islessequal(double16 x, double16 y);
2771-#endif //cl_khr_fp64
2772+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2773 #ifdef cl_khr_fp16
2774 int __ovld __cnfn islessequal(half x, half y);
2775 short2 __ovld __cnfn islessequal(half2 x, half2 y);
2776@@ -10767,14 +10780,14 @@ int3 __ovld __cnfn islessgreater(float3 x, float3 y);
2777 int4 __ovld __cnfn islessgreater(float4 x, float4 y);
2778 int8 __ovld __cnfn islessgreater(float8 x, float8 y);
2779 int16 __ovld __cnfn islessgreater(float16 x, float16 y);
2780-#ifdef cl_khr_fp64
2781+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2782 int __ovld __cnfn islessgreater(double x, double y);
2783 long2 __ovld __cnfn islessgreater(double2 x, double2 y);
2784 long3 __ovld __cnfn islessgreater(double3 x, double3 y);
2785 long4 __ovld __cnfn islessgreater(double4 x, double4 y);
2786 long8 __ovld __cnfn islessgreater(double8 x, double8 y);
2787 long16 __ovld __cnfn islessgreater(double16 x, double16 y);
2788-#endif //cl_khr_fp64
2789+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2790 #ifdef cl_khr_fp16
2791 int __ovld __cnfn islessgreater(half x, half y);
2792 short2 __ovld __cnfn islessgreater(half2 x, half2 y);
2793@@ -10793,14 +10806,14 @@ int3 __ovld __cnfn isfinite(float3);
2794 int4 __ovld __cnfn isfinite(float4);
2795 int8 __ovld __cnfn isfinite(float8);
2796 int16 __ovld __cnfn isfinite(float16);
2797-#ifdef cl_khr_fp64
2798+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2799 int __ovld __cnfn isfinite(double);
2800 long2 __ovld __cnfn isfinite(double2);
2801 long3 __ovld __cnfn isfinite(double3);
2802 long4 __ovld __cnfn isfinite(double4);
2803 long8 __ovld __cnfn isfinite(double8);
2804 long16 __ovld __cnfn isfinite(double16);
2805-#endif //cl_khr_fp64
2806+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2807 #ifdef cl_khr_fp16
2808 int __ovld __cnfn isfinite(half);
2809 short2 __ovld __cnfn isfinite(half2);
2810@@ -10819,14 +10832,14 @@ int3 __ovld __cnfn isinf(float3);
2811 int4 __ovld __cnfn isinf(float4);
2812 int8 __ovld __cnfn isinf(float8);
2813 int16 __ovld __cnfn isinf(float16);
2814-#ifdef cl_khr_fp64
2815+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2816 int __ovld __cnfn isinf(double);
2817 long2 __ovld __cnfn isinf(double2);
2818 long3 __ovld __cnfn isinf(double3);
2819 long4 __ovld __cnfn isinf(double4);
2820 long8 __ovld __cnfn isinf(double8);
2821 long16 __ovld __cnfn isinf(double16);
2822-#endif //cl_khr_fp64
2823+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2824 #ifdef cl_khr_fp16
2825 int __ovld __cnfn isinf(half);
2826 short2 __ovld __cnfn isinf(half2);
2827@@ -10845,14 +10858,14 @@ int3 __ovld __cnfn isnan(float3);
2828 int4 __ovld __cnfn isnan(float4);
2829 int8 __ovld __cnfn isnan(float8);
2830 int16 __ovld __cnfn isnan(float16);
2831-#ifdef cl_khr_fp64
2832+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2833 int __ovld __cnfn isnan(double);
2834 long2 __ovld __cnfn isnan(double2);
2835 long3 __ovld __cnfn isnan(double3);
2836 long4 __ovld __cnfn isnan(double4);
2837 long8 __ovld __cnfn isnan(double8);
2838 long16 __ovld __cnfn isnan(double16);
2839-#endif //cl_khr_fp64
2840+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2841 #ifdef cl_khr_fp16
2842 int __ovld __cnfn isnan(half);
2843 short2 __ovld __cnfn isnan(half2);
2844@@ -10871,14 +10884,14 @@ int3 __ovld __cnfn isnormal(float3);
2845 int4 __ovld __cnfn isnormal(float4);
2846 int8 __ovld __cnfn isnormal(float8);
2847 int16 __ovld __cnfn isnormal(float16);
2848-#ifdef cl_khr_fp64
2849+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2850 int __ovld __cnfn isnormal(double);
2851 long2 __ovld __cnfn isnormal(double2);
2852 long3 __ovld __cnfn isnormal(double3);
2853 long4 __ovld __cnfn isnormal(double4);
2854 long8 __ovld __cnfn isnormal(double8);
2855 long16 __ovld __cnfn isnormal(double16);
2856-#endif //cl_khr_fp64
2857+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2858 #ifdef cl_khr_fp16
2859 int __ovld __cnfn isnormal(half);
2860 short2 __ovld __cnfn isnormal(half2);
2861@@ -10899,14 +10912,14 @@ int3 __ovld __cnfn isordered(float3 x, float3 y);
2862 int4 __ovld __cnfn isordered(float4 x, float4 y);
2863 int8 __ovld __cnfn isordered(float8 x, float8 y);
2864 int16 __ovld __cnfn isordered(float16 x, float16 y);
2865-#ifdef cl_khr_fp64
2866+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2867 int __ovld __cnfn isordered(double x, double y);
2868 long2 __ovld __cnfn isordered(double2 x, double2 y);
2869 long3 __ovld __cnfn isordered(double3 x, double3 y);
2870 long4 __ovld __cnfn isordered(double4 x, double4 y);
2871 long8 __ovld __cnfn isordered(double8 x, double8 y);
2872 long16 __ovld __cnfn isordered(double16 x, double16 y);
2873-#endif //cl_khr_fp64
2874+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2875 #ifdef cl_khr_fp16
2876 int __ovld __cnfn isordered(half x, half y);
2877 short2 __ovld __cnfn isordered(half2 x, half2 y);
2878@@ -10927,14 +10940,14 @@ int3 __ovld __cnfn isunordered(float3 x, float3 y);
2879 int4 __ovld __cnfn isunordered(float4 x, float4 y);
2880 int8 __ovld __cnfn isunordered(float8 x, float8 y);
2881 int16 __ovld __cnfn isunordered(float16 x, float16 y);
2882-#ifdef cl_khr_fp64
2883+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2884 int __ovld __cnfn isunordered(double x, double y);
2885 long2 __ovld __cnfn isunordered(double2 x, double2 y);
2886 long3 __ovld __cnfn isunordered(double3 x, double3 y);
2887 long4 __ovld __cnfn isunordered(double4 x, double4 y);
2888 long8 __ovld __cnfn isunordered(double8 x, double8 y);
2889 long16 __ovld __cnfn isunordered(double16 x, double16 y);
2890-#endif //cl_khr_fp64
2891+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2892 #ifdef cl_khr_fp16
2893 int __ovld __cnfn isunordered(half x, half y);
2894 short2 __ovld __cnfn isunordered(half2 x, half2 y);
2895@@ -10957,14 +10970,14 @@ int3 __ovld __cnfn signbit(float3);
2896 int4 __ovld __cnfn signbit(float4);
2897 int8 __ovld __cnfn signbit(float8);
2898 int16 __ovld __cnfn signbit(float16);
2899-#ifdef cl_khr_fp64
2900+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2901 int __ovld __cnfn signbit(double);
2902 long2 __ovld __cnfn signbit(double2);
2903 long3 __ovld __cnfn signbit(double3);
2904 long4 __ovld __cnfn signbit(double4);
2905 long8 __ovld __cnfn signbit(double8);
2906 long16 __ovld __cnfn signbit(double16);
2907-#endif //cl_khr_fp64
2908+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2909 #ifdef cl_khr_fp16
2910 int __ovld __cnfn signbit(half);
2911 short2 __ovld __cnfn signbit(half2);
2912@@ -11091,14 +11104,14 @@ float3 __ovld __cnfn bitselect(float3 a, float3 b, float3 c);
2913 float4 __ovld __cnfn bitselect(float4 a, float4 b, float4 c);
2914 float8 __ovld __cnfn bitselect(float8 a, float8 b, float8 c);
2915 float16 __ovld __cnfn bitselect(float16 a, float16 b, float16 c);
2916-#ifdef cl_khr_fp64
2917+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2918 double __ovld __cnfn bitselect(double a, double b, double c);
2919 double2 __ovld __cnfn bitselect(double2 a, double2 b, double2 c);
2920 double3 __ovld __cnfn bitselect(double3 a, double3 b, double3 c);
2921 double4 __ovld __cnfn bitselect(double4 a, double4 b, double4 c);
2922 double8 __ovld __cnfn bitselect(double8 a, double8 b, double8 c);
2923 double16 __ovld __cnfn bitselect(double16 a, double16 b, double16 c);
2924-#endif //cl_khr_fp64
2925+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2926 #ifdef cl_khr_fp16
2927 half __ovld __cnfn bitselect(half a, half b, half c);
2928 half2 __ovld __cnfn bitselect(half2 a, half2 b, half2 c);
2929@@ -11231,7 +11244,7 @@ ulong8 __ovld __cnfn select(ulong8 a, ulong8 b, ulong8 c);
2930 long16 __ovld __cnfn select(long16 a, long16 b, ulong16 c);
2931 ulong16 __ovld __cnfn select(ulong16 a, ulong16 b, ulong16 c);
2932
2933-#ifdef cl_khr_fp64
2934+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2935 double __ovld __cnfn select(double a, double b, long c);
2936 double2 __ovld __cnfn select(double2 a, double2 b, long2 c);
2937 double3 __ovld __cnfn select(double3 a, double3 b, long3 c);
2938@@ -11244,7 +11257,7 @@ double3 __ovld __cnfn select(double3 a, double3 b, ulong3 c);
2939 double4 __ovld __cnfn select(double4 a, double4 b, ulong4 c);
2940 double8 __ovld __cnfn select(double8 a, double8 b, ulong8 c);
2941 double16 __ovld __cnfn select(double16 a, double16 b, ulong16 c);
2942-#endif //cl_khr_fp64
2943+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2944 #ifdef cl_khr_fp16
2945 half __ovld __cnfn select(half a, half b, short c);
2946 half2 __ovld __cnfn select(half2 a, half2 b, short2 c);
2947@@ -11323,13 +11336,13 @@ uint16 __ovld vload16(size_t offset, const __constant uint *p);
2948 long16 __ovld vload16(size_t offset, const __constant long *p);
2949 ulong16 __ovld vload16(size_t offset, const __constant ulong *p);
2950 float16 __ovld vload16(size_t offset, const __constant float *p);
2951-#ifdef cl_khr_fp64
2952+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2953 double2 __ovld vload2(size_t offset, const __constant double *p);
2954 double3 __ovld vload3(size_t offset, const __constant double *p);
2955 double4 __ovld vload4(size_t offset, const __constant double *p);
2956 double8 __ovld vload8(size_t offset, const __constant double *p);
2957 double16 __ovld vload16(size_t offset, const __constant double *p);
2958-#endif //cl_khr_fp64
2959+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2960
2961 #ifdef cl_khr_fp16
2962 half __ovld vload(size_t offset, const __constant half *p);
2963@@ -11340,7 +11353,7 @@ half8 __ovld vload8(size_t offset, const __constant half *p);
2964 half16 __ovld vload16(size_t offset, const __constant half *p);
2965 #endif //cl_khr_fp16
2966
2967-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
2968+#ifdef __opencl_c_generic_address_space
2969 char2 __ovld vload2(size_t offset, const char *p);
2970 uchar2 __ovld vload2(size_t offset, const uchar *p);
2971 short2 __ovld vload2(size_t offset, const short *p);
2972@@ -11387,13 +11400,13 @@ long16 __ovld vload16(size_t offset, const long *p);
2973 ulong16 __ovld vload16(size_t offset, const ulong *p);
2974 float16 __ovld vload16(size_t offset, const float *p);
2975
2976-#ifdef cl_khr_fp64
2977+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2978 double2 __ovld vload2(size_t offset, const double *p);
2979 double3 __ovld vload3(size_t offset, const double *p);
2980 double4 __ovld vload4(size_t offset, const double *p);
2981 double8 __ovld vload8(size_t offset, const double *p);
2982 double16 __ovld vload16(size_t offset, const double *p);
2983-#endif //cl_khr_fp64
2984+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2985
2986 #ifdef cl_khr_fp16
2987 half __ovld vload(size_t offset, const half *p);
2988@@ -11403,7 +11416,7 @@ half4 __ovld vload4(size_t offset, const half *p);
2989 half8 __ovld vload8(size_t offset, const half *p);
2990 half16 __ovld vload16(size_t offset, const half *p);
2991 #endif //cl_khr_fp16
2992-#else
2993+#endif //__opencl_c_generic_address_space
2994 char2 __ovld vload2(size_t offset, const __global char *p);
2995 uchar2 __ovld vload2(size_t offset, const __global uchar *p);
2996 short2 __ovld vload2(size_t offset, const __global short *p);
2997@@ -11540,7 +11553,7 @@ long16 __ovld vload16(size_t offset, const __private long *p);
2998 ulong16 __ovld vload16(size_t offset, const __private ulong *p);
2999 float16 __ovld vload16(size_t offset, const __private float *p);
3000
3001-#ifdef cl_khr_fp64
3002+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3003 double2 __ovld vload2(size_t offset, const __global double *p);
3004 double3 __ovld vload3(size_t offset, const __global double *p);
3005 double4 __ovld vload4(size_t offset, const __global double *p);
3006@@ -11556,7 +11569,7 @@ double3 __ovld vload3(size_t offset, const __private double *p);
3007 double4 __ovld vload4(size_t offset, const __private double *p);
3008 double8 __ovld vload8(size_t offset, const __private double *p);
3009 double16 __ovld vload16(size_t offset, const __private double *p);
3010-#endif //cl_khr_fp64
3011+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3012
3013 #ifdef cl_khr_fp16
3014 half __ovld vload(size_t offset, const __global half *p);
3015@@ -11578,9 +11591,8 @@ half4 __ovld vload4(size_t offset, const __private half *p);
3016 half8 __ovld vload8(size_t offset, const __private half *p);
3017 half16 __ovld vload16(size_t offset, const __private half *p);
3018 #endif //cl_khr_fp16
3019-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3020
3021-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3022+#ifdef __opencl_c_generic_address_space
3023 void __ovld vstore2(char2 data, size_t offset, char *p);
3024 void __ovld vstore2(uchar2 data, size_t offset, uchar *p);
3025 void __ovld vstore2(short2 data, size_t offset, short *p);
3026@@ -11626,13 +11638,13 @@ void __ovld vstore16(uint16 data, size_t offset, uint *p);
3027 void __ovld vstore16(long16 data, size_t offset, long *p);
3028 void __ovld vstore16(ulong16 data, size_t offset, ulong *p);
3029 void __ovld vstore16(float16 data, size_t offset, float *p);
3030-#ifdef cl_khr_fp64
3031+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3032 void __ovld vstore2(double2 data, size_t offset, double *p);
3033 void __ovld vstore3(double3 data, size_t offset, double *p);
3034 void __ovld vstore4(double4 data, size_t offset, double *p);
3035 void __ovld vstore8(double8 data, size_t offset, double *p);
3036 void __ovld vstore16(double16 data, size_t offset, double *p);
3037-#endif //cl_khr_fp64
3038+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3039 #ifdef cl_khr_fp16
3040 void __ovld vstore(half data, size_t offset, half *p);
3041 void __ovld vstore2(half2 data, size_t offset, half *p);
3042@@ -11641,7 +11653,7 @@ void __ovld vstore4(half4 data, size_t offset, half *p);
3043 void __ovld vstore8(half8 data, size_t offset, half *p);
3044 void __ovld vstore16(half16 data, size_t offset, half *p);
3045 #endif //cl_khr_fp16
3046-#else
3047+#endif //__opencl_c_generic_address_space
3048 void __ovld vstore2(char2 data, size_t offset, __global char *p);
3049 void __ovld vstore2(uchar2 data, size_t offset, __global uchar *p);
3050 void __ovld vstore2(short2 data, size_t offset, __global short *p);
3051@@ -11777,7 +11789,7 @@ void __ovld vstore16(uint16 data, size_t offset, __private uint *p);
3052 void __ovld vstore16(long16 data, size_t offset, __private long *p);
3053 void __ovld vstore16(ulong16 data, size_t offset, __private ulong *p);
3054 void __ovld vstore16(float16 data, size_t offset, __private float *p);
3055-#ifdef cl_khr_fp64
3056+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3057 void __ovld vstore2(double2 data, size_t offset, __global double *p);
3058 void __ovld vstore3(double3 data, size_t offset, __global double *p);
3059 void __ovld vstore4(double4 data, size_t offset, __global double *p);
3060@@ -11793,7 +11805,7 @@ void __ovld vstore3(double3 data, size_t offset, __private double *p);
3061 void __ovld vstore4(double4 data, size_t offset, __private double *p);
3062 void __ovld vstore8(double8 data, size_t offset, __private double *p);
3063 void __ovld vstore16(double16 data, size_t offset, __private double *p);
3064-#endif //cl_khr_fp64
3065+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3066 #ifdef cl_khr_fp16
3067 void __ovld vstore(half data, size_t offset, __global half *p);
3068 void __ovld vstore2(half2 data, size_t offset, __global half *p);
3069@@ -11814,7 +11826,6 @@ void __ovld vstore4(half4 data, size_t offset, __private half *p);
3070 void __ovld vstore8(half8 data, size_t offset, __private half *p);
3071 void __ovld vstore16(half16 data, size_t offset, __private half *p);
3072 #endif //cl_khr_fp16
3073-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3074
3075 /**
3076 * Read sizeof (half) bytes of data from address
3077@@ -11825,13 +11836,12 @@ void __ovld vstore16(half16 data, size_t offset, __private half *p);
3078 * must be 16-bit aligned.
3079 */
3080 float __ovld vload_half(size_t offset, const __constant half *p);
3081-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3082+#ifdef __opencl_c_generic_address_space
3083 float __ovld vload_half(size_t offset, const half *p);
3084-#else
3085+#endif //__opencl_c_generic_address_space
3086 float __ovld vload_half(size_t offset, const __global half *p);
3087 float __ovld vload_half(size_t offset, const __local half *p);
3088 float __ovld vload_half(size_t offset, const __private half *p);
3089-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3090
3091 /**
3092 * Read sizeof (halfn) bytes of data from address
3093@@ -11846,13 +11856,13 @@ float3 __ovld vload_half3(size_t offset, const __constant half *p);
3094 float4 __ovld vload_half4(size_t offset, const __constant half *p);
3095 float8 __ovld vload_half8(size_t offset, const __constant half *p);
3096 float16 __ovld vload_half16(size_t offset, const __constant half *p);
3097-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3098+#ifdef __opencl_c_generic_address_space
3099 float2 __ovld vload_half2(size_t offset, const half *p);
3100 float3 __ovld vload_half3(size_t offset, const half *p);
3101 float4 __ovld vload_half4(size_t offset, const half *p);
3102 float8 __ovld vload_half8(size_t offset, const half *p);
3103 float16 __ovld vload_half16(size_t offset, const half *p);
3104-#else
3105+#endif //__opencl_c_generic_address_space
3106 float2 __ovld vload_half2(size_t offset, const __global half *p);
3107 float3 __ovld vload_half3(size_t offset, const __global half *p);
3108 float4 __ovld vload_half4(size_t offset, const __global half *p);
3109@@ -11868,7 +11878,6 @@ float3 __ovld vload_half3(size_t offset, const __private half *p);
3110 float4 __ovld vload_half4(size_t offset, const __private half *p);
3111 float8 __ovld vload_half8(size_t offset, const __private half *p);
3112 float16 __ovld vload_half16(size_t offset, const __private half *p);
3113-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3114
3115 /**
3116 * The float value given by data is first
3117@@ -11881,20 +11890,20 @@ float16 __ovld vload_half16(size_t offset, const __private half *p);
3118 * The default current rounding mode is round to
3119 * nearest even.
3120 */
3121-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3122+#ifdef __opencl_c_generic_address_space
3123 void __ovld vstore_half(float data, size_t offset, half *p);
3124 void __ovld vstore_half_rte(float data, size_t offset, half *p);
3125 void __ovld vstore_half_rtz(float data, size_t offset, half *p);
3126 void __ovld vstore_half_rtp(float data, size_t offset, half *p);
3127 void __ovld vstore_half_rtn(float data, size_t offset, half *p);
3128-#ifdef cl_khr_fp64
3129+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3130 void __ovld vstore_half(double data, size_t offset, half *p);
3131 void __ovld vstore_half_rte(double data, size_t offset, half *p);
3132 void __ovld vstore_half_rtz(double data, size_t offset, half *p);
3133 void __ovld vstore_half_rtp(double data, size_t offset, half *p);
3134 void __ovld vstore_half_rtn(double data, size_t offset, half *p);
3135-#endif //cl_khr_fp64
3136-#else
3137+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3138+#endif //__opencl_c_generic_address_space
3139 void __ovld vstore_half(float data, size_t offset, __global half *p);
3140 void __ovld vstore_half_rte(float data, size_t offset, __global half *p);
3141 void __ovld vstore_half_rtz(float data, size_t offset, __global half *p);
3142@@ -11910,7 +11919,7 @@ void __ovld vstore_half_rte(float data, size_t offset, __private half *p);
3143 void __ovld vstore_half_rtz(float data, size_t offset, __private half *p);
3144 void __ovld vstore_half_rtp(float data, size_t offset, __private half *p);
3145 void __ovld vstore_half_rtn(float data, size_t offset, __private half *p);
3146-#ifdef cl_khr_fp64
3147+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3148 void __ovld vstore_half(double data, size_t offset, __global half *p);
3149 void __ovld vstore_half_rte(double data, size_t offset, __global half *p);
3150 void __ovld vstore_half_rtz(double data, size_t offset, __global half *p);
3151@@ -11926,8 +11935,7 @@ void __ovld vstore_half_rte(double data, size_t offset, __private half *p);
3152 void __ovld vstore_half_rtz(double data, size_t offset, __private half *p);
3153 void __ovld vstore_half_rtp(double data, size_t offset, __private half *p);
3154 void __ovld vstore_half_rtn(double data, size_t offset, __private half *p);
3155-#endif //cl_khr_fp64
3156-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3157+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3158
3159 /**
3160 * The floatn value given by data is converted to
3161@@ -11940,7 +11948,7 @@ void __ovld vstore_half_rtn(double data, size_t offset, __private half *p);
3162 * The default current rounding mode is round to
3163 * nearest even.
3164 */
3165-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3166+#ifdef __opencl_c_generic_address_space
3167 void __ovld vstore_half2(float2 data, size_t offset, half *p);
3168 void __ovld vstore_half3(float3 data, size_t offset, half *p);
3169 void __ovld vstore_half4(float4 data, size_t offset, half *p);
3170@@ -11966,7 +11974,7 @@ void __ovld vstore_half3_rtn(float3 data, size_t offset, half *p);
3171 void __ovld vstore_half4_rtn(float4 data, size_t offset, half *p);
3172 void __ovld vstore_half8_rtn(float8 data, size_t offset, half *p);
3173 void __ovld vstore_half16_rtn(float16 data, size_t offset, half *p);
3174-#ifdef cl_khr_fp64
3175+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3176 void __ovld vstore_half2(double2 data, size_t offset, half *p);
3177 void __ovld vstore_half3(double3 data, size_t offset, half *p);
3178 void __ovld vstore_half4(double4 data, size_t offset, half *p);
3179@@ -11992,8 +12000,8 @@ void __ovld vstore_half3_rtn(double3 data, size_t offset, half *p);
3180 void __ovld vstore_half4_rtn(double4 data, size_t offset, half *p);
3181 void __ovld vstore_half8_rtn(double8 data, size_t offset, half *p);
3182 void __ovld vstore_half16_rtn(double16 data, size_t offset, half *p);
3183-#endif //cl_khr_fp64
3184-#else
3185+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3186+#endif //__opencl_c_generic_address_space
3187 void __ovld vstore_half2(float2 data, size_t offset, __global half *p);
3188 void __ovld vstore_half3(float3 data, size_t offset, __global half *p);
3189 void __ovld vstore_half4(float4 data, size_t offset, __global half *p);
3190@@ -12069,7 +12077,7 @@ void __ovld vstore_half3_rtn(float3 data, size_t offset, __private half *p);
3191 void __ovld vstore_half4_rtn(float4 data, size_t offset, __private half *p);
3192 void __ovld vstore_half8_rtn(float8 data, size_t offset, __private half *p);
3193 void __ovld vstore_half16_rtn(float16 data, size_t offset, __private half *p);
3194-#ifdef cl_khr_fp64
3195+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3196 void __ovld vstore_half2(double2 data, size_t offset, __global half *p);
3197 void __ovld vstore_half3(double3 data, size_t offset, __global half *p);
3198 void __ovld vstore_half4(double4 data, size_t offset, __global half *p);
3199@@ -12145,8 +12153,7 @@ void __ovld vstore_half3_rtn(double3 data, size_t offset, __private half *p);
3200 void __ovld vstore_half4_rtn(double4 data, size_t offset, __private half *p);
3201 void __ovld vstore_half8_rtn(double8 data, size_t offset, __private half *p);
3202 void __ovld vstore_half16_rtn(double16 data, size_t offset, __private half *p);
3203-#endif //cl_khr_fp64
3204-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3205+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3206
3207 /**
3208 * For n = 1, 2, 4, 8 and 16 read sizeof (halfn)
3209@@ -12167,14 +12174,14 @@ float3 __ovld vloada_half3(size_t offset, const __constant half *p);
3210 float4 __ovld vloada_half4(size_t offset, const __constant half *p);
3211 float8 __ovld vloada_half8(size_t offset, const __constant half *p);
3212 float16 __ovld vloada_half16(size_t offset, const __constant half *p);
3213-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3214+#ifdef __opencl_c_generic_address_space
3215 float __ovld vloada_half(size_t offset, const half *p);
3216 float2 __ovld vloada_half2(size_t offset, const half *p);
3217 float3 __ovld vloada_half3(size_t offset, const half *p);
3218 float4 __ovld vloada_half4(size_t offset, const half *p);
3219 float8 __ovld vloada_half8(size_t offset, const half *p);
3220 float16 __ovld vloada_half16(size_t offset, const half *p);
3221-#else
3222+#endif //__opencl_c_generic_address_space
3223 float __ovld vloada_half(size_t offset, const __global half *p);
3224 float2 __ovld vloada_half2(size_t offset, const __global half *p);
3225 float3 __ovld vloada_half3(size_t offset, const __global half *p);
3226@@ -12193,7 +12200,6 @@ float3 __ovld vloada_half3(size_t offset, const __private half *p);
3227 float4 __ovld vloada_half4(size_t offset, const __private half *p);
3228 float8 __ovld vloada_half8(size_t offset, const __private half *p);
3229 float16 __ovld vloada_half16(size_t offset, const __private half *p);
3230-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3231
3232 /**
3233 * The floatn value given by data is converted to
3234@@ -12211,7 +12217,7 @@ float16 __ovld vloada_half16(size_t offset, const __private half *p);
3235 * mode. The default current rounding mode is
3236 * round to nearest even.
3237 */
3238-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3239+#ifdef __opencl_c_generic_address_space
3240 void __ovld vstorea_half(float data, size_t offset, half *p);
3241 void __ovld vstorea_half2(float2 data, size_t offset, half *p);
3242 void __ovld vstorea_half3(float3 data, size_t offset, half *p);
3243@@ -12247,7 +12253,7 @@ void __ovld vstorea_half4_rtn(float4 data, size_t offset, half *p);
3244 void __ovld vstorea_half8_rtn(float8 data, size_t offset, half *p);
3245 void __ovld vstorea_half16_rtn(float16 data, size_t offset, half *p);
3246
3247-#ifdef cl_khr_fp64
3248+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3249 void __ovld vstorea_half(double data, size_t offset, half *p);
3250 void __ovld vstorea_half2(double2 data, size_t offset, half *p);
3251 void __ovld vstorea_half3(double3 data, size_t offset, half *p);
3252@@ -12282,9 +12288,9 @@ void __ovld vstorea_half3_rtn(double3 data, size_t offset, half *p);
3253 void __ovld vstorea_half4_rtn(double4 data, size_t offset, half *p);
3254 void __ovld vstorea_half8_rtn(double8 data, size_t offset, half *p);
3255 void __ovld vstorea_half16_rtn(double16 data, size_t offset, half *p);
3256-#endif //cl_khr_fp64
3257+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3258+#endif //__opencl_c_generic_address_space
3259
3260-#else
3261 void __ovld vstorea_half(float data, size_t offset, __global half *p);
3262 void __ovld vstorea_half2(float2 data, size_t offset, __global half *p);
3263 void __ovld vstorea_half3(float3 data, size_t offset, __global half *p);
3264@@ -12390,7 +12396,7 @@ void __ovld vstorea_half4_rtn(float4 data, size_t offset, __private half *p);
3265 void __ovld vstorea_half8_rtn(float8 data, size_t offset, __private half *p);
3266 void __ovld vstorea_half16_rtn(float16 data, size_t offset, __private half *p);
3267
3268-#ifdef cl_khr_fp64
3269+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3270 void __ovld vstorea_half(double data, size_t offset, __global half *p);
3271 void __ovld vstorea_half2(double2 data, size_t offset, __global half *p);
3272 void __ovld vstorea_half3(double3 data, size_t offset, __global half *p);
3273@@ -12495,8 +12501,7 @@ void __ovld vstorea_half3_rtn(double3 data,size_t offset, __private half *p);
3274 void __ovld vstorea_half4_rtn(double4 data,size_t offset, __private half *p);
3275 void __ovld vstorea_half8_rtn(double8 data,size_t offset, __private half *p);
3276 void __ovld vstorea_half16_rtn(double16 data,size_t offset, __private half *p);
3277-#endif //cl_khr_fp64
3278-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3279+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3280
3281 // OpenCL v1.1 s6.11.8, v1.2 s6.12.8, v2.0 s6.13.8 - Synchronization Functions
3282
3283@@ -12580,7 +12585,7 @@ void __ovld write_mem_fence(cl_mem_fence_flags flags);
3284
3285 // OpenCL v2.0 s6.13.9 - Address Space Qualifier Functions
3286
3287-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3288+#ifdef __opencl_c_generic_address_space
3289 cl_mem_fence_flags __ovld get_fence(const void *ptr);
3290 cl_mem_fence_flags __ovld get_fence(void *ptr);
3291
3292@@ -12591,7 +12596,7 @@ cl_mem_fence_flags __ovld get_fence(void *ptr);
3293 * where gentype is builtin type or user defined type.
3294 */
3295
3296-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3297+#endif //__opencl_c_generic_address_space
3298
3299 // OpenCL v1.1 s6.11.10, v1.2 s6.12.10, v2.0 s6.13.10 - Async Copies from Global to Local Memory, Local to Global Memory, and Prefetch
3300
3301@@ -12730,7 +12735,7 @@ event_t __ovld async_work_group_copy(__global uint16 *dst, const __local uint16
3302 event_t __ovld async_work_group_copy(__global long16 *dst, const __local long16 *src, size_t num_elements, event_t event);
3303 event_t __ovld async_work_group_copy(__global ulong16 *dst, const __local ulong16 *src, size_t num_elements, event_t event);
3304 event_t __ovld async_work_group_copy(__global float16 *dst, const __local float16 *src, size_t num_elements, event_t event);
3305-#ifdef cl_khr_fp64
3306+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3307 event_t __ovld async_work_group_copy(__local double *dst, const __global double *src, size_t num_elements, event_t event);
3308 event_t __ovld async_work_group_copy(__local double2 *dst, const __global double2 *src, size_t num_elements, event_t event);
3309 event_t __ovld async_work_group_copy(__local double3 *dst, const __global double3 *src, size_t num_elements, event_t event);
3310@@ -12743,7 +12748,7 @@ event_t __ovld async_work_group_copy(__global double3 *dst, const __local double
3311 event_t __ovld async_work_group_copy(__global double4 *dst, const __local double4 *src, size_t num_elements, event_t event);
3312 event_t __ovld async_work_group_copy(__global double8 *dst, const __local double8 *src, size_t num_elements, event_t event);
3313 event_t __ovld async_work_group_copy(__global double16 *dst, const __local double16 *src, size_t num_elements, event_t event);
3314-#endif //cl_khr_fp64
3315+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3316 #ifdef cl_khr_fp16
3317 event_t __ovld async_work_group_copy(__local half *dst, const __global half *src, size_t num_elements, event_t event);
3318 event_t __ovld async_work_group_copy(__local half2 *dst, const __global half2 *src, size_t num_elements, event_t event);
3319@@ -12893,7 +12898,7 @@ event_t __ovld async_work_group_strided_copy(__global uint16 *dst, const __local
3320 event_t __ovld async_work_group_strided_copy(__global long16 *dst, const __local long16 *src, size_t num_elements, size_t dst_stride, event_t event);
3321 event_t __ovld async_work_group_strided_copy(__global ulong16 *dst, const __local ulong16 *src, size_t num_elements, size_t dst_stride, event_t event);
3322 event_t __ovld async_work_group_strided_copy(__global float16 *dst, const __local float16 *src, size_t num_elements, size_t dst_stride, event_t event);
3323-#ifdef cl_khr_fp64
3324+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3325 event_t __ovld async_work_group_strided_copy(__local double *dst, const __global double *src, size_t num_elements, size_t src_stride, event_t event);
3326 event_t __ovld async_work_group_strided_copy(__local double2 *dst, const __global double2 *src, size_t num_elements, size_t src_stride, event_t event);
3327 event_t __ovld async_work_group_strided_copy(__local double3 *dst, const __global double3 *src, size_t num_elements, size_t src_stride, event_t event);
3328@@ -12906,7 +12911,7 @@ event_t __ovld async_work_group_strided_copy(__global double3 *dst, const __loca
3329 event_t __ovld async_work_group_strided_copy(__global double4 *dst, const __local double4 *src, size_t num_elements, size_t dst_stride, event_t event);
3330 event_t __ovld async_work_group_strided_copy(__global double8 *dst, const __local double8 *src, size_t num_elements, size_t dst_stride, event_t event);
3331 event_t __ovld async_work_group_strided_copy(__global double16 *dst, const __local double16 *src, size_t num_elements, size_t dst_stride, event_t event);
3332-#endif //cl_khr_fp64
3333+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3334 #ifdef cl_khr_fp16
3335 event_t __ovld async_work_group_strided_copy(__local half *dst, const __global half *src, size_t num_elements, size_t src_stride, event_t event);
3336 event_t __ovld async_work_group_strided_copy(__local half2 *dst, const __global half2 *src, size_t num_elements, size_t src_stride, event_t event);
3337@@ -12996,14 +13001,14 @@ void __ovld prefetch(const __global uint16 *p, size_t num_elements);
3338 void __ovld prefetch(const __global long16 *p, size_t num_elements);
3339 void __ovld prefetch(const __global ulong16 *p, size_t num_elements);
3340 void __ovld prefetch(const __global float16 *p, size_t num_elements);
3341-#ifdef cl_khr_fp64
3342+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3343 void __ovld prefetch(const __global double *p, size_t num_elements);
3344 void __ovld prefetch(const __global double2 *p, size_t num_elements);
3345 void __ovld prefetch(const __global double3 *p, size_t num_elements);
3346 void __ovld prefetch(const __global double4 *p, size_t num_elements);
3347 void __ovld prefetch(const __global double8 *p, size_t num_elements);
3348 void __ovld prefetch(const __global double16 *p, size_t num_elements);
3349-#endif //cl_khr_fp64
3350+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3351 #ifdef cl_khr_fp16
3352 void __ovld prefetch(const __global half *p, size_t num_elements);
3353 void __ovld prefetch(const __global half2 *p, size_t num_elements);
3354@@ -13026,9 +13031,11 @@ void __ovld prefetch(const __global half16 *p, size_t num_elements);
3355 * pointed by p. The function returns old.
3356 */
3357 int __ovld atomic_add(volatile __global int *p, int val);
3358-unsigned int __ovld atomic_add(volatile __global unsigned int *p, unsigned int val);
3359+unsigned int __ovld atomic_add(volatile __global unsigned int *p,
3360+ unsigned int val);
3361 int __ovld atomic_add(volatile __local int *p, int val);
3362-unsigned int __ovld atomic_add(volatile __local unsigned int *p, unsigned int val);
3363+unsigned int __ovld atomic_add(volatile __local unsigned int *p,
3364+ unsigned int val);
3365 #ifdef __OPENCL_CPP_VERSION__
3366 int __ovld atomic_add(volatile int *p, int val);
3367 unsigned int __ovld atomic_add(volatile unsigned int *p, unsigned int val);
3368@@ -13056,9 +13063,11 @@ unsigned long __ovld atom_add(volatile __local unsigned long *p, unsigned long v
3369 * returns old.
3370 */
3371 int __ovld atomic_sub(volatile __global int *p, int val);
3372-unsigned int __ovld atomic_sub(volatile __global unsigned int *p, unsigned int val);
3373+unsigned int __ovld atomic_sub(volatile __global unsigned int *p,
3374+ unsigned int val);
3375 int __ovld atomic_sub(volatile __local int *p, int val);
3376-unsigned int __ovld atomic_sub(volatile __local unsigned int *p, unsigned int val);
3377+unsigned int __ovld atomic_sub(volatile __local unsigned int *p,
3378+ unsigned int val);
3379 #ifdef __OPENCL_CPP_VERSION__
3380 int __ovld atomic_sub(volatile int *p, int val);
3381 unsigned int __ovld atomic_sub(volatile unsigned int *p, unsigned int val);
3382@@ -13086,9 +13095,11 @@ unsigned long __ovld atom_sub(volatile __local unsigned long *p, unsigned long v
3383 * value.
3384 */
3385 int __ovld atomic_xchg(volatile __global int *p, int val);
3386-unsigned int __ovld atomic_xchg(volatile __global unsigned int *p, unsigned int val);
3387+unsigned int __ovld atomic_xchg(volatile __global unsigned int *p,
3388+ unsigned int val);
3389 int __ovld atomic_xchg(volatile __local int *p, int val);
3390-unsigned int __ovld atomic_xchg(volatile __local unsigned int *p, unsigned int val);
3391+unsigned int __ovld atomic_xchg(volatile __local unsigned int *p,
3392+ unsigned int val);
3393 float __ovld atomic_xchg(volatile __global float *p, float val);
3394 float __ovld atomic_xchg(volatile __local float *p, float val);
3395 #ifdef __OPENCL_CPP_VERSION__
3396@@ -13183,12 +13194,15 @@ unsigned long __ovld atom_dec(volatile __local unsigned long *p);
3397 * returns old.
3398 */
3399 int __ovld atomic_cmpxchg(volatile __global int *p, int cmp, int val);
3400-unsigned int __ovld atomic_cmpxchg(volatile __global unsigned int *p, unsigned int cmp, unsigned int val);
3401+unsigned int __ovld atomic_cmpxchg(volatile __global unsigned int *p,
3402+ unsigned int cmp, unsigned int val);
3403 int __ovld atomic_cmpxchg(volatile __local int *p, int cmp, int val);
3404-unsigned int __ovld atomic_cmpxchg(volatile __local unsigned int *p, unsigned int cmp, unsigned int val);
3405+unsigned int __ovld atomic_cmpxchg(volatile __local unsigned int *p,
3406+ unsigned int cmp, unsigned int val);
3407 #ifdef __OPENCL_CPP_VERSION__
3408 int __ovld atomic_cmpxchg(volatile int *p, int cmp, int val);
3409-unsigned int __ovld atomic_cmpxchg(volatile unsigned int *p, unsigned int cmp, unsigned int val);
3410+unsigned int __ovld atomic_cmpxchg(volatile unsigned int *p, unsigned int cmp,
3411+ unsigned int val);
3412 #endif
3413
3414 #if defined(cl_khr_global_int32_base_atomics)
3415@@ -13215,9 +13229,11 @@ unsigned long __ovld atom_cmpxchg(volatile __local unsigned long *p, unsigned lo
3416 * returns old.
3417 */
3418 int __ovld atomic_min(volatile __global int *p, int val);
3419-unsigned int __ovld atomic_min(volatile __global unsigned int *p, unsigned int val);
3420+unsigned int __ovld atomic_min(volatile __global unsigned int *p,
3421+ unsigned int val);
3422 int __ovld atomic_min(volatile __local int *p, int val);
3423-unsigned int __ovld atomic_min(volatile __local unsigned int *p, unsigned int val);
3424+unsigned int __ovld atomic_min(volatile __local unsigned int *p,
3425+ unsigned int val);
3426 #ifdef __OPENCL_CPP_VERSION__
3427 int __ovld atomic_min(volatile int *p, int val);
3428 unsigned int __ovld atomic_min(volatile unsigned int *p, unsigned int val);
3429@@ -13247,9 +13263,11 @@ unsigned long __ovld atom_min(volatile __local unsigned long *p, unsigned long v
3430 * returns old.
3431 */
3432 int __ovld atomic_max(volatile __global int *p, int val);
3433-unsigned int __ovld atomic_max(volatile __global unsigned int *p, unsigned int val);
3434+unsigned int __ovld atomic_max(volatile __global unsigned int *p,
3435+ unsigned int val);
3436 int __ovld atomic_max(volatile __local int *p, int val);
3437-unsigned int __ovld atomic_max(volatile __local unsigned int *p, unsigned int val);
3438+unsigned int __ovld atomic_max(volatile __local unsigned int *p,
3439+ unsigned int val);
3440 #ifdef __OPENCL_CPP_VERSION__
3441 int __ovld atomic_max(volatile int *p, int val);
3442 unsigned int __ovld atomic_max(volatile unsigned int *p, unsigned int val);
3443@@ -13278,9 +13296,11 @@ unsigned long __ovld atom_max(volatile __local unsigned long *p, unsigned long v
3444 * pointed by p. The function returns old.
3445 */
3446 int __ovld atomic_and(volatile __global int *p, int val);
3447-unsigned int __ovld atomic_and(volatile __global unsigned int *p, unsigned int val);
3448+unsigned int __ovld atomic_and(volatile __global unsigned int *p,
3449+ unsigned int val);
3450 int __ovld atomic_and(volatile __local int *p, int val);
3451-unsigned int __ovld atomic_and(volatile __local unsigned int *p, unsigned int val);
3452+unsigned int __ovld atomic_and(volatile __local unsigned int *p,
3453+ unsigned int val);
3454 #ifdef __OPENCL_CPP_VERSION__
3455 int __ovld atomic_and(volatile int *p, int val);
3456 unsigned int __ovld atomic_and(volatile unsigned int *p, unsigned int val);
3457@@ -13309,9 +13329,11 @@ unsigned long __ovld atom_and(volatile __local unsigned long *p, unsigned long v
3458 * pointed by p. The function returns old.
3459 */
3460 int __ovld atomic_or(volatile __global int *p, int val);
3461-unsigned int __ovld atomic_or(volatile __global unsigned int *p, unsigned int val);
3462+unsigned int __ovld atomic_or(volatile __global unsigned int *p,
3463+ unsigned int val);
3464 int __ovld atomic_or(volatile __local int *p, int val);
3465-unsigned int __ovld atomic_or(volatile __local unsigned int *p, unsigned int val);
3466+unsigned int __ovld atomic_or(volatile __local unsigned int *p,
3467+ unsigned int val);
3468 #ifdef __OPENCL_CPP_VERSION__
3469 int __ovld atomic_or(volatile int *p, int val);
3470 unsigned int __ovld atomic_or(volatile unsigned int *p, unsigned int val);
3471@@ -13340,9 +13362,11 @@ unsigned long __ovld atom_or(volatile __local unsigned long *p, unsigned long va
3472 * pointed by p. The function returns old.
3473 */
3474 int __ovld atomic_xor(volatile __global int *p, int val);
3475-unsigned int __ovld atomic_xor(volatile __global unsigned int *p, unsigned int val);
3476+unsigned int __ovld atomic_xor(volatile __global unsigned int *p,
3477+ unsigned int val);
3478 int __ovld atomic_xor(volatile __local int *p, int val);
3479-unsigned int __ovld atomic_xor(volatile __local unsigned int *p, unsigned int val);
3480+unsigned int __ovld atomic_xor(volatile __local unsigned int *p,
3481+ unsigned int val);
3482 #ifdef __OPENCL_CPP_VERSION__
3483 int __ovld atomic_xor(volatile int *p, int val);
3484 unsigned int __ovld atomic_xor(volatile unsigned int *p, unsigned int val);
3485@@ -13380,120 +13404,78 @@ unsigned long __ovld atom_xor(volatile __local unsigned long *p, unsigned long v
3486 #endif
3487
3488 // atomic_init()
3489+#ifdef __opencl_c_generic_address_space
3490 void __ovld atomic_init(volatile atomic_int *object, int value);
3491 void __ovld atomic_init(volatile atomic_uint *object, uint value);
3492 void __ovld atomic_init(volatile atomic_float *object, float value);
3493 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
3494 void __ovld atomic_init(volatile atomic_long *object, long value);
3495 void __ovld atomic_init(volatile atomic_ulong *object, ulong value);
3496-#ifdef cl_khr_fp64
3497+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3498 void __ovld atomic_init(volatile atomic_double *object, double value);
3499-#endif //cl_khr_fp64
3500-#endif
3501+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3502+#endif // defined(cl_khr_int64_base_atomics) &&
3503+ // defined(cl_khr_int64_extended_atomics)
3504+#endif // __opencl_c_generic_address_space
3505+
3506+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
3507+void __ovld atomic_init(volatile atomic_int __global *object, int value);
3508+void __ovld atomic_init(volatile atomic_int __local *object, int value);
3509+void __ovld atomic_init(volatile atomic_uint __global *object, uint value);
3510+void __ovld atomic_init(volatile atomic_uint __local *object, uint value);
3511+void __ovld atomic_init(volatile atomic_float __global *object, float value);
3512+void __ovld atomic_init(volatile atomic_float __local *object, float value);
3513+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
3514+void __ovld atomic_init(volatile atomic_long __global *object, long value);
3515+void __ovld atomic_init(volatile atomic_long __local *object, long value);
3516+void __ovld atomic_init(volatile atomic_ulong __global *object, ulong value);
3517+void __ovld atomic_init(volatile atomic_ulong __local *object, ulong value);
3518+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3519+void __ovld atomic_init(volatile atomic_double __global *object, double value);
3520+void __ovld atomic_init(volatile atomic_double __local *object, double value);
3521+#endif // cl_khr_fp64
3522+#endif // defined(cl_khr_int64_base_atomics) &&
3523+ // defined(cl_khr_int64_extended_atomics)
3524+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
3525
3526 // atomic_work_item_fence()
3527-void __ovld atomic_work_item_fence(cl_mem_fence_flags flags, memory_order order, memory_scope scope);
3528+void __ovld atomic_work_item_fence(cl_mem_fence_flags flags, memory_order order,
3529+ memory_scope scope);
3530
3531 // atomic_fetch()
3532-
3533+#if defined(__opencl_c_atomic_scope_device) && \
3534+ defined(__opencl_c_atomic_order_seq_cst)
3535+#ifdef __opencl_c_generic_address_space
3536 int __ovld atomic_fetch_add(volatile atomic_int *object, int operand);
3537-int __ovld atomic_fetch_add_explicit(volatile atomic_int *object, int operand, memory_order order);
3538-int __ovld atomic_fetch_add_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
3539 uint __ovld atomic_fetch_add(volatile atomic_uint *object, uint operand);
3540-uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *object, uint operand, memory_order order);
3541-uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
3542 int __ovld atomic_fetch_sub(volatile atomic_int *object, int operand);
3543-int __ovld atomic_fetch_sub_explicit(volatile atomic_int *object, int operand, memory_order order);
3544-int __ovld atomic_fetch_sub_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
3545 uint __ovld atomic_fetch_sub(volatile atomic_uint *object, uint operand);
3546-uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *object, uint operand, memory_order order);
3547-uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
3548 int __ovld atomic_fetch_or(volatile atomic_int *object, int operand);
3549-int __ovld atomic_fetch_or_explicit(volatile atomic_int *object, int operand, memory_order order);
3550-int __ovld atomic_fetch_or_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
3551 uint __ovld atomic_fetch_or(volatile atomic_uint *object, uint operand);
3552-uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *object, uint operand, memory_order order);
3553-uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
3554 int __ovld atomic_fetch_xor(volatile atomic_int *object, int operand);
3555-int __ovld atomic_fetch_xor_explicit(volatile atomic_int *object, int operand, memory_order order);
3556-int __ovld atomic_fetch_xor_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
3557 uint __ovld atomic_fetch_xor(volatile atomic_uint *object, uint operand);
3558-uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint *object, uint operand, memory_order order);
3559-uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
3560 int __ovld atomic_fetch_and(volatile atomic_int *object, int operand);
3561-int __ovld atomic_fetch_and_explicit(volatile atomic_int *object, int operand, memory_order order);
3562-int __ovld atomic_fetch_and_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
3563 uint __ovld atomic_fetch_and(volatile atomic_uint *object, uint operand);
3564-uint __ovld atomic_fetch_and_explicit(volatile atomic_uint *object, uint operand, memory_order order);
3565-uint __ovld atomic_fetch_and_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
3566 int __ovld atomic_fetch_min(volatile atomic_int *object, int operand);
3567-int __ovld atomic_fetch_min_explicit(volatile atomic_int *object, int operand, memory_order order);
3568-int __ovld atomic_fetch_min_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
3569 uint __ovld atomic_fetch_min(volatile atomic_uint *object, uint operand);
3570-uint __ovld atomic_fetch_min_explicit(volatile atomic_uint *object, uint operand, memory_order order);
3571-uint __ovld atomic_fetch_min_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
3572-uint __ovld atomic_fetch_min(volatile atomic_uint *object, int operand);
3573-uint __ovld atomic_fetch_min_explicit(volatile atomic_uint *object, int operand, memory_order order);
3574-uint __ovld atomic_fetch_min_explicit(volatile atomic_uint *object, int operand, memory_order order, memory_scope scope);
3575 int __ovld atomic_fetch_max(volatile atomic_int *object, int operand);
3576-int __ovld atomic_fetch_max_explicit(volatile atomic_int *object, int operand, memory_order order);
3577-int __ovld atomic_fetch_max_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
3578 uint __ovld atomic_fetch_max(volatile atomic_uint *object, uint operand);
3579-uint __ovld atomic_fetch_max_explicit(volatile atomic_uint *object, uint operand, memory_order order);
3580-uint __ovld atomic_fetch_max_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
3581-uint __ovld atomic_fetch_max(volatile atomic_uint *object, int operand);
3582-uint __ovld atomic_fetch_max_explicit(volatile atomic_uint *object, int operand, memory_order order);
3583-uint __ovld atomic_fetch_max_explicit(volatile atomic_uint *object, int operand, memory_order order, memory_scope scope);
3584
3585 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
3586 long __ovld atomic_fetch_add(volatile atomic_long *object, long operand);
3587-long __ovld atomic_fetch_add_explicit(volatile atomic_long *object, long operand, memory_order order);
3588-long __ovld atomic_fetch_add_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);
3589 ulong __ovld atomic_fetch_add(volatile atomic_ulong *object, ulong operand);
3590-ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
3591-ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);
3592 long __ovld atomic_fetch_sub(volatile atomic_long *object, long operand);
3593-long __ovld atomic_fetch_sub_explicit(volatile atomic_long *object, long operand, memory_order order);
3594-long __ovld atomic_fetch_sub_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);
3595 ulong __ovld atomic_fetch_sub(volatile atomic_ulong *object, ulong operand);
3596-ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
3597-ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);
3598 long __ovld atomic_fetch_or(volatile atomic_long *object, long operand);
3599-long __ovld atomic_fetch_or_explicit(volatile atomic_long *object, long operand, memory_order order);
3600-long __ovld atomic_fetch_or_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);
3601 ulong __ovld atomic_fetch_or(volatile atomic_ulong *object, ulong operand);
3602-ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
3603-ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);
3604 long __ovld atomic_fetch_xor(volatile atomic_long *object, long operand);
3605-long __ovld atomic_fetch_xor_explicit(volatile atomic_long *object, long operand, memory_order order);
3606-long __ovld atomic_fetch_xor_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);
3607 ulong __ovld atomic_fetch_xor(volatile atomic_ulong *object, ulong operand);
3608-ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
3609-ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);
3610 long __ovld atomic_fetch_and(volatile atomic_long *object, long operand);
3611-long __ovld atomic_fetch_and_explicit(volatile atomic_long *object, long operand, memory_order order);
3612-long __ovld atomic_fetch_and_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);
3613 ulong __ovld atomic_fetch_and(volatile atomic_ulong *object, ulong operand);
3614-ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
3615-ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);
3616 long __ovld atomic_fetch_min(volatile atomic_long *object, long operand);
3617-long __ovld atomic_fetch_min_explicit(volatile atomic_long *object, long operand, memory_order order);
3618-long __ovld atomic_fetch_min_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);
3619 ulong __ovld atomic_fetch_min(volatile atomic_ulong *object, ulong operand);
3620-ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
3621-ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);
3622-ulong __ovld atomic_fetch_min(volatile atomic_ulong *object, long operand);
3623-ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *object, long operand, memory_order order);
3624-ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *object, long operand, memory_order order, memory_scope scope);
3625 long __ovld atomic_fetch_max(volatile atomic_long *object, long operand);
3626-long __ovld atomic_fetch_max_explicit(volatile atomic_long *object, long operand, memory_order order);
3627-long __ovld atomic_fetch_max_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);
3628 ulong __ovld atomic_fetch_max(volatile atomic_ulong *object, ulong operand);
3629-ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
3630-ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);
3631-ulong __ovld atomic_fetch_max(volatile atomic_ulong *object, long operand);
3632-ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *object, long operand, memory_order order);
3633-ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *object, long operand, memory_order order, memory_scope scope);
3634 #endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
3635
3636 // OpenCL v2.0 s6.13.11.7.5:
3637@@ -13501,196 +13483,2239 @@ ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *object, long opera
3638 // or/xor/and/min/max: atomic type argument can be intptr_t/uintptr_t, value type argument can be intptr_t/uintptr_t.
3639
3640 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
3641-uintptr_t __ovld atomic_fetch_add(volatile atomic_uintptr_t *object, ptrdiff_t operand);
3642-uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order);
3643-uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order, memory_scope scope);
3644-uintptr_t __ovld atomic_fetch_sub(volatile atomic_uintptr_t *object, ptrdiff_t operand);
3645-uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order);
3646-uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order, memory_scope scope);
3647-
3648-uintptr_t __ovld atomic_fetch_or(volatile atomic_uintptr_t *object, intptr_t operand);
3649-uintptr_t __ovld atomic_fetch_or_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order);
3650-uintptr_t __ovld atomic_fetch_or_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order, memory_scope scope);
3651-uintptr_t __ovld atomic_fetch_xor(volatile atomic_uintptr_t *object, intptr_t operand);
3652-uintptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order);
3653-uintptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order, memory_scope scope);
3654-uintptr_t __ovld atomic_fetch_and(volatile atomic_uintptr_t *object, intptr_t operand);
3655-uintptr_t __ovld atomic_fetch_and_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order);
3656-uintptr_t __ovld atomic_fetch_and_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order, memory_scope scope);
3657-uintptr_t __ovld atomic_fetch_min(volatile atomic_uintptr_t *object, intptr_t opermax);
3658-uintptr_t __ovld atomic_fetch_min_explicit(volatile atomic_uintptr_t *object, intptr_t opermax, memory_order minder);
3659-uintptr_t __ovld atomic_fetch_min_explicit(volatile atomic_uintptr_t *object, intptr_t opermax, memory_order minder, memory_scope scope);
3660-uintptr_t __ovld atomic_fetch_max(volatile atomic_uintptr_t *object, intptr_t opermax);
3661-uintptr_t __ovld atomic_fetch_max_explicit(volatile atomic_uintptr_t *object, intptr_t opermax, memory_order minder);
3662-uintptr_t __ovld atomic_fetch_max_explicit(volatile atomic_uintptr_t *object, intptr_t opermax, memory_order minder, memory_scope scope);
3663-
3664-intptr_t __ovld atomic_fetch_or(volatile atomic_intptr_t *object, uintptr_t operand);
3665-intptr_t __ovld atomic_fetch_or_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order);
3666-intptr_t __ovld atomic_fetch_or_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order, memory_scope scope);
3667-intptr_t __ovld atomic_fetch_xor(volatile atomic_intptr_t *object, uintptr_t operand);
3668-intptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order);
3669-intptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order, memory_scope scope);
3670-intptr_t __ovld atomic_fetch_and(volatile atomic_intptr_t *object, uintptr_t operand);
3671-intptr_t __ovld atomic_fetch_and_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order);
3672-intptr_t __ovld atomic_fetch_and_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order, memory_scope scope);
3673-intptr_t __ovld atomic_fetch_min(volatile atomic_intptr_t *object, uintptr_t opermax);
3674-intptr_t __ovld atomic_fetch_min_explicit(volatile atomic_intptr_t *object, uintptr_t opermax, memory_order minder);
3675-intptr_t __ovld atomic_fetch_min_explicit(volatile atomic_intptr_t *object, uintptr_t opermax, memory_order minder, memory_scope scope);
3676-intptr_t __ovld atomic_fetch_max(volatile atomic_intptr_t *object, uintptr_t opermax);
3677-intptr_t __ovld atomic_fetch_max_explicit(volatile atomic_intptr_t *object, uintptr_t opermax, memory_order minder);
3678-intptr_t __ovld atomic_fetch_max_explicit(volatile atomic_intptr_t *object, uintptr_t opermax, memory_order minder, memory_scope scope);
3679+uintptr_t __ovld atomic_fetch_add(volatile atomic_uintptr_t *object,
3680+ ptrdiff_t operand);
3681+uintptr_t __ovld atomic_fetch_sub(volatile atomic_uintptr_t *object,
3682+ ptrdiff_t operand);
3683+
3684+uintptr_t __ovld atomic_fetch_or(volatile atomic_uintptr_t *object,
3685+ intptr_t operand);
3686+uintptr_t __ovld atomic_fetch_xor(volatile atomic_uintptr_t *object,
3687+ intptr_t operand);
3688+uintptr_t __ovld atomic_fetch_and(volatile atomic_uintptr_t *object,
3689+ intptr_t operand);
3690+uintptr_t __ovld atomic_fetch_min(volatile atomic_uintptr_t *object,
3691+ intptr_t opermax);
3692+uintptr_t __ovld atomic_fetch_max(volatile atomic_uintptr_t *object,
3693+ intptr_t opermax);
3694+
3695+intptr_t __ovld atomic_fetch_or(volatile atomic_intptr_t *object,
3696+ uintptr_t operand);
3697+intptr_t __ovld atomic_fetch_xor(volatile atomic_intptr_t *object,
3698+ uintptr_t operand);
3699+intptr_t __ovld atomic_fetch_and(volatile atomic_intptr_t *object,
3700+ uintptr_t operand);
3701+intptr_t __ovld atomic_fetch_min(volatile atomic_intptr_t *object,
3702+ uintptr_t opermax);
3703+intptr_t __ovld atomic_fetch_max(volatile atomic_intptr_t *object,
3704+ uintptr_t opermax);
3705+#endif // defined(cl_khr_int64_base_atomics) &&
3706+ // defined(cl_khr_int64_extended_atomics)
3707+#endif // __opencl_c_generic_address_space
3708+
3709+#if(__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
3710+int __ovld atomic_fetch_add(volatile atomic_int __global *object, int operand);
3711+uint __ovld atomic_fetch_add(volatile atomic_uint __local *object,
3712+ uint operand);
3713+int __ovld atomic_fetch_sub(volatile atomic_int __global *object, int operand);
3714+int __ovld atomic_fetch_sub(volatile atomic_int __local *object, int operand);
3715+uint __ovld atomic_fetch_sub(volatile atomic_uint __local *object,
3716+ uint operand);
3717+uint __ovld atomic_fetch_sub(volatile atomic_uint __global *object,
3718+ uint operand);
3719+int __ovld atomic_fetch_or(volatile atomic_int __global *object, int operand);
3720+uint __ovld atomic_fetch_sub(volatile atomic_uint __local *object,
3721+ uint operand);
3722+uint __ovld atomic_fetch_or(volatile atomic_uint __global *object,
3723+ uint operand);
3724+uint __ovld atomic_fetch_or(volatile atomic_uint __local *object, uint operand);
3725+int __ovld atomic_fetch_xor(volatile atomic_int __global *object, int operand);
3726+int __ovld atomic_fetch_xor(volatile atomic_int __local *object, int operand);
3727+uint __ovld atomic_fetch_xor(volatile atomic_uint __global *object,
3728+ uint operand);
3729+uint __ovld atomic_fetch_xor(volatile atomic_uint __local *object,
3730+ uint operand);
3731+int __ovld atomic_fetch_and(volatile atomic_int __global *object, int operand);
3732+int __ovld atomic_fetch_and(volatile atomic_int __local *object, int operand);
3733+uint __ovld atomic_fetch_and(volatile atomic_uint __global *object,
3734+ uint operand);
3735+uint __ovld atomic_fetch_and(volatile atomic_uint __local *object,
3736+ uint operand);
3737+int __ovld atomic_fetch_min(volatile atomic_int __global *object, int operand);
3738+int __ovld atomic_fetch_min(volatile atomic_int __local *object, int operand);
3739+uint __ovld atomic_fetch_min(volatile atomic_uint __global *object,
3740+ uint operand);
3741+uint __ovld atomic_fetch_min(volatile atomic_uint __local *object,
3742+ uint operand);
3743+int __ovld atomic_fetch_max(volatile atomic_int __global *object, int operand);
3744+int __ovld atomic_fetch_max(volatile atomic_int __local *object, int operand);
3745+uint __ovld atomic_fetch_max(volatile atomic_uint __global *object,
3746+ uint operand);
3747+uint __ovld atomic_fetch_max(volatile atomic_uint __local *object,
3748+ uint operand);
3749+
3750+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
3751+long __ovld atomic_fetch_add(volatile atomic_long __global *object,
3752+ long operand);
3753+long __ovld atomic_fetch_add(volatile atomic_long __local *object,
3754+ long operand);
3755+ulong __ovld atomic_fetch_add(volatile atomic_ulong __global *object,
3756+ ulong operand);
3757+ulong __ovld atomic_fetch_add(volatile atomic_ulong __local *object,
3758+ ulong operand);
3759+long __ovld atomic_fetch_sub(volatile atomic_long __global *object,
3760+ long operand);
3761+long __ovld atomic_fetch_sub(volatile atomic_long __local *object,
3762+ long operand);
3763+ulong __ovld atomic_fetch_sub(volatile atomic_ulong __global *object,
3764+ ulong operand);
3765+ulong __ovld atomic_fetch_sub(volatile atomic_ulong __local *object,
3766+ ulong operand);
3767+long __ovld atomic_fetch_or(volatile atomic_long __global *object,
3768+ long operand);
3769+long __ovld atomic_fetch_or(volatile atomic_long __local *object, long operand);
3770+ulong __ovld atomic_fetch_or(volatile atomic_ulong __global *object,
3771+ ulong operand);
3772+ulong __ovld atomic_fetch_or(volatile atomic_ulong __local *object,
3773+ ulong operand);
3774+long __ovld atomic_fetch_xor(volatile atomic_long __global *object,
3775+ long operand);
3776+long __ovld atomic_fetch_xor(volatile atomic_long __local *object,
3777+ long operand);
3778+ulong __ovld atomic_fetch_xor(volatile atomic_ulong __global *object,
3779+ ulong operand);
3780+ulong __ovld atomic_fetch_xor(volatile atomic_ulong __local *object,
3781+ ulong operand);
3782+long __ovld atomic_fetch_and(volatile atomic_long __global *object,
3783+ long operand);
3784+long __ovld atomic_fetch_and(volatile atomic_long __local *object,
3785+ long operand);
3786+ulong __ovld atomic_fetch_and(volatile atomic_ulong __global *object,
3787+ ulong operand);
3788+ulong __ovld atomic_fetch_and(volatile atomic_ulong __local *object,
3789+ ulong operand);
3790+long __ovld atomic_fetch_min(volatile atomic_long __global *object,
3791+ long operand);
3792+long __ovld atomic_fetch_min(volatile atomic_long __local *object,
3793+ long operand);
3794+ulong __ovld atomic_fetch_min(volatile atomic_ulong __global *object,
3795+ ulong operand);
3796+ulong __ovld atomic_fetch_min(volatile atomic_ulong __local *object,
3797+ ulong operand);
3798+long __ovld atomic_fetch_max(volatile atomic_long __global *object,
3799+ long operand);
3800+long __ovld atomic_fetch_max(volatile atomic_long __local *object,
3801+ long operand);
3802+ulong __ovld atomic_fetch_max(volatile atomic_ulong __global *object,
3803+ ulong operand);
3804+ulong __ovld atomic_fetch_max(volatile atomic_ulong __local *object,
3805+ ulong operand);
3806+#endif // defined(cl_khr_int64_base_atomics) &&
3807+ // defined(cl_khr_int64_extended_atomics)
3808+
3809+// OpenCL v2.0 s6.13.11.7.5:
3810+// add/sub: atomic type argument can be uintptr_t/intptr_t, value type argument
3811+// can be ptrdiff_t. or/xor/and/min/max: atomic type argument can be
3812+// intptr_t/uintptr_t, value type argument can be intptr_t/uintptr_t.
3813+
3814+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
3815+uintptr_t __ovld atomic_fetch_add(volatile atomic_uintptr_t __global *object,
3816+ ptrdiff_t operand);
3817+uintptr_t __ovld atomic_fetch_add(volatile atomic_uintptr_t __local *object,
3818+ ptrdiff_t operand);
3819+uintptr_t __ovld atomic_fetch_sub(volatile atomic_uintptr_t __global *object,
3820+ ptrdiff_t operand);
3821+uintptr_t __ovld atomic_fetch_sub(volatile atomic_uintptr_t __local *object,
3822+ ptrdiff_t operand);
3823+
3824+uintptr_t __ovld atomic_fetch_or(volatile atomic_uintptr_t __global *object,
3825+ intptr_t operand);
3826+uintptr_t __ovld atomic_fetch_or(volatile atomic_uintptr_t __local *object,
3827+ intptr_t operand);
3828+uintptr_t __ovld atomic_fetch_xor(volatile atomic_uintptr_t __global *object,
3829+ intptr_t operand);
3830+uintptr_t __ovld atomic_fetch_xor(volatile atomic_uintptr_t __local *object,
3831+ intptr_t operand);
3832+uintptr_t __ovld atomic_fetch_and(volatile atomic_uintptr_t __global *object,
3833+ intptr_t operand);
3834+uintptr_t __ovld atomic_fetch_and(volatile atomic_uintptr_t __local *object,
3835+ intptr_t operand);
3836+uintptr_t __ovld atomic_fetch_min(volatile atomic_uintptr_t __global *object,
3837+ intptr_t opermax);
3838+uintptr_t __ovld atomic_fetch_min(volatile atomic_uintptr_t __local *object,
3839+ intptr_t opermax);
3840+uintptr_t __ovld atomic_fetch_max(volatile atomic_uintptr_t __global *object,
3841+ intptr_t opermax);
3842+uintptr_t __ovld atomic_fetch_max(volatile atomic_uintptr_t __local *object,
3843+ intptr_t opermax);
3844+
3845+intptr_t __ovld atomic_fetch_or(volatile atomic_intptr_t __global *object,
3846+ uintptr_t operand);
3847+intptr_t __ovld atomic_fetch_or(volatile atomic_intptr_t __local *object,
3848+ uintptr_t operand);
3849+intptr_t __ovld atomic_fetch_xor(volatile atomic_intptr_t __global *object,
3850+ uintptr_t operand);
3851+intptr_t __ovld atomic_fetch_xor(volatile atomic_intptr_t __local *object,
3852+ uintptr_t operand);
3853+intptr_t __ovld atomic_fetch_and(volatile atomic_intptr_t __global *object,
3854+ uintptr_t operand);
3855+intptr_t __ovld atomic_fetch_and(volatile atomic_intptr_t __local *object,
3856+ uintptr_t operand);
3857+intptr_t __ovld atomic_fetch_min(volatile atomic_intptr_t __global *object,
3858+ uintptr_t opermax);
3859+intptr_t __ovld atomic_fetch_min(volatile atomic_intptr_t __local *object,
3860+ uintptr_t opermax);
3861+intptr_t __ovld atomic_fetch_max(volatile atomic_intptr_t __global *object,
3862+ uintptr_t opermax);
3863+intptr_t __ovld atomic_fetch_max(volatile atomic_intptr_t __local *object,
3864+ uintptr_t opermax);
3865+#endif // defined(cl_khr_int64_base_atomics) &&
3866+ // defined(cl_khr_int64_extended_atomics)
3867+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
3868+
3869+#endif // defined(__opencl_c_atomic_scope_device) &&
3870+ // defined(__opencl_c_atomic_order_seq_cst)
3871+
3872+#ifdef __opencl_c_generic_address_space
3873+#ifdef __opencl_c_atomic_scope_device
3874+int __ovld atomic_fetch_add_explicit(volatile atomic_int *object, int operand,
3875+ memory_order order);
3876+uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *object,
3877+ uint operand, memory_order order);
3878+int __ovld atomic_fetch_sub_explicit(volatile atomic_int *object, int operand,
3879+ memory_order order);
3880+uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *object,
3881+ uint operand, memory_order order);
3882+int __ovld atomic_fetch_or_explicit(volatile atomic_int *object, int operand,
3883+ memory_order order);
3884+uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *object, uint operand,
3885+ memory_order order);
3886+int __ovld atomic_fetch_xor_explicit(volatile atomic_int *object, int operand,
3887+ memory_order order);
3888+uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint *object,
3889+ uint operand, memory_order order);
3890+int __ovld atomic_fetch_and_explicit(volatile atomic_int *object, int operand,
3891+ memory_order order);
3892+uint __ovld atomic_fetch_and_explicit(volatile atomic_uint *object,
3893+ uint operand, memory_order order);
3894+int __ovld atomic_fetch_min_explicit(volatile atomic_int *object, int operand,
3895+ memory_order order);
3896+uint __ovld atomic_fetch_min_explicit(volatile atomic_uint *object,
3897+ uint operand, memory_order order);
3898+int __ovld atomic_fetch_max_explicit(volatile atomic_int *object, int operand,
3899+ memory_order order);
3900+uint __ovld atomic_fetch_max_explicit(volatile atomic_uint *object,
3901+ uint operand, memory_order order);
3902+#endif // __opencl_c_atomic_scope_device
3903+int __ovld atomic_fetch_add_explicit(volatile atomic_int *object, int operand,
3904+ memory_order order, memory_scope scope);
3905+uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *object,
3906+ uint operand, memory_order order,
3907+ memory_scope scope);
3908+int __ovld atomic_fetch_sub_explicit(volatile atomic_int *object, int operand,
3909+ memory_order order, memory_scope scope);
3910+uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *object,
3911+ uint operand, memory_order order,
3912+ memory_scope scope);
3913+int __ovld atomic_fetch_or_explicit(volatile atomic_int *object, int operand,
3914+ memory_order order, memory_scope scope);
3915+uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *object, uint operand,
3916+ memory_order order, memory_scope scope);
3917+int __ovld atomic_fetch_xor_explicit(volatile atomic_int *object, int operand,
3918+ memory_order order, memory_scope scope);
3919+uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint *object,
3920+ uint operand, memory_order order,
3921+ memory_scope scope);
3922+int __ovld atomic_fetch_and_explicit(volatile atomic_int *object, int operand,
3923+ memory_order order, memory_scope scope);
3924+uint __ovld atomic_fetch_and_explicit(volatile atomic_uint *object,
3925+ uint operand, memory_order order,
3926+ memory_scope scope);
3927+int __ovld atomic_fetch_min_explicit(volatile atomic_int *object, int operand,
3928+ memory_order order, memory_scope scope);
3929+uint __ovld atomic_fetch_min_explicit(volatile atomic_uint *object,
3930+ uint operand, memory_order order,
3931+ memory_scope scope);
3932+int __ovld atomic_fetch_max_explicit(volatile atomic_int *object, int operand,
3933+ memory_order order, memory_scope scope);
3934+uint __ovld atomic_fetch_max_explicit(volatile atomic_uint *object,
3935+ uint operand, memory_order order,
3936+ memory_scope scope);
3937+
3938+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
3939+#ifdef __opencl_c_atomic_scope_device
3940+long __ovld atomic_fetch_add_explicit(volatile atomic_long *object,
3941+ long operand, memory_order order);
3942+ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong *object,
3943+ ulong operand, memory_order order);
3944+long __ovld atomic_fetch_sub_explicit(volatile atomic_long *object,
3945+ long operand, memory_order order);
3946+ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong *object,
3947+ ulong operand, memory_order order);
3948+long __ovld atomic_fetch_or_explicit(volatile atomic_long *object, long operand,
3949+ memory_order order);
3950+ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong *object,
3951+ ulong operand, memory_order order);
3952+long __ovld atomic_fetch_xor_explicit(volatile atomic_long *object,
3953+ long operand, memory_order order);
3954+ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong *object,
3955+ ulong operand, memory_order order);
3956+long __ovld atomic_fetch_and_explicit(volatile atomic_long *object,
3957+ long operand, memory_order order);
3958+ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong *object,
3959+ ulong operand, memory_order order);
3960+long __ovld atomic_fetch_min_explicit(volatile atomic_long *object,
3961+ long operand, memory_order order);
3962+ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *object,
3963+ ulong operand, memory_order order);
3964+long __ovld atomic_fetch_max_explicit(volatile atomic_long *object,
3965+ long operand, memory_order order);
3966+ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *object,
3967+ ulong operand, memory_order order);
3968+#endif // __opencl_c_atomic_scope_device
3969+long __ovld atomic_fetch_add_explicit(volatile atomic_long *object,
3970+ long operand, memory_order order,
3971+ memory_scope scope);
3972+ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong *object,
3973+ ulong operand, memory_order order,
3974+ memory_scope scope);
3975+long __ovld atomic_fetch_sub_explicit(volatile atomic_long *object,
3976+ long operand, memory_order order,
3977+ memory_scope scope);
3978+ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong *object,
3979+ ulong operand, memory_order order,
3980+ memory_scope scope);
3981+long __ovld atomic_fetch_or_explicit(volatile atomic_long *object, long operand,
3982+ memory_order order, memory_scope scope);
3983+ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong *object,
3984+ ulong operand, memory_order order,
3985+ memory_scope scope);
3986+long __ovld atomic_fetch_xor_explicit(volatile atomic_long *object,
3987+ long operand, memory_order order,
3988+ memory_scope scope);
3989+ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong *object,
3990+ ulong operand, memory_order order,
3991+ memory_scope scope);
3992+long __ovld atomic_fetch_and_explicit(volatile atomic_long *object,
3993+ long operand, memory_order order,
3994+ memory_scope scope);
3995+ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong *object,
3996+ ulong operand, memory_order order,
3997+ memory_scope scope);
3998+long __ovld atomic_fetch_min_explicit(volatile atomic_long *object,
3999+ long operand, memory_order order,
4000+ memory_scope scope);
4001+ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *object,
4002+ ulong operand, memory_order order,
4003+ memory_scope scope);
4004+long __ovld atomic_fetch_max_explicit(volatile atomic_long *object,
4005+ long operand, memory_order order,
4006+ memory_scope scope);
4007+ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *object,
4008+ ulong operand, memory_order order,
4009+ memory_scope scope);
4010+#endif // defined(cl_khr_int64_base_atomics) &&
4011+ // defined(cl_khr_int64_extended_atomics)
4012+
4013+// OpenCL v2.0 s6.13.11.7.5:
4014+// add/sub: atomic type argument can be uintptr_t/intptr_t, value type argument
4015+// can be ptrdiff_t. or/xor/and/min/max: atomic type argument can be
4016+// intptr_t/uintptr_t, value type argument can be intptr_t/uintptr_t.
4017+
4018+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4019+#ifdef __opencl_c_atomic_scope_device
4020+uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *object,
4021+ ptrdiff_t operand,
4022+ memory_order order);
4023+uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *object,
4024+ ptrdiff_t operand,
4025+ memory_order order);
4026+uintptr_t __ovld atomic_fetch_or_explicit(volatile atomic_uintptr_t *object,
4027+ intptr_t operand, memory_order order);
4028+uintptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_uintptr_t *object,
4029+ intptr_t operand,
4030+ memory_order order);
4031+uintptr_t __ovld atomic_fetch_and_explicit(volatile atomic_uintptr_t *object,
4032+ intptr_t operand,
4033+ memory_order order);
4034+uintptr_t __ovld atomic_fetch_min_explicit(volatile atomic_uintptr_t *object,
4035+ intptr_t opermax,
4036+ memory_order minder);
4037+uintptr_t __ovld atomic_fetch_max_explicit(volatile atomic_uintptr_t *object,
4038+ intptr_t opermax,
4039+ memory_order minder);
4040+intptr_t __ovld atomic_fetch_or_explicit(volatile atomic_intptr_t *object,
4041+ uintptr_t operand, memory_order order);
4042+intptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_intptr_t *object,
4043+ uintptr_t operand,
4044+ memory_order order);
4045+intptr_t __ovld atomic_fetch_and_explicit(volatile atomic_intptr_t *object,
4046+ uintptr_t operand,
4047+ memory_order order);
4048+intptr_t __ovld atomic_fetch_min_explicit(volatile atomic_intptr_t *object,
4049+ uintptr_t opermax,
4050+ memory_order minder);
4051+intptr_t __ovld atomic_fetch_max_explicit(volatile atomic_intptr_t *object,
4052+ uintptr_t opermax,
4053+ memory_order minder);
4054+#endif // __opencl_c_atomic_scope_device
4055+uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *object,
4056+ ptrdiff_t operand,
4057+ memory_order order,
4058+ memory_scope scope);
4059+uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *object,
4060+ ptrdiff_t operand,
4061+ memory_order order,
4062+ memory_scope scope);
4063+
4064+uintptr_t __ovld atomic_fetch_or_explicit(volatile atomic_uintptr_t *object,
4065+ intptr_t operand, memory_order order,
4066+ memory_scope scope);
4067+uintptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_uintptr_t *object,
4068+ intptr_t operand, memory_order order,
4069+ memory_scope scope);
4070+uintptr_t __ovld atomic_fetch_and_explicit(volatile atomic_uintptr_t *object,
4071+ intptr_t operand, memory_order order,
4072+ memory_scope scope);
4073+uintptr_t __ovld atomic_fetch_min_explicit(volatile atomic_uintptr_t *object,
4074+ intptr_t opermax,
4075+ memory_order minder,
4076+ memory_scope scope);
4077+uintptr_t __ovld atomic_fetch_max_explicit(volatile atomic_uintptr_t *object,
4078+ intptr_t opermax,
4079+ memory_order minder,
4080+ memory_scope scope);
4081+
4082+intptr_t __ovld atomic_fetch_or_explicit(volatile atomic_intptr_t *object,
4083+ uintptr_t operand, memory_order order,
4084+ memory_scope scope);
4085+intptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_intptr_t *object,
4086+ uintptr_t operand, memory_order order,
4087+ memory_scope scope);
4088+intptr_t __ovld atomic_fetch_and_explicit(volatile atomic_intptr_t *object,
4089+ uintptr_t operand, memory_order order,
4090+ memory_scope scope);
4091+intptr_t __ovld atomic_fetch_min_explicit(volatile atomic_intptr_t *object,
4092+ uintptr_t opermax,
4093+ memory_order minder,
4094+ memory_scope scope);
4095+intptr_t __ovld atomic_fetch_max_explicit(volatile atomic_intptr_t *object,
4096+ uintptr_t opermax,
4097+ memory_order minder,
4098+ memory_scope scope);
4099 #endif
4100+#endif // __opencl_c_generic_address_space
4101+
4102+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4103+#ifdef __opencl_c_atomic_scope_device
4104+int __ovld atomic_fetch_add_explicit(volatile atomic_int __global *object,
4105+ int operand, memory_order order);
4106+int __ovld atomic_fetch_add_explicit(volatile atomic_int __local *object,
4107+ int operand, memory_order order);
4108+uint __ovld atomic_fetch_add_explicit(volatile atomic_uint __global *object,
4109+ uint operand, memory_order order);
4110+uint __ovld atomic_fetch_add_explicit(volatile atomic_uint __local *object,
4111+ uint operand, memory_order order);
4112+int __ovld atomic_fetch_sub_explicit(volatile atomic_int __global *object,
4113+ int operand, memory_order order);
4114+int __ovld atomic_fetch_sub_explicit(volatile atomic_int __local *object,
4115+ int operand, memory_order order);
4116+uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint __global *object,
4117+ uint operand, memory_order order);
4118+uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint __local *object,
4119+ uint operand, memory_order order);
4120+int __ovld atomic_fetch_or_explicit(volatile atomic_int __global *object,
4121+ int operand, memory_order order);
4122+int __ovld atomic_fetch_or_explicit(volatile atomic_int __local *object,
4123+ int operand, memory_order order);
4124+uint __ovld atomic_fetch_or_explicit(volatile atomic_uint __global *object,
4125+ uint operand, memory_order order);
4126+uint __ovld atomic_fetch_or_explicit(volatile atomic_uint __local *object,
4127+ uint operand, memory_order order);
4128+int __ovld atomic_fetch_xor_explicit(volatile atomic_int __global *object,
4129+ int operand, memory_order order);
4130+int __ovld atomic_fetch_xor_explicit(volatile atomic_int __local *object,
4131+ int operand, memory_order order);
4132+uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint __global *object,
4133+ uint operand, memory_order order);
4134+uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint __local *object,
4135+ uint operand, memory_order order);
4136+int __ovld atomic_fetch_and_explicit(volatile atomic_int __global *object,
4137+ int operand, memory_order order);
4138+int __ovld atomic_fetch_and_explicit(volatile atomic_int __local *object,
4139+ int operand, memory_order order);
4140+uint __ovld atomic_fetch_and_explicit(volatile atomic_uint __global *object,
4141+ uint operand, memory_order order);
4142+uint __ovld atomic_fetch_and_explicit(volatile atomic_uint __local *object,
4143+ uint operand, memory_order order);
4144+int __ovld atomic_fetch_min_explicit(volatile atomic_int __global *object,
4145+ int operand, memory_order order);
4146+int __ovld atomic_fetch_min_explicit(volatile atomic_int __local *object,
4147+ int operand, memory_order order);
4148+uint __ovld atomic_fetch_min_explicit(volatile atomic_uint __global *object,
4149+ uint operand, memory_order order);
4150+uint __ovld atomic_fetch_min_explicit(volatile atomic_uint __local *object,
4151+ uint operand, memory_order order);
4152+int __ovld atomic_fetch_max_explicit(volatile atomic_int __global *object,
4153+ int operand, memory_order order);
4154+int __ovld atomic_fetch_max_explicit(volatile atomic_int __local *object,
4155+ int operand, memory_order order);
4156+uint __ovld atomic_fetch_max_explicit(volatile atomic_uint __global *object,
4157+ uint operand, memory_order order);
4158+uint __ovld atomic_fetch_max_explicit(volatile atomic_uint __local *object,
4159+ uint operand, memory_order order);
4160+#endif // __opencl_c_atomic_scope_device
4161+int __ovld atomic_fetch_add_explicit(volatile atomic_int __global *object,
4162+ int operand, memory_order order,
4163+ memory_scope scope);
4164+int __ovld atomic_fetch_add_explicit(volatile atomic_int __local *object,
4165+ int operand, memory_order order,
4166+ memory_scope scope);
4167+uint __ovld atomic_fetch_add_explicit(volatile atomic_uint __global *object,
4168+ uint operand, memory_order order,
4169+ memory_scope scope);
4170+uint __ovld atomic_fetch_add_explicit(volatile atomic_uint __local *object,
4171+ uint operand, memory_order order,
4172+ memory_scope scope);
4173+int __ovld atomic_fetch_sub_explicit(volatile atomic_int __global *object,
4174+ int operand, memory_order order,
4175+ memory_scope scope);
4176+int __ovld atomic_fetch_sub_explicit(volatile atomic_int __local *object,
4177+ int operand, memory_order order,
4178+ memory_scope scope);
4179+uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint __global *object,
4180+ uint operand, memory_order order,
4181+ memory_scope scope);
4182+uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint __local *object,
4183+ uint operand, memory_order order,
4184+ memory_scope scope);
4185+int __ovld atomic_fetch_or_explicit(volatile atomic_int __global *object,
4186+ int operand, memory_order order,
4187+ memory_scope scope);
4188+int __ovld atomic_fetch_or_explicit(volatile atomic_int __local *object,
4189+ int operand, memory_order order,
4190+ memory_scope scope);
4191+uint __ovld atomic_fetch_or_explicit(volatile atomic_uint __global *object,
4192+ uint operand, memory_order order,
4193+ memory_scope scope);
4194+uint __ovld atomic_fetch_or_explicit(volatile atomic_uint __local *object,
4195+ uint operand, memory_order order,
4196+ memory_scope scope);
4197+int __ovld atomic_fetch_xor_explicit(volatile atomic_int __global *object,
4198+ int operand, memory_order order,
4199+ memory_scope scope);
4200+int __ovld atomic_fetch_xor_explicit(volatile atomic_int __local *object,
4201+ int operand, memory_order order,
4202+ memory_scope scope);
4203+uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint __global *object,
4204+ uint operand, memory_order order,
4205+ memory_scope scope);
4206+uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint __local *object,
4207+ uint operand, memory_order order,
4208+ memory_scope scope);
4209+int __ovld atomic_fetch_and_explicit(volatile atomic_int __global *object,
4210+ int operand, memory_order order,
4211+ memory_scope scope);
4212+int __ovld atomic_fetch_and_explicit(volatile atomic_int __local *object,
4213+ int operand, memory_order order,
4214+ memory_scope scope);
4215+uint __ovld atomic_fetch_and_explicit(volatile atomic_uint __global *object,
4216+ uint operand, memory_order order,
4217+ memory_scope scope);
4218+uint __ovld atomic_fetch_and_explicit(volatile atomic_uint __local *object,
4219+ uint operand, memory_order order,
4220+ memory_scope scope);
4221+int __ovld atomic_fetch_min_explicit(volatile atomic_int __global *object,
4222+ int operand, memory_order order,
4223+ memory_scope scope);
4224+int __ovld atomic_fetch_min_explicit(volatile atomic_int __local *object,
4225+ int operand, memory_order order,
4226+ memory_scope scope);
4227+uint __ovld atomic_fetch_min_explicit(volatile atomic_uint __global *object,
4228+ uint operand, memory_order order,
4229+ memory_scope scope);
4230+uint __ovld atomic_fetch_min_explicit(volatile atomic_uint __local *object,
4231+ uint operand, memory_order order,
4232+ memory_scope scope);
4233+int __ovld atomic_fetch_max_explicit(volatile atomic_int __global *object,
4234+ int operand, memory_order order,
4235+ memory_scope scope);
4236+int __ovld atomic_fetch_max_explicit(volatile atomic_int __local *object,
4237+ int operand, memory_order order,
4238+ memory_scope scope);
4239+uint __ovld atomic_fetch_max_explicit(volatile atomic_uint __global *object,
4240+ uint operand, memory_order order,
4241+ memory_scope scope);
4242+uint __ovld atomic_fetch_max_explicit(volatile atomic_uint __local *object,
4243+ uint operand, memory_order order,
4244+ memory_scope scope);
4245+
4246+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4247+#ifdef __opencl_c_atomic_scope_device
4248+long __ovld atomic_fetch_add_explicit(volatile atomic_long __global *object,
4249+ long operand, memory_order order);
4250+long __ovld atomic_fetch_add_explicit(volatile atomic_long __local *object,
4251+ long operand, memory_order order);
4252+ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong __global *object,
4253+ ulong operand, memory_order order);
4254+ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong __local *object,
4255+ ulong operand, memory_order order);
4256+long __ovld atomic_fetch_sub_explicit(volatile atomic_long __global *object,
4257+ long operand, memory_order order);
4258+long __ovld atomic_fetch_sub_explicit(volatile atomic_long __local *object,
4259+ long operand, memory_order order);
4260+ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong __global *object,
4261+ ulong operand, memory_order order);
4262+ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong __local *object,
4263+ ulong operand, memory_order order);
4264+long __ovld atomic_fetch_or_explicit(volatile atomic_long __global *object,
4265+ long operand, memory_order order);
4266+long __ovld atomic_fetch_or_explicit(volatile atomic_long __local *object,
4267+ long operand, memory_order order);
4268+ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong __global *object,
4269+ ulong operand, memory_order order);
4270+ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong __local *object,
4271+ ulong operand, memory_order order);
4272+long __ovld atomic_fetch_xor_explicit(volatile atomic_long __global *object,
4273+ long operand, memory_order order);
4274+long __ovld atomic_fetch_xor_explicit(volatile atomic_long __local *object,
4275+ long operand, memory_order order);
4276+ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong __global *object,
4277+ ulong operand, memory_order order);
4278+ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong __local *object,
4279+ ulong operand, memory_order order);
4280+long __ovld atomic_fetch_and_explicit(volatile atomic_long __global *object,
4281+ long operand, memory_order order);
4282+long __ovld atomic_fetch_and_explicit(volatile atomic_long __local *object,
4283+ long operand, memory_order order);
4284+ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong __global *object,
4285+ ulong operand, memory_order order);
4286+ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong __local *object,
4287+ ulong operand, memory_order order);
4288+long __ovld atomic_fetch_min_explicit(volatile atomic_long __global *object,
4289+ long operand, memory_order order);
4290+long __ovld atomic_fetch_min_explicit(volatile atomic_long __local *object,
4291+ long operand, memory_order order);
4292+ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong __global *object,
4293+ ulong operand, memory_order order);
4294+ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong __local *object,
4295+ ulong operand, memory_order order);
4296+long __ovld atomic_fetch_max_explicit(volatile atomic_long __global *object,
4297+ long operand, memory_order order);
4298+long __ovld atomic_fetch_max_explicit(volatile atomic_long __local *object,
4299+ long operand, memory_order order);
4300+ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong __global *object,
4301+ ulong operand, memory_order order);
4302+ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong __local *object,
4303+ ulong operand, memory_order order);
4304+#endif // __opencl_c_atomic_scope_device
4305+long __ovld atomic_fetch_add_explicit(volatile atomic_long __global *object,
4306+ long operand, memory_order order,
4307+ memory_scope scope);
4308+long __ovld atomic_fetch_add_explicit(volatile atomic_long __local *object,
4309+ long operand, memory_order order,
4310+ memory_scope scope);
4311+ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong __global *object,
4312+ ulong operand, memory_order order,
4313+ memory_scope scope);
4314+ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong __local *object,
4315+ ulong operand, memory_order order,
4316+ memory_scope scope);
4317+long __ovld atomic_fetch_sub_explicit(volatile atomic_long __global *object,
4318+ long operand, memory_order order,
4319+ memory_scope scope);
4320+long __ovld atomic_fetch_sub_explicit(volatile atomic_long __local *object,
4321+ long operand, memory_order order,
4322+ memory_scope scope);
4323+ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong __global *object,
4324+ ulong operand, memory_order order,
4325+ memory_scope scope);
4326+ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong __local *object,
4327+ ulong operand, memory_order order,
4328+ memory_scope scope);
4329+long __ovld atomic_fetch_or_explicit(volatile atomic_long __global *object,
4330+ long operand, memory_order order,
4331+ memory_scope scope);
4332+long __ovld atomic_fetch_or_explicit(volatile atomic_long __local *object,
4333+ long operand, memory_order order,
4334+ memory_scope scope);
4335+ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong __global *object,
4336+ ulong operand, memory_order order,
4337+ memory_scope scope);
4338+ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong __local *object,
4339+ ulong operand, memory_order order,
4340+ memory_scope scope);
4341+long __ovld atomic_fetch_xor_explicit(volatile atomic_long __global *object,
4342+ long operand, memory_order order,
4343+ memory_scope scope);
4344+long __ovld atomic_fetch_xor_explicit(volatile atomic_long __local *object,
4345+ long operand, memory_order order,
4346+ memory_scope scope);
4347+ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong __global *object,
4348+ ulong operand, memory_order order,
4349+ memory_scope scope);
4350+ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong __local *object,
4351+ ulong operand, memory_order order,
4352+ memory_scope scope);
4353+long __ovld atomic_fetch_and_explicit(volatile atomic_long __global *object,
4354+ long operand, memory_order order,
4355+ memory_scope scope);
4356+long __ovld atomic_fetch_and_explicit(volatile atomic_long __local *object,
4357+ long operand, memory_order order,
4358+ memory_scope scope);
4359+ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong __global *object,
4360+ ulong operand, memory_order order,
4361+ memory_scope scope);
4362+ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong __local *object,
4363+ ulong operand, memory_order order,
4364+ memory_scope scope);
4365+long __ovld atomic_fetch_min_explicit(volatile atomic_long __global *object,
4366+ long operand, memory_order order,
4367+ memory_scope scope);
4368+long __ovld atomic_fetch_min_explicit(volatile atomic_long __local *object,
4369+ long operand, memory_order order,
4370+ memory_scope scope);
4371+ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong __global *object,
4372+ ulong operand, memory_order order,
4373+ memory_scope scope);
4374+ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong __local *object,
4375+ ulong operand, memory_order order,
4376+ memory_scope scope);
4377+long __ovld atomic_fetch_max_explicit(volatile atomic_long __global *object,
4378+ long operand, memory_order order,
4379+ memory_scope scope);
4380+long __ovld atomic_fetch_max_explicit(volatile atomic_long __local *object,
4381+ long operand, memory_order order,
4382+ memory_scope scope);
4383+ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong __global *object,
4384+ ulong operand, memory_order order,
4385+ memory_scope scope);
4386+ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong __local *object,
4387+ ulong operand, memory_order order,
4388+ memory_scope scope);
4389+#endif // defined(cl_khr_int64_base_atomics) &&
4390+ // defined(cl_khr_int64_extended_atomics)
4391+
4392+// OpenCL v2.0 s6.13.11.7.5:
4393+// add/sub: atomic type argument can be uintptr_t/intptr_t, value type argument
4394+// can be ptrdiff_t. or/xor/and/min/max: atomic type argument can be
4395+// intptr_t/uintptr_t, value type argument can be intptr_t/uintptr_t.
4396+
4397+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4398+#ifdef __opencl_c_atomic_scope_device
4399+uintptr_t __ovld
4400+atomic_fetch_add_explicit(volatile atomic_uintptr_t __global *object,
4401+ ptrdiff_t operand, memory_order order);
4402+uintptr_t __ovld
4403+atomic_fetch_add_explicit(volatile atomic_uintptr_t __local *object,
4404+ ptrdiff_t operand, memory_order order);
4405+uintptr_t __ovld
4406+atomic_fetch_sub_explicit(volatile atomic_uintptr_t __global *object,
4407+ ptrdiff_t operand, memory_order order);
4408+uintptr_t __ovld
4409+atomic_fetch_sub_explicit(volatile atomic_uintptr_t __local *object,
4410+ ptrdiff_t operand, memory_order order);
4411+uintptr_t __ovld
4412+atomic_fetch_or_explicit(volatile atomic_uintptr_t __global *object,
4413+ intptr_t operand, memory_order order);
4414+uintptr_t __ovld
4415+atomic_fetch_or_explicit(volatile atomic_uintptr_t __local *object,
4416+ intptr_t operand, memory_order order);
4417+uintptr_t __ovld
4418+atomic_fetch_xor_explicit(volatile atomic_uintptr_t __global *object,
4419+ intptr_t operand, memory_order order);
4420+uintptr_t __ovld
4421+atomic_fetch_xor_explicit(volatile atomic_uintptr_t __local *object,
4422+ intptr_t operand, memory_order order);
4423+uintptr_t __ovld
4424+atomic_fetch_and_explicit(volatile atomic_uintptr_t __global *object,
4425+ intptr_t operand, memory_order order);
4426+uintptr_t __ovld
4427+atomic_fetch_and_explicit(volatile atomic_uintptr_t __local *object,
4428+ intptr_t operand, memory_order order);
4429+uintptr_t __ovld
4430+atomic_fetch_min_explicit(volatile atomic_uintptr_t __global *object,
4431+ intptr_t opermax, memory_order minder);
4432+uintptr_t __ovld
4433+atomic_fetch_min_explicit(volatile atomic_uintptr_t __local *object,
4434+ intptr_t opermax, memory_order minder);
4435+uintptr_t __ovld
4436+atomic_fetch_max_explicit(volatile atomic_uintptr_t __global *object,
4437+ intptr_t opermax, memory_order minder);
4438+uintptr_t __ovld
4439+atomic_fetch_max_explicit(volatile atomic_uintptr_t __local *object,
4440+ intptr_t opermax, memory_order minder);
4441+intptr_t __ovld
4442+atomic_fetch_or_explicit(volatile atomic_intptr_t __global *object,
4443+ uintptr_t operand, memory_order order);
4444+intptr_t __ovld
4445+atomic_fetch_or_explicit(volatile atomic_intptr_t __local *object,
4446+ uintptr_t operand, memory_order order);
4447+intptr_t __ovld
4448+atomic_fetch_xor_explicit(volatile atomic_intptr_t __global *object,
4449+ uintptr_t operand, memory_order order);
4450+intptr_t __ovld
4451+atomic_fetch_xor_explicit(volatile atomic_intptr_t __local *object,
4452+ uintptr_t operand, memory_order order);
4453+intptr_t __ovld
4454+atomic_fetch_and_explicit(volatile atomic_intptr_t __global *object,
4455+ uintptr_t operand, memory_order order);
4456+intptr_t __ovld
4457+atomic_fetch_and_explicit(volatile atomic_intptr_t __local *object,
4458+ uintptr_t operand, memory_order order);
4459+intptr_t __ovld
4460+atomic_fetch_min_explicit(volatile atomic_intptr_t __global *object,
4461+ uintptr_t opermax, memory_order minder);
4462+intptr_t __ovld
4463+atomic_fetch_min_explicit(volatile atomic_intptr_t __local *object,
4464+ uintptr_t opermax, memory_order minder);
4465+intptr_t __ovld
4466+atomic_fetch_max_explicit(volatile atomic_intptr_t __global *object,
4467+ uintptr_t opermax, memory_order minder);
4468+intptr_t __ovld
4469+atomic_fetch_max_explicit(volatile atomic_intptr_t __local *object,
4470+ uintptr_t opermax, memory_order minder);
4471+#endif // __opencl_c_atomic_scope_device
4472+uintptr_t __ovld atomic_fetch_add_explicit(
4473+ volatile atomic_uintptr_t __global *object, ptrdiff_t operand,
4474+ memory_order order, memory_scope scope);
4475+uintptr_t __ovld atomic_fetch_add_explicit(
4476+ volatile atomic_uintptr_t __local *object, ptrdiff_t operand,
4477+ memory_order order, memory_scope scope);
4478+uintptr_t __ovld atomic_fetch_sub_explicit(
4479+ volatile atomic_uintptr_t __global *object, ptrdiff_t operand,
4480+ memory_order order, memory_scope scope);
4481+uintptr_t __ovld atomic_fetch_sub_explicit(
4482+ volatile atomic_uintptr_t __local *object, ptrdiff_t operand,
4483+ memory_order order, memory_scope scope);
4484+
4485+uintptr_t __ovld atomic_fetch_or_explicit(
4486+ volatile atomic_uintptr_t __global *object, intptr_t operand,
4487+ memory_order order, memory_scope scope);
4488+uintptr_t __ovld atomic_fetch_or_explicit(
4489+ volatile atomic_uintptr_t __local *object, intptr_t operand,
4490+ memory_order order, memory_scope scope);
4491+uintptr_t __ovld atomic_fetch_xor_explicit(
4492+ volatile atomic_uintptr_t __global *object, intptr_t operand,
4493+ memory_order order, memory_scope scope);
4494+uintptr_t __ovld atomic_fetch_xor_explicit(
4495+ volatile atomic_uintptr_t __local *object, intptr_t operand,
4496+ memory_order order, memory_scope scope);
4497+uintptr_t __ovld atomic_fetch_and_explicit(
4498+ volatile atomic_uintptr_t __global *object, intptr_t operand,
4499+ memory_order order, memory_scope scope);
4500+uintptr_t __ovld atomic_fetch_and_explicit(
4501+ volatile atomic_uintptr_t __local *object, intptr_t operand,
4502+ memory_order order, memory_scope scope);
4503+uintptr_t __ovld atomic_fetch_min_explicit(
4504+ volatile atomic_uintptr_t __global *object, intptr_t opermax,
4505+ memory_order minder, memory_scope scope);
4506+uintptr_t __ovld atomic_fetch_min_explicit(
4507+ volatile atomic_uintptr_t __local *object, intptr_t opermax,
4508+ memory_order minder, memory_scope scope);
4509+uintptr_t __ovld atomic_fetch_max_explicit(
4510+ volatile atomic_uintptr_t __global *object, intptr_t opermax,
4511+ memory_order minder, memory_scope scope);
4512+uintptr_t __ovld atomic_fetch_max_explicit(
4513+ volatile atomic_uintptr_t __local *object, intptr_t opermax,
4514+ memory_order minder, memory_scope scope);
4515+
4516+intptr_t __ovld atomic_fetch_or_explicit(
4517+ volatile atomic_intptr_t __global *object, uintptr_t operand,
4518+ memory_order order, memory_scope scope);
4519+intptr_t __ovld atomic_fetch_or_explicit(
4520+ volatile atomic_intptr_t __local *object, uintptr_t operand,
4521+ memory_order order, memory_scope scope);
4522+intptr_t __ovld atomic_fetch_xor_explicit(
4523+ volatile atomic_intptr_t __global *object, uintptr_t operand,
4524+ memory_order order, memory_scope scope);
4525+intptr_t __ovld atomic_fetch_xor_explicit(
4526+ volatile atomic_intptr_t __local *object, uintptr_t operand,
4527+ memory_order order, memory_scope scope);
4528+intptr_t __ovld atomic_fetch_and_explicit(
4529+ volatile atomic_intptr_t __global *object, uintptr_t operand,
4530+ memory_order order, memory_scope scope);
4531+intptr_t __ovld atomic_fetch_and_explicit(
4532+ volatile atomic_intptr_t __local *object, uintptr_t operand,
4533+ memory_order order, memory_scope scope);
4534+intptr_t __ovld atomic_fetch_min_explicit(
4535+ volatile atomic_intptr_t __global *object, uintptr_t opermax,
4536+ memory_order minder, memory_scope scope);
4537+intptr_t __ovld atomic_fetch_min_explicit(
4538+ volatile atomic_intptr_t __local *object, uintptr_t opermax,
4539+ memory_order minder, memory_scope scope);
4540+intptr_t __ovld atomic_fetch_max_explicit(
4541+ volatile atomic_intptr_t __global *object, uintptr_t opermax,
4542+ memory_order minder, memory_scope scope);
4543+intptr_t __ovld atomic_fetch_max_explicit(
4544+ volatile atomic_intptr_t __local *object, uintptr_t opermax,
4545+ memory_order minder, memory_scope scope);
4546+#endif // defined(cl_khr_int64_base_atomics) &&
4547+ // defined(cl_khr_int64_extended_atomics)
4548+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4549
4550 // atomic_store()
4551
4552+#if defined(__opencl_c_atomic_scope_device) && \
4553+ defined(__opencl_c_atomic_order_seq_cst)
4554+
4555+#ifdef __opencl_c_generic_address_space
4556 void __ovld atomic_store(volatile atomic_int *object, int desired);
4557-void __ovld atomic_store_explicit(volatile atomic_int *object, int desired, memory_order order);
4558-void __ovld atomic_store_explicit(volatile atomic_int *object, int desired, memory_order order, memory_scope scope);
4559 void __ovld atomic_store(volatile atomic_uint *object, uint desired);
4560-void __ovld atomic_store_explicit(volatile atomic_uint *object, uint desired, memory_order order);
4561-void __ovld atomic_store_explicit(volatile atomic_uint *object, uint desired, memory_order order, memory_scope scope);
4562 void __ovld atomic_store(volatile atomic_float *object, float desired);
4563-void __ovld atomic_store_explicit(volatile atomic_float *object, float desired, memory_order order);
4564-void __ovld atomic_store_explicit(volatile atomic_float *object, float desired, memory_order order, memory_scope scope);
4565 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4566-#ifdef cl_khr_fp64
4567+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4568 void __ovld atomic_store(volatile atomic_double *object, double desired);
4569-void __ovld atomic_store_explicit(volatile atomic_double *object, double desired, memory_order order);
4570-void __ovld atomic_store_explicit(volatile atomic_double *object, double desired, memory_order order, memory_scope scope);
4571-#endif //cl_khr_fp64
4572+#endif
4573 void __ovld atomic_store(volatile atomic_long *object, long desired);
4574-void __ovld atomic_store_explicit(volatile atomic_long *object, long desired, memory_order order);
4575-void __ovld atomic_store_explicit(volatile atomic_long *object, long desired, memory_order order, memory_scope scope);
4576 void __ovld atomic_store(volatile atomic_ulong *object, ulong desired);
4577-void __ovld atomic_store_explicit(volatile atomic_ulong *object, ulong desired, memory_order order);
4578-void __ovld atomic_store_explicit(volatile atomic_ulong *object, ulong desired, memory_order order, memory_scope scope);
4579+#endif // defined(cl_khr_int64_base_atomics) &&
4580+ // defined(cl_khr_int64_extended_atomics)
4581+#endif // __opencl_c_generic_address_space
4582+
4583+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4584+void __ovld atomic_store(volatile atomic_int __global *object, int desired);
4585+void __ovld atomic_store(volatile atomic_int __local *object, int desired);
4586+void __ovld atomic_store(volatile atomic_uint __global *object, uint desired);
4587+void __ovld atomic_store(volatile atomic_uint __local *object, uint desired);
4588+void __ovld atomic_store(volatile atomic_float __global *object, float desired);
4589+void __ovld atomic_store(volatile atomic_float __local *object, float desired);
4590+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4591+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4592+void __ovld atomic_store(volatile atomic_double __global *object,
4593+ double desired);
4594+void __ovld atomic_store(volatile atomic_double __local *object,
4595+ double desired);
4596 #endif
4597+void __ovld atomic_store(volatile atomic_long __global *object, long desired);
4598+void __ovld atomic_store(volatile atomic_long __local *object, long desired);
4599+void __ovld atomic_store(volatile atomic_ulong __global *object, ulong desired);
4600+void __ovld atomic_store(volatile atomic_ulong __local *object, ulong desired);
4601+#endif // defined(cl_khr_int64_base_atomics) &&
4602+ // defined(cl_khr_int64_extended_atomics)
4603+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4604+
4605+#endif // defined(__opencl_c_atomic_scope_device) &&
4606+ // defined(__opencl_c_atomic_order_seq_cst)
4607+
4608+#ifdef __opencl_c_generic_address_space
4609+#ifdef __opencl_c_atomic_scope_device
4610+void __ovld atomic_store_explicit(volatile atomic_int *object, int desired,
4611+ memory_order order);
4612+void __ovld atomic_store_explicit(volatile atomic_uint *object, uint desired,
4613+ memory_order order);
4614+void __ovld atomic_store_explicit(volatile atomic_float *object, float desired,
4615+ memory_order order);
4616+#endif // __opencl_c_atomic_scope_device
4617+void __ovld atomic_store_explicit(volatile atomic_int *object, int desired,
4618+ memory_order order, memory_scope scope);
4619+void __ovld atomic_store_explicit(volatile atomic_uint *object, uint desired,
4620+ memory_order order, memory_scope scope);
4621+void __ovld atomic_store_explicit(volatile atomic_float *object, float desired,
4622+ memory_order order, memory_scope scope);
4623+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4624+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4625+#ifdef __opencl_c_atomic_scope_device
4626+void __ovld atomic_store_explicit(volatile atomic_double *object,
4627+ double desired, memory_order order);
4628+#endif //__opencl_c_atomic_scope_device
4629+void __ovld atomic_store_explicit(volatile atomic_double *object,
4630+ double desired, memory_order order,
4631+ memory_scope scope);
4632+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4633+#ifdef __opencl_c_atomic_scope_device
4634+void __ovld atomic_store_explicit(volatile atomic_long *object, long desired,
4635+ memory_order order);
4636+void __ovld atomic_store_explicit(volatile atomic_ulong *object, ulong desired,
4637+ memory_order order);
4638+#endif //__opencl_c_atomic_scope_device
4639+void __ovld atomic_store_explicit(volatile atomic_long *object, long desired,
4640+ memory_order order, memory_scope scope);
4641+void __ovld atomic_store_explicit(volatile atomic_ulong *object, ulong desired,
4642+ memory_order order, memory_scope scope);
4643+#endif // defined(cl_khr_int64_base_atomics) &&
4644+ // defined(cl_khr_int64_extended_atomics)
4645+#endif // __opencl_c_generic_address_space
4646+
4647+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4648+#ifdef __opencl_c_atomic_scope_device
4649+void __ovld atomic_store_explicit(volatile atomic_int __global *object,
4650+ int desired, memory_order order);
4651+void __ovld atomic_store_explicit(volatile atomic_int __local *object,
4652+ int desired, memory_order order);
4653+void __ovld atomic_store_explicit(volatile atomic_uint __global *object,
4654+ uint desired, memory_order order);
4655+void __ovld atomic_store_explicit(volatile atomic_uint __local *object,
4656+ uint desired, memory_order order);
4657+void __ovld atomic_store_explicit(volatile atomic_float __global *object,
4658+ float desired, memory_order order);
4659+void __ovld atomic_store_explicit(volatile atomic_float __local *object,
4660+ float desired, memory_order order);
4661+#endif // __opencl_c_atomic_scope_device
4662+void __ovld atomic_store_explicit(volatile atomic_int __global *object,
4663+ int desired, memory_order order,
4664+ memory_scope scope);
4665+void __ovld atomic_store_explicit(volatile atomic_int __local *object,
4666+ int desired, memory_order order,
4667+ memory_scope scope);
4668+void __ovld atomic_store_explicit(volatile atomic_uint __global *object,
4669+ uint desired, memory_order order,
4670+ memory_scope scope);
4671+void __ovld atomic_store_explicit(volatile atomic_uint __local *object,
4672+ uint desired, memory_order order,
4673+ memory_scope scope);
4674+void __ovld atomic_store_explicit(volatile atomic_float __global *object,
4675+ float desired, memory_order order,
4676+ memory_scope scope);
4677+void __ovld atomic_store_explicit(volatile atomic_float __local *object,
4678+ float desired, memory_order order,
4679+ memory_scope scope);
4680+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4681+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4682+#ifdef __opencl_c_atomic_scope_device
4683+void __ovld atomic_store_explicit(volatile atomic_double __global *object,
4684+ double desired, memory_order order);
4685+void __ovld atomic_store_explicit(volatile atomic_double __local *object,
4686+ double desired, memory_order order);
4687+#endif //__opencl_c_atomic_scope_device
4688+void __ovld atomic_store_explicit(volatile atomic_double __global *object,
4689+ double desired, memory_order order,
4690+ memory_scope scope);
4691+void __ovld atomic_store_explicit(volatile atomic_double __local *object,
4692+ double desired, memory_order order,
4693+ memory_scope scope);
4694+#endif // cl_khr_fp64
4695+#ifdef __opencl_c_atomic_scope_device
4696+void __ovld atomic_store_explicit(volatile atomic_long __global *object,
4697+ long desired, memory_order order);
4698+void __ovld atomic_store_explicit(volatile atomic_long __local *object,
4699+ long desired, memory_order order);
4700+void __ovld atomic_store_explicit(volatile atomic_ulong __global *object,
4701+ ulong desired, memory_order order);
4702+void __ovld atomic_store_explicit(volatile atomic_ulong __local *object,
4703+ ulong desired, memory_order order);
4704+#endif // __opencl_c_atomic_scope_device
4705+void __ovld atomic_store_explicit(volatile atomic_long __global *object,
4706+ long desired, memory_order order,
4707+ memory_scope scope);
4708+void __ovld atomic_store_explicit(volatile atomic_long __local *object,
4709+ long desired, memory_order order,
4710+ memory_scope scope);
4711+void __ovld atomic_store_explicit(volatile atomic_ulong __global *object,
4712+ ulong desired, memory_order order,
4713+ memory_scope scope);
4714+void __ovld atomic_store_explicit(volatile atomic_ulong __local *object,
4715+ ulong desired, memory_order order,
4716+ memory_scope scope);
4717+#endif // defined(cl_khr_int64_base_atomics) &&
4718+ // defined(cl_khr_int64_extended_atomics)
4719+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4720
4721 // atomic_load()
4722-
4723+#ifdef __opencl_c_generic_address_space
4724+#if defined(__opencl_c_atomic_scope_device) && \
4725+ defined(__opencl_c_atomic_order_seq_cst)
4726 int __ovld atomic_load(volatile atomic_int *object);
4727-int __ovld atomic_load_explicit(volatile atomic_int *object, memory_order order);
4728-int __ovld atomic_load_explicit(volatile atomic_int *object, memory_order order, memory_scope scope);
4729 uint __ovld atomic_load(volatile atomic_uint *object);
4730-uint __ovld atomic_load_explicit(volatile atomic_uint *object, memory_order order);
4731-uint __ovld atomic_load_explicit(volatile atomic_uint *object, memory_order order, memory_scope scope);
4732 float __ovld atomic_load(volatile atomic_float *object);
4733-float __ovld atomic_load_explicit(volatile atomic_float *object, memory_order order);
4734-float __ovld atomic_load_explicit(volatile atomic_float *object, memory_order order, memory_scope scope);
4735 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4736-#ifdef cl_khr_fp64
4737+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4738 double __ovld atomic_load(volatile atomic_double *object);
4739-double __ovld atomic_load_explicit(volatile atomic_double *object, memory_order order);
4740-double __ovld atomic_load_explicit(volatile atomic_double *object, memory_order order, memory_scope scope);
4741-#endif //cl_khr_fp64
4742+#endif // cl_khr_fp64
4743 long __ovld atomic_load(volatile atomic_long *object);
4744-long __ovld atomic_load_explicit(volatile atomic_long *object, memory_order order);
4745-long __ovld atomic_load_explicit(volatile atomic_long *object, memory_order order, memory_scope scope);
4746 ulong __ovld atomic_load(volatile atomic_ulong *object);
4747-ulong __ovld atomic_load_explicit(volatile atomic_ulong *object, memory_order order);
4748-ulong __ovld atomic_load_explicit(volatile atomic_ulong *object, memory_order order, memory_scope scope);
4749-#endif
4750+#endif // defined(cl_khr_int64_base_atomics) &&
4751+ // defined(cl_khr_int64_extended_atomics)
4752+#endif // defined(__opencl_c_atomic_scope_device) &&
4753+ // defined(__opencl_c_atomic_order_seq_cst)
4754+#endif //__opencl_c_generic_address_space
4755+
4756+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4757+#if defined(__opencl_c_atomic_scope_device) && \
4758+ defined(__opencl_c_atomic_order_seq_cst)
4759+int __ovld atomic_load(volatile atomic_int __global *object);
4760+int __ovld atomic_load(volatile atomic_int __local *object);
4761+uint __ovld atomic_load(volatile atomic_uint __global *object);
4762+uint __ovld atomic_load(volatile atomic_uint __local *object);
4763+float __ovld atomic_load(volatile atomic_float __global *object);
4764+float __ovld atomic_load(volatile atomic_float __local *object);
4765+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4766+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4767+double __ovld atomic_load(volatile atomic_double __global *object);
4768+double __ovld atomic_load(volatile atomic_double __local *object);
4769+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4770+long __ovld atomic_load(volatile atomic_long __global *object);
4771+long __ovld atomic_load(volatile atomic_long __local *object);
4772+ulong __ovld atomic_load(volatile atomic_ulong __global *object);
4773+ulong __ovld atomic_load(volatile atomic_ulong __local *object);
4774+#endif // defined(cl_khr_int64_base_atomics) &&
4775+ // defined(cl_khr_int64_extended_atomics)
4776+#endif // defined(__opencl_c_atomic_scope_device) &&
4777+ // defined(__opencl_c_atomic_order_seq_cst)
4778+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4779+
4780+#ifdef __opencl_c_generic_address_space
4781+#ifdef __opencl_c_atomic_scope_device
4782+int __ovld atomic_load_explicit(volatile atomic_int *object,
4783+ memory_order order);
4784+uint __ovld atomic_load_explicit(volatile atomic_uint *object,
4785+ memory_order order);
4786+float __ovld atomic_load_explicit(volatile atomic_float *object,
4787+ memory_order order);
4788+#endif // __opencl_c_atomic_scope_device
4789+int __ovld atomic_load_explicit(volatile atomic_int *object, memory_order order,
4790+ memory_scope scope);
4791+uint __ovld atomic_load_explicit(volatile atomic_uint *object,
4792+ memory_order order, memory_scope scope);
4793+float __ovld atomic_load_explicit(volatile atomic_float *object,
4794+ memory_order order, memory_scope scope);
4795+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4796+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4797+#ifdef __opencl_c_atomic_scope_device
4798+double __ovld atomic_load_explicit(volatile atomic_double *object,
4799+ memory_order order);
4800+#endif // __opencl_c_atomic_scope_device
4801+double __ovld atomic_load_explicit(volatile atomic_double *object,
4802+ memory_order order, memory_scope scope);
4803+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4804+#ifdef __opencl_c_atomic_scope_device
4805+long __ovld atomic_load_explicit(volatile atomic_long *object,
4806+ memory_order order);
4807+ulong __ovld atomic_load_explicit(volatile atomic_ulong *object,
4808+ memory_order order);
4809+#endif //__opencl_c_atomic_scope_device
4810+long __ovld atomic_load_explicit(volatile atomic_long *object,
4811+ memory_order order, memory_scope scope);
4812+ulong __ovld atomic_load_explicit(volatile atomic_ulong *object,
4813+ memory_order order, memory_scope scope);
4814+#endif // defined(cl_khr_int64_base_atomics) &&
4815+ // defined(cl_khr_int64_extended_atomics)
4816+#endif // __opencl_c_generic_address_space
4817+
4818+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4819+#ifdef __opencl_c_atomic_scope_device
4820+int __ovld atomic_load_explicit(volatile atomic_int __global *object,
4821+ memory_order order);
4822+int __ovld atomic_load_explicit(volatile atomic_int __local *object,
4823+ memory_order order);
4824+uint __ovld atomic_load_explicit(volatile atomic_uint __global *object,
4825+ memory_order order);
4826+uint __ovld atomic_load_explicit(volatile atomic_uint __local *object,
4827+ memory_order order);
4828+float __ovld atomic_load_explicit(volatile atomic_float __global *object,
4829+ memory_order order);
4830+float __ovld atomic_load_explicit(volatile atomic_float __local *object,
4831+ memory_order order);
4832+#endif // __opencl_c_atomic_scope_device
4833+int __ovld atomic_load_explicit(volatile atomic_int __global *object,
4834+ memory_order order, memory_scope scope);
4835+int __ovld atomic_load_explicit(volatile atomic_int __local *object,
4836+ memory_order order, memory_scope scope);
4837+uint __ovld atomic_load_explicit(volatile atomic_uint __global *object,
4838+ memory_order order, memory_scope scope);
4839+uint __ovld atomic_load_explicit(volatile atomic_uint __local *object,
4840+ memory_order order, memory_scope scope);
4841+float __ovld atomic_load_explicit(volatile atomic_float __global *object,
4842+ memory_order order, memory_scope scope);
4843+float __ovld atomic_load_explicit(volatile atomic_float __local *object,
4844+ memory_order order, memory_scope scope);
4845+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4846+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4847+#ifdef __opencl_c_atomic_scope_device
4848+double __ovld atomic_load_explicit(volatile atomic_double __global *object,
4849+ memory_order order);
4850+double __ovld atomic_load_explicit(volatile atomic_double __local *object,
4851+ memory_order order);
4852+#endif // __opencl_c_atomic_scope_device
4853+double __ovld atomic_load_explicit(volatile atomic_double __global *object,
4854+ memory_order order, memory_scope scope);
4855+double __ovld atomic_load_explicit(volatile atomic_double __local *object,
4856+ memory_order order, memory_scope scope);
4857+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4858+#ifdef __opencl_c_atomic_scope_device
4859+long __ovld atomic_load_explicit(volatile atomic_long __global *object,
4860+ memory_order order);
4861+long __ovld atomic_load_explicit(volatile atomic_long __local *object,
4862+ memory_order order);
4863+ulong __ovld atomic_load_explicit(volatile atomic_ulong __global *object,
4864+ memory_order order);
4865+ulong __ovld atomic_load_explicit(volatile atomic_ulong __local *object,
4866+ memory_order order);
4867+#endif // __opencl_c_atomic_scope_device
4868+long __ovld atomic_load_explicit(volatile atomic_long __global *object,
4869+ memory_order order, memory_scope scope);
4870+long __ovld atomic_load_explicit(volatile atomic_long __local *object,
4871+ memory_order order, memory_scope scope);
4872+ulong __ovld atomic_load_explicit(volatile atomic_ulong __global *object,
4873+ memory_order order, memory_scope scope);
4874+ulong __ovld atomic_load_explicit(volatile atomic_ulong __local *object,
4875+ memory_order order, memory_scope scope);
4876+#endif // defined(cl_khr_int64_base_atomics) &&
4877+ // defined(cl_khr_int64_extended_atomics)
4878+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4879
4880 // atomic_exchange()
4881-
4882+#ifdef __opencl_c_generic_address_space
4883+#if defined(__opencl_c_atomic_scope_device) && \
4884+ defined(__opencl_c_atomic_order_seq_cst)
4885 int __ovld atomic_exchange(volatile atomic_int *object, int desired);
4886-int __ovld atomic_exchange_explicit(volatile atomic_int *object, int desired, memory_order order);
4887-int __ovld atomic_exchange_explicit(volatile atomic_int *object, int desired, memory_order order, memory_scope scope);
4888 uint __ovld atomic_exchange(volatile atomic_uint *object, uint desired);
4889-uint __ovld atomic_exchange_explicit(volatile atomic_uint *object, uint desired, memory_order order);
4890-uint __ovld atomic_exchange_explicit(volatile atomic_uint *object, uint desired, memory_order order, memory_scope scope);
4891 float __ovld atomic_exchange(volatile atomic_float *object, float desired);
4892-float __ovld atomic_exchange_explicit(volatile atomic_float *object, float desired, memory_order order);
4893-float __ovld atomic_exchange_explicit(volatile atomic_float *object, float desired, memory_order order, memory_scope scope);
4894 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4895-#ifdef cl_khr_fp64
4896+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4897 double __ovld atomic_exchange(volatile atomic_double *object, double desired);
4898-double __ovld atomic_exchange_explicit(volatile atomic_double *object, double desired, memory_order order);
4899-double __ovld atomic_exchange_explicit(volatile atomic_double *object, double desired, memory_order order, memory_scope scope);
4900-#endif //cl_khr_fp64
4901+#endif
4902 long __ovld atomic_exchange(volatile atomic_long *object, long desired);
4903-long __ovld atomic_exchange_explicit(volatile atomic_long *object, long desired, memory_order order);
4904-long __ovld atomic_exchange_explicit(volatile atomic_long *object, long desired, memory_order order, memory_scope scope);
4905 ulong __ovld atomic_exchange(volatile atomic_ulong *object, ulong desired);
4906-ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *object, ulong desired, memory_order order);
4907-ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *object, ulong desired, memory_order order, memory_scope scope);
4908+#endif // defined(cl_khr_int64_base_atomics) &&
4909+ // defined(cl_khr_int64_extended_atomics)
4910+#endif // defined(__opencl_c_atomic_scope_device) &&
4911+ // defined(__opencl_c_atomic_order_seq_cst)
4912+#endif // __opencl_c_generic_address_space
4913+
4914+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4915+#if defined(__opencl_c_atomic_scope_device) && \
4916+ defined(__opencl_c_atomic_order_seq_cst)
4917+int __ovld atomic_exchange(volatile atomic_int __global *object, int desired);
4918+int __ovld atomic_exchange(volatile atomic_int __local *object, int desired);
4919+uint __ovld atomic_exchange(volatile atomic_uint __global *object,
4920+ uint desired);
4921+uint __ovld atomic_exchange(volatile atomic_uint __local *object, uint desired);
4922+float __ovld atomic_exchange(volatile atomic_float __global *object,
4923+ float desired);
4924+float __ovld atomic_exchange(volatile atomic_float __local *object,
4925+ float desired);
4926+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4927+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4928+double __ovld atomic_exchange(volatile atomic_double __global *object,
4929+ double desired);
4930+double __ovld atomic_exchange(volatile atomic_double __local *object,
4931+ double desired);
4932 #endif
4933+long __ovld atomic_exchange(volatile atomic_long __global *object,
4934+ long desired);
4935+long __ovld atomic_exchange(volatile atomic_long __local *object, long desired);
4936+ulong __ovld atomic_exchange(volatile atomic_ulong __global *object,
4937+ ulong desired);
4938+ulong __ovld atomic_exchange(volatile atomic_ulong __local *object,
4939+ ulong desired);
4940+#endif // defined(cl_khr_int64_base_atomics) &&
4941+ // defined(cl_khr_int64_extended_atomics)
4942+#endif // defined(__opencl_c_atomic_scope_device) &&
4943+ // defined(__opencl_c_atomic_order_seq_cst)
4944+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4945+
4946+#ifdef __opencl_c_generic_address_space
4947+#ifdef __opencl_c_atomic_scope_device
4948+int __ovld atomic_exchange_explicit(volatile atomic_int *object, int desired,
4949+ memory_order order);
4950+uint __ovld atomic_exchange_explicit(volatile atomic_uint *object, uint desired,
4951+ memory_order order);
4952+float __ovld atomic_exchange_explicit(volatile atomic_float *object,
4953+ float desired, memory_order order);
4954+#endif // __opencl_c_atomic_scope_device
4955+int __ovld atomic_exchange_explicit(volatile atomic_int *object, int desired,
4956+ memory_order order, memory_scope scope);
4957+uint __ovld atomic_exchange_explicit(volatile atomic_uint *object, uint desired,
4958+ memory_order order, memory_scope scope);
4959+float __ovld atomic_exchange_explicit(volatile atomic_float *object,
4960+ float desired, memory_order order,
4961+ memory_scope scope);
4962+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4963+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4964+#ifdef __opencl_c_atomic_scope_device
4965+double __ovld atomic_exchange_explicit(volatile atomic_double *object,
4966+ double desired, memory_order order);
4967+#endif // __opencl_c_atomic_scope_device
4968+double __ovld atomic_exchange_explicit(volatile atomic_double *object,
4969+ double desired, memory_order order,
4970+ memory_scope scope);
4971+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4972+#ifdef __opencl_c_atomic_scope_device
4973+long __ovld atomic_exchange_explicit(volatile atomic_long *object, long desired,
4974+ memory_order order);
4975+ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *object,
4976+ ulong desired, memory_order order);
4977+#endif // __opencl_c_atomic_scope_device
4978+long __ovld atomic_exchange_explicit(volatile atomic_long *object, long desired,
4979+ memory_order order, memory_scope scope);
4980+ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *object,
4981+ ulong desired, memory_order order,
4982+ memory_scope scope);
4983+#endif // defined(cl_khr_int64_base_atomics) &&
4984+ // defined(cl_khr_int64_extended_atomics)
4985+#endif // __opencl_c_generic_address_space
4986+
4987+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4988+#ifdef __opencl_c_atomic_scope_device
4989+int __ovld atomic_exchange_explicit(volatile atomic_int __global *object,
4990+ int desired, memory_order order);
4991+int __ovld atomic_exchange_explicit(volatile atomic_int __local *object,
4992+ int desired, memory_order order);
4993+uint __ovld atomic_exchange_explicit(volatile atomic_uint __global *object,
4994+ uint desired, memory_order order);
4995+uint __ovld atomic_exchange_explicit(volatile atomic_uint __local *object,
4996+ uint desired, memory_order order);
4997+float __ovld atomic_exchange_explicit(volatile atomic_float __global *object,
4998+ float desired, memory_order order);
4999+float __ovld atomic_exchange_explicit(volatile atomic_float __local *object,
5000+ float desired, memory_order order);
5001+#endif // __opencl_c_atomic_scope_device
5002+int __ovld atomic_exchange_explicit(volatile atomic_int __global *object,
5003+ int desired, memory_order order,
5004+ memory_scope scope);
5005+int __ovld atomic_exchange_explicit(volatile atomic_int __local *object,
5006+ int desired, memory_order order,
5007+ memory_scope scope);
5008+uint __ovld atomic_exchange_explicit(volatile atomic_uint __global *object,
5009+ uint desired, memory_order order,
5010+ memory_scope scope);
5011+uint __ovld atomic_exchange_explicit(volatile atomic_uint __local *object,
5012+ uint desired, memory_order order,
5013+ memory_scope scope);
5014+float __ovld atomic_exchange_explicit(volatile atomic_float __global *object,
5015+ float desired, memory_order order,
5016+ memory_scope scope);
5017+float __ovld atomic_exchange_explicit(volatile atomic_float __local *object,
5018+ float desired, memory_order order,
5019+ memory_scope scope);
5020+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
5021+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
5022+#ifdef __opencl_c_atomic_scope_device
5023+double __ovld atomic_exchange_explicit(volatile atomic_double __global *object,
5024+ double desired, memory_order order);
5025+double __ovld atomic_exchange_explicit(volatile atomic_double __local *object,
5026+ double desired, memory_order order);
5027+#endif // __opencl_c_atomic_scope_device
5028+double __ovld atomic_exchange_explicit(volatile atomic_double __global *object,
5029+ double desired, memory_order order,
5030+ memory_scope scope);
5031+double __ovld atomic_exchange_explicit(volatile atomic_double __local *object,
5032+ double desired, memory_order order,
5033+ memory_scope scope);
5034+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
5035+#ifdef __opencl_c_atomic_scope_device
5036+long __ovld atomic_exchange_explicit(volatile atomic_long __global *object,
5037+ long desired, memory_order order);
5038+long __ovld atomic_exchange_explicit(volatile atomic_long __local *object,
5039+ long desired, memory_order order);
5040+ulong __ovld atomic_exchange_explicit(volatile atomic_ulong __global *object,
5041+ ulong desired, memory_order order);
5042+ulong __ovld atomic_exchange_explicit(volatile atomic_ulong __local *object,
5043+ ulong desired, memory_order order);
5044+#endif // __opencl_c_atomic_scope_device
5045+long __ovld atomic_exchange_explicit(volatile atomic_long __global *object,
5046+ long desired, memory_order order,
5047+ memory_scope scope);
5048+long __ovld atomic_exchange_explicit(volatile atomic_long __local *object,
5049+ long desired, memory_order order,
5050+ memory_scope scope);
5051+ulong __ovld atomic_exchange_explicit(volatile atomic_ulong __global *object,
5052+ ulong desired, memory_order order,
5053+ memory_scope scope);
5054+ulong __ovld atomic_exchange_explicit(volatile atomic_ulong __local *object,
5055+ ulong desired, memory_order order,
5056+ memory_scope scope);
5057+#endif // defined(cl_khr_int64_base_atomics) &&
5058+ // defined(cl_khr_int64_extended_atomics)
5059+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
5060
5061 // atomic_compare_exchange_strong() and atomic_compare_exchange_weak()
5062-
5063-bool __ovld atomic_compare_exchange_strong(volatile atomic_int *object, int *expected, int desired);
5064-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_int *object, int *expected,
5065- int desired, memory_order success, memory_order failure);
5066-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_int *object, int *expected,
5067- int desired, memory_order success, memory_order failure, memory_scope scope);
5068-bool __ovld atomic_compare_exchange_strong(volatile atomic_uint *object, uint *expected, uint desired);
5069-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_uint *object, uint *expected,
5070- uint desired, memory_order success, memory_order failure);
5071-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_uint *object, uint *expected,
5072- uint desired, memory_order success, memory_order failure, memory_scope scope);
5073-bool __ovld atomic_compare_exchange_weak(volatile atomic_int *object, int *expected, int desired);
5074-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_int *object, int *expected,
5075- int desired, memory_order success, memory_order failure);
5076-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_int *object, int *expected,
5077- int desired, memory_order success, memory_order failure, memory_scope scope);
5078-bool __ovld atomic_compare_exchange_weak(volatile atomic_uint *object, uint *expected, uint desired);
5079-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_uint *object, uint *expected,
5080- uint desired, memory_order success, memory_order failure);
5081-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_uint *object, uint *expected,
5082- uint desired, memory_order success, memory_order failure, memory_scope scope);
5083-bool __ovld atomic_compare_exchange_strong(volatile atomic_float *object, float *expected, float desired);
5084-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_float *object, float *expected,
5085- float desired, memory_order success, memory_order failure);
5086-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_float *object, float *expected,
5087- float desired, memory_order success, memory_order failure, memory_scope scope);
5088-bool __ovld atomic_compare_exchange_weak(volatile atomic_float *object, float *expected, float desired);
5089-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_float *object, float *expected,
5090- float desired, memory_order success, memory_order failure);
5091-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_float *object, float *expected,
5092- float desired, memory_order success, memory_order failure, memory_scope scope);
5093+#ifdef __opencl_c_generic_address_space
5094+#if defined(__opencl_c_atomic_scope_device) && \
5095+ defined(__opencl_c_atomic_order_seq_cst)
5096+bool __ovld atomic_compare_exchange_strong(volatile atomic_int *object,
5097+ int *expected, int desired);
5098+bool __ovld atomic_compare_exchange_strong(volatile atomic_uint *object,
5099+ uint *expected, uint desired);
5100+bool __ovld atomic_compare_exchange_weak(volatile atomic_int *object,
5101+ int *expected, int desired);
5102+bool __ovld atomic_compare_exchange_weak(volatile atomic_uint *object,
5103+ uint *expected, uint desired);
5104+bool __ovld atomic_compare_exchange_strong(volatile atomic_float *object,
5105+ float *expected, float desired);
5106+bool __ovld atomic_compare_exchange_weak(volatile atomic_float *object,
5107+ float *expected, float desired);
5108+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
5109+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
5110+bool __ovld atomic_compare_exchange_strong(volatile atomic_double *object,
5111+ double *expected, double desired);
5112+bool __ovld atomic_compare_exchange_weak(volatile atomic_double *object,
5113+ double *expected, double desired);
5114+#endif
5115+bool __ovld atomic_compare_exchange_strong(volatile atomic_long *object,
5116+ long *expected, long desired);
5117+bool __ovld atomic_compare_exchange_weak(volatile atomic_long *object,
5118+ long *expected, long desired);
5119+bool __ovld atomic_compare_exchange_strong(volatile atomic_ulong *object,
5120+ ulong *expected, ulong desired);
5121+bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong *object,
5122+ ulong *expected, ulong desired);
5123+#endif // defined(cl_khr_int64_base_atomics) &&
5124+ // defined(cl_khr_int64_extended_atomics)
5125+#endif // defined(__opencl_c_atomic_scope_device) &&
5126+ // defined(__opencl_c_atomic_order_seq_cst)
5127+#endif // __opencl_c_generic_address_space
5128+
5129+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
5130+#if defined(__opencl_c_atomic_scope_device) && \
5131+ defined(__opencl_c_atomic_order_seq_cst)
5132+bool __ovld atomic_compare_exchange_strong(volatile atomic_int __global *object,
5133+ int __global *expected, int desired);
5134+bool __ovld atomic_compare_exchange_strong(volatile atomic_int __local *object,
5135+ int __global *expected, int desired);
5136+bool __ovld atomic_compare_exchange_strong(volatile atomic_int __global *object,
5137+ int __local *expected, int desired);
5138+bool __ovld atomic_compare_exchange_strong(volatile atomic_int __local *object,
5139+ int __local *expected, int desired);
5140+bool __ovld atomic_compare_exchange_strong(volatile atomic_int __global *object,
5141+ int __private *expected,
5142+ int desired);
5143+bool __ovld atomic_compare_exchange_strong(volatile atomic_int __local *object,
5144+ int __private *expected,
5145+ int desired);
5146+bool __ovld
5147+atomic_compare_exchange_strong(volatile atomic_uint __global *object,
5148+ uint __global *expected, uint desired);
5149+bool __ovld atomic_compare_exchange_strong(volatile atomic_uint __local *object,
5150+ uint __global *expected,
5151+ uint desired);
5152+bool __ovld
5153+atomic_compare_exchange_strong(volatile atomic_uint __global *object,
5154+ uint __local *expected, uint desired);
5155+bool __ovld atomic_compare_exchange_strong(volatile atomic_uint __local *object,
5156+ uint __local *expected,
5157+ uint desired);
5158+bool __ovld
5159+atomic_compare_exchange_strong(volatile atomic_uint __global *object,
5160+ uint __private *expected, uint desired);
5161+bool __ovld atomic_compare_exchange_strong(volatile atomic_uint __local *object,
5162+ uint __private *expected,
5163+ uint desired);
5164+bool __ovld atomic_compare_exchange_weak(volatile atomic_int __global *object,
5165+ int __global *expected, int desired);
5166+bool __ovld atomic_compare_exchange_weak(volatile atomic_int __local *object,
5167+ int __global *expected, int desired);
5168+bool __ovld atomic_compare_exchange_weak(volatile atomic_int __global *object,
5169+ int __local *expected, int desired);
5170+bool __ovld atomic_compare_exchange_weak(volatile atomic_int __local *object,
5171+ int __local *expected, int desired);
5172+bool __ovld atomic_compare_exchange_weak(volatile atomic_int __global *object,
5173+ int __private *expected, int desired);
5174+bool __ovld atomic_compare_exchange_weak(volatile atomic_int __local *object,
5175+ int __private *expected, int desired);
5176+bool __ovld atomic_compare_exchange_weak(volatile atomic_uint __global *object,
5177+ uint __global *expected, uint desired);
5178+bool __ovld atomic_compare_exchange_weak(volatile atomic_uint __local *object,
5179+ uint __global *expected, uint desired);
5180+bool __ovld atomic_compare_exchange_weak(volatile atomic_uint __global *object,
5181+ uint __local *expected, uint desired);
5182+bool __ovld atomic_compare_exchange_weak(volatile atomic_uint __local *object,
5183+ uint __local *expected, uint desired);
5184+bool __ovld atomic_compare_exchange_weak(volatile atomic_uint __global *object,
5185+ uint __private *expected,
5186+ uint desired);
5187+bool __ovld atomic_compare_exchange_weak(volatile atomic_uint __local *object,
5188+ uint __private *expected,
5189+ uint desired);
5190+bool __ovld
5191+atomic_compare_exchange_strong(volatile atomic_float __global *object,
5192+ float __global *expected, float desired);
5193+bool __ovld
5194+atomic_compare_exchange_strong(volatile atomic_float __local *object,
5195+ float __global *expected, float desired);
5196+bool __ovld
5197+atomic_compare_exchange_strong(volatile atomic_float __global *object,
5198+ float __local *expected, float desired);
5199+bool __ovld
5200+atomic_compare_exchange_strong(volatile atomic_float __local *object,
5201+ float __local *expected, float desired);
5202+bool __ovld
5203+atomic_compare_exchange_strong(volatile atomic_float __global *object,
5204+ float __private *expected, float desired);
5205+bool __ovld
5206+atomic_compare_exchange_strong(volatile atomic_float __local *object,
5207+ float __private *expected, float desired);
5208+bool __ovld atomic_compare_exchange_weak(volatile atomic_float __global *object,
5209+ float __global *expected,
5210+ float desired);
5211+bool __ovld atomic_compare_exchange_weak(volatile atomic_float __local *object,
5212+ float __global *expected,
5213+ float desired);
5214+bool __ovld atomic_compare_exchange_weak(volatile atomic_float __global *object,
5215+ float __local *expected,
5216+ float desired);
5217+bool __ovld atomic_compare_exchange_weak(volatile atomic_float __local *object,
5218+ float __local *expected,
5219+ float desired);
5220+bool __ovld atomic_compare_exchange_weak(volatile atomic_float __global *object,
5221+ float __private *expected,
5222+ float desired);
5223+bool __ovld atomic_compare_exchange_weak(volatile atomic_float __local *object,
5224+ float __private *expected,
5225+ float desired);
5226 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
5227-#ifdef cl_khr_fp64
5228-bool __ovld atomic_compare_exchange_strong(volatile atomic_double *object, double *expected, double desired);
5229-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_double *object, double *expected,
5230- double desired, memory_order success, memory_order failure);
5231-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_double *object, double *expected,
5232- double desired, memory_order success, memory_order failure, memory_scope scope);
5233-bool __ovld atomic_compare_exchange_weak(volatile atomic_double *object, double *expected, double desired);
5234-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_double *object, double *expected,
5235- double desired, memory_order success, memory_order failure);
5236-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_double *object, double *expected,
5237- double desired, memory_order success, memory_order failure, memory_scope scope);
5238-#endif //cl_khr_fp64
5239-bool __ovld atomic_compare_exchange_strong(volatile atomic_long *object, long *expected, long desired);
5240-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_long *object, long *expected,
5241- long desired, memory_order success, memory_order failure);
5242-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_long *object, long *expected,
5243- long desired, memory_order success, memory_order failure, memory_scope scope);
5244-bool __ovld atomic_compare_exchange_weak(volatile atomic_long *object, long *expected, long desired);
5245-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_long *object, long *expected,
5246- long desired, memory_order success, memory_order failure);
5247-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_long *object, long *expected,
5248- long desired, memory_order success, memory_order failure, memory_scope scope);
5249-bool __ovld atomic_compare_exchange_strong(volatile atomic_ulong *object, ulong *expected, ulong desired);
5250-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_ulong *object, ulong *expected,
5251- ulong desired, memory_order success, memory_order failure);
5252-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_ulong *object, ulong *expected,
5253- ulong desired, memory_order success, memory_order failure, memory_scope scope);
5254-bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong *object, ulong *expected, ulong desired);
5255-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_ulong *object, ulong *expected,
5256- ulong desired, memory_order success, memory_order failure);
5257-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_ulong *object, ulong *expected,
5258- ulong desired, memory_order success, memory_order failure, memory_scope scope);
5259+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
5260+bool __ovld
5261+atomic_compare_exchange_strong(volatile atomic_double __global *object,
5262+ double __global *expected, double desired);
5263+bool __ovld
5264+atomic_compare_exchange_strong(volatile atomic_double __local *object,
5265+ double __global *expected, double desired);
5266+bool __ovld
5267+atomic_compare_exchange_strong(volatile atomic_double __global *object,
5268+ double __local *expected, double desired);
5269+bool __ovld
5270+atomic_compare_exchange_strong(volatile atomic_double __local *object,
5271+ double __local *expected, double desired);
5272+bool __ovld
5273+atomic_compare_exchange_strong(volatile atomic_double __global *object,
5274+ double __private *expected, double desired);
5275+bool __ovld
5276+atomic_compare_exchange_strong(volatile atomic_double __local *object,
5277+ double __private *expected, double desired);
5278+bool __ovld
5279+atomic_compare_exchange_weak(volatile atomic_double __global *object,
5280+ double __global *expected, double desired);
5281+bool __ovld atomic_compare_exchange_weak(volatile atomic_double __local *object,
5282+ double __global *expected,
5283+ double desired);
5284+bool __ovld
5285+atomic_compare_exchange_weak(volatile atomic_double __global *object,
5286+ double __local *expected, double desired);
5287+bool __ovld atomic_compare_exchange_weak(volatile atomic_double __local *object,
5288+ double __local *expected,
5289+ double desired);
5290+bool __ovld
5291+atomic_compare_exchange_weak(volatile atomic_double __global *object,
5292+ double __private *expected, double desired);
5293+bool __ovld atomic_compare_exchange_weak(volatile atomic_double __local *object,
5294+ double __private *expected,
5295+ double desired);
5296 #endif
5297+bool __ovld
5298+atomic_compare_exchange_strong(volatile atomic_long __global *object,
5299+ long __global *expected, long desired);
5300+bool __ovld atomic_compare_exchange_strong(volatile atomic_long __local *object,
5301+ long __global *expected,
5302+ long desired);
5303+bool __ovld
5304+atomic_compare_exchange_strong(volatile atomic_long __global *object,
5305+ long __local *expected, long desired);
5306+bool __ovld atomic_compare_exchange_strong(volatile atomic_long __local *object,
5307+ long __local *expected,
5308+ long desired);
5309+bool __ovld
5310+atomic_compare_exchange_strong(volatile atomic_long __global *object,
5311+ long __private *expected, long desired);
5312+bool __ovld atomic_compare_exchange_strong(volatile atomic_long __local *object,
5313+ long __private *expected,
5314+ long desired);
5315+bool __ovld atomic_compare_exchange_weak(volatile atomic_long __global *object,
5316+ long __global *expected, long desired);
5317+bool __ovld atomic_compare_exchange_weak(volatile atomic_long __local *object,
5318+ long __global *expected, long desired);
5319+bool __ovld atomic_compare_exchange_weak(volatile atomic_long __global *object,
5320+ long __local *expected, long desired);
5321+bool __ovld atomic_compare_exchange_weak(volatile atomic_long __local *object,
5322+ long __local *expected, long desired);
5323+bool __ovld atomic_compare_exchange_weak(volatile atomic_long __global *object,
5324+ long __private *expected,
5325+ long desired);
5326+bool __ovld atomic_compare_exchange_weak(volatile atomic_long __local *object,
5327+ long __private *expected,
5328+ long desired);
5329+bool __ovld
5330+atomic_compare_exchange_strong(volatile atomic_ulong __global *object,
5331+ ulong __global *expected, ulong desired);
5332+bool __ovld
5333+atomic_compare_exchange_strong(volatile atomic_ulong __local *object,
5334+ ulong __global *expected, ulong desired);
5335+bool __ovld
5336+atomic_compare_exchange_strong(volatile atomic_ulong __global *object,
5337+ ulong __local *expected, ulong desired);
5338+bool __ovld
5339+atomic_compare_exchange_strong(volatile atomic_ulong __local *object,
5340+ ulong __local *expected, ulong desired);
5341+bool __ovld
5342+atomic_compare_exchange_strong(volatile atomic_ulong __global *object,
5343+ ulong __private *expected, ulong desired);
5344+bool __ovld
5345+atomic_compare_exchange_strong(volatile atomic_ulong __local *object,
5346+ ulong __private *expected, ulong desired);
5347+bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong __global *object,
5348+ ulong __global *expected,
5349+ ulong desired);
5350+bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong __local *object,
5351+ ulong __global *expected,
5352+ ulong desired);
5353+bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong __global *object,
5354+ ulong __local *expected,
5355+ ulong desired);
5356+bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong __local *object,
5357+ ulong __local *expected,
5358+ ulong desired);
5359+bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong __global *object,
5360+ ulong __private *expected,
5361+ ulong desired);
5362+bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong __local *object,
5363+ ulong __private *expected,
5364+ ulong desired);
5365+#endif // defined(cl_khr_int64_base_atomics) &&
5366+ // defined(cl_khr_int64_extended_atomics)
5367+#endif // defined(__opencl_c_atomic_scope_device) &&
5368+ // defined(__opencl_c_atomic_order_seq_cst)
5369+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
5370+
5371+#ifdef __opencl_c_generic_address_space
5372+#ifdef __opencl_c_atomic_scope_device
5373+bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_int *object,
5374+ int *expected, int desired,
5375+ memory_order success,
5376+ memory_order failure);
5377+bool __ovld atomic_compare_exchange_strong_explicit(
5378+ volatile atomic_uint *object, uint *expected, uint desired,
5379+ memory_order success, memory_order failure);
5380+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_int *object,
5381+ int *expected, int desired,
5382+ memory_order success,
5383+ memory_order failure);
5384+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_uint *object,
5385+ uint *expected, uint desired,
5386+ memory_order success,
5387+ memory_order failure);
5388+bool __ovld atomic_compare_exchange_strong_explicit(
5389+ volatile atomic_float *object, float *expected, float desired,
5390+ memory_order success, memory_order failure);
5391+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_float *object,
5392+ float *expected,
5393+ float desired,
5394+ memory_order success,
5395+ memory_order failure);
5396+#endif // __opencl_c_atomic_scope_device
5397+bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_int *object,
5398+ int *expected, int desired,
5399+ memory_order success,
5400+ memory_order failure,
5401+ memory_scope scope);
5402+bool __ovld atomic_compare_exchange_strong_explicit(
5403+ volatile atomic_uint *object, uint *expected, uint desired,
5404+ memory_order success, memory_order failure, memory_scope scope);
5405+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_int *object,
5406+ int *expected, int desired,
5407+ memory_order success,
5408+ memory_order failure,
5409+ memory_scope scope);
5410+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_uint *object,
5411+ uint *expected, uint desired,
5412+ memory_order success,
5413+ memory_order failure,
5414+ memory_scope scope);
5415+bool __ovld atomic_compare_exchange_strong_explicit(
5416+ volatile atomic_float *object, float *expected, float desired,
5417+ memory_order success, memory_order failure, memory_scope scope);
5418+bool __ovld atomic_compare_exchange_weak_explicit(
5419+ volatile atomic_float *object, float *expected, float desired,
5420+ memory_order success, memory_order failure, memory_scope scope);
5421+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
5422+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
5423+#ifdef __opencl_c_atomic_scope_device
5424+bool __ovld atomic_compare_exchange_strong_explicit(
5425+ volatile atomic_double *object, double *expected, double desired,
5426+ memory_order success, memory_order failure);
5427+bool __ovld atomic_compare_exchange_weak_explicit(
5428+ volatile atomic_double *object, double *expected, double desired,
5429+ memory_order success, memory_order failure);
5430+#endif // __opencl_c_atomic_scope_device
5431+bool __ovld atomic_compare_exchange_strong_explicit(
5432+ volatile atomic_double *object, double *expected, double desired,
5433+ memory_order success, memory_order failure, memory_scope scope);
5434+bool __ovld atomic_compare_exchange_weak_explicit(
5435+ volatile atomic_double *object, double *expected, double desired,
5436+ memory_order success, memory_order failure, memory_scope scope);
5437+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
5438+#ifdef __opencl_c_atomic_scope_device
5439+bool __ovld atomic_compare_exchange_strong_explicit(
5440+ volatile atomic_long *object, long *expected, long desired,
5441+ memory_order success, memory_order failure);
5442+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_long *object,
5443+ long *expected, long desired,
5444+ memory_order success,
5445+ memory_order failure);
5446+bool __ovld atomic_compare_exchange_strong_explicit(
5447+ volatile atomic_ulong *object, ulong *expected, ulong desired,
5448+ memory_order success, memory_order failure);
5449+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_ulong *object,
5450+ ulong *expected,
5451+ ulong desired,
5452+ memory_order success,
5453+ memory_order failure);
5454+#endif // __opencl_c_atomic_scope_device
5455+bool __ovld atomic_compare_exchange_strong_explicit(
5456+ volatile atomic_long *object, long *expected, long desired,
5457+ memory_order success, memory_order failure, memory_scope scope);
5458+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_long *object,
5459+ long *expected, long desired,
5460+ memory_order success,
5461+ memory_order failure,
5462+ memory_scope scope);
5463+bool __ovld atomic_compare_exchange_strong_explicit(
5464+ volatile atomic_ulong *object, ulong *expected, ulong desired,
5465+ memory_order success, memory_order failure, memory_scope scope);
5466+bool __ovld atomic_compare_exchange_weak_explicit(
5467+ volatile atomic_ulong *object, ulong *expected, ulong desired,
5468+ memory_order success, memory_order failure, memory_scope scope);
5469+#endif // defined(cl_khr_int64_base_atomics) &&
5470+ // defined(cl_khr_int64_extended_atomics)
5471+#endif // __opencl_c_generic_address_space
5472+
5473+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
5474+#ifdef __opencl_c_atomic_scope_device
5475+bool __ovld atomic_compare_exchange_strong_explicit(
5476+ volatile atomic_int __global *object, int __global *expected, int desired,
5477+ memory_order success, memory_order failure);
5478+bool __ovld atomic_compare_exchange_strong_explicit(
5479+ volatile atomic_int __local *object, int __global *expected, int desired,
5480+ memory_order success, memory_order failure);
5481+bool __ovld atomic_compare_exchange_strong_explicit(
5482+ volatile atomic_int __global *object, int __local *expected, int desired,
5483+ memory_order success, memory_order failure);
5484+bool __ovld atomic_compare_exchange_strong_explicit(
5485+ volatile atomic_int __local *object, int __local *expected, int desired,
5486+ memory_order success, memory_order failure);
5487+bool __ovld atomic_compare_exchange_strong_explicit(
5488+ volatile atomic_int __global *object, int __private *expected, int desired,
5489+ memory_order success, memory_order failure);
5490+bool __ovld atomic_compare_exchange_strong_explicit(
5491+ volatile atomic_int __local *object, int __private *expected, int desired,
5492+ memory_order success, memory_order failure);
5493+bool __ovld atomic_compare_exchange_strong_explicit(
5494+ volatile atomic_uint __global *object, uint __global *expected,
5495+ uint desired, memory_order success, memory_order failure);
5496+bool __ovld atomic_compare_exchange_strong_explicit(
5497+ volatile atomic_uint __local *object, uint __global *expected, uint desired,
5498+ memory_order success, memory_order failure);
5499+bool __ovld atomic_compare_exchange_strong_explicit(
5500+ volatile atomic_uint __global *object, uint __local *expected, uint desired,
5501+ memory_order success, memory_order failure);
5502+bool __ovld atomic_compare_exchange_strong_explicit(
5503+ volatile atomic_uint __local *object, uint __local *expected, uint desired,
5504+ memory_order success, memory_order failure);
5505+bool __ovld atomic_compare_exchange_strong_explicit(
5506+ volatile atomic_uint __global *object, uint __private *expected,
5507+ uint desired, memory_order success, memory_order failure);
5508+bool __ovld atomic_compare_exchange_strong_explicit(
5509+ volatile atomic_uint __local *object, uint __private *expected,
5510+ uint desired, memory_order success, memory_order failure);
5511+bool __ovld atomic_compare_exchange_weak_explicit(
5512+ volatile atomic_int __global *object, int __global *expected, int desired,
5513+ memory_order success, memory_order failure);
5514+bool __ovld atomic_compare_exchange_weak_explicit(
5515+ volatile atomic_int __local *object, int __global *expected, int desired,
5516+ memory_order success, memory_order failure);
5517+bool __ovld atomic_compare_exchange_weak_explicit(
5518+ volatile atomic_int __global *object, int __local *expected, int desired,
5519+ memory_order success, memory_order failure);
5520+bool __ovld atomic_compare_exchange_weak_explicit(
5521+ volatile atomic_int __local *object, int __local *expected, int desired,
5522+ memory_order success, memory_order failure);
5523+bool __ovld atomic_compare_exchange_weak_explicit(
5524+ volatile atomic_int __global *object, int __private *expected, int desired,
5525+ memory_order success, memory_order failure);
5526+bool __ovld atomic_compare_exchange_weak_explicit(
5527+ volatile atomic_int __local *object, int __private *expected, int desired,
5528+ memory_order success, memory_order failure);
5529+bool __ovld atomic_compare_exchange_weak_explicit(
5530+ volatile atomic_uint __global *object, uint __global *expected,
5531+ uint desired, memory_order success, memory_order failure);
5532+bool __ovld atomic_compare_exchange_weak_explicit(
5533+ volatile atomic_uint __local *object, uint __global *expected, uint desired,
5534+ memory_order success, memory_order failure);
5535+bool __ovld atomic_compare_exchange_weak_explicit(
5536+ volatile atomic_uint __global *object, uint __local *expected, uint desired,
5537+ memory_order success, memory_order failure);
5538+bool __ovld atomic_compare_exchange_weak_explicit(
5539+ volatile atomic_uint __local *object, uint __local *expected, uint desired,
5540+ memory_order success, memory_order failure);
5541+bool __ovld atomic_compare_exchange_weak_explicit(
5542+ volatile atomic_uint __global *object, uint __private *expected,
5543+ uint desired, memory_order success, memory_order failure);
5544+bool __ovld atomic_compare_exchange_weak_explicit(
5545+ volatile atomic_uint __local *object, uint __private *expected,
5546+ uint desired, memory_order success, memory_order failure);
5547+bool __ovld atomic_compare_exchange_strong_explicit(
5548+ volatile atomic_float __global *object, float __global *expected,
5549+ float desired, memory_order success, memory_order failure);
5550+bool __ovld atomic_compare_exchange_strong_explicit(
5551+ volatile atomic_float __local *object, float __global *expected,
5552+ float desired, memory_order success, memory_order failure);
5553+bool __ovld atomic_compare_exchange_strong_explicit(
5554+ volatile atomic_float __global *object, float __local *expected,
5555+ float desired, memory_order success, memory_order failure);
5556+bool __ovld atomic_compare_exchange_strong_explicit(
5557+ volatile atomic_float __local *object, float __local *expected,
5558+ float desired, memory_order success, memory_order failure);
5559+bool __ovld atomic_compare_exchange_strong_explicit(
5560+ volatile atomic_float __global *object, float __private *expected,
5561+ float desired, memory_order success, memory_order failure);
5562+bool __ovld atomic_compare_exchange_strong_explicit(
5563+ volatile atomic_float __local *object, float __private *expected,
5564+ float desired, memory_order success, memory_order failure);
5565+bool __ovld atomic_compare_exchange_weak_explicit(
5566+ volatile atomic_float __global *object, float __global *expected,
5567+ float desired, memory_order success, memory_order failure);
5568+bool __ovld atomic_compare_exchange_weak_explicit(
5569+ volatile atomic_float __local *object, float __global *expected,
5570+ float desired, memory_order success, memory_order failure);
5571+bool __ovld atomic_compare_exchange_weak_explicit(
5572+ volatile atomic_float __global *object, float __local *expected,
5573+ float desired, memory_order success, memory_order failure);
5574+bool __ovld atomic_compare_exchange_weak_explicit(
5575+ volatile atomic_float __local *object, float __local *expected,
5576+ float desired, memory_order success, memory_order failure);
5577+bool __ovld atomic_compare_exchange_weak_explicit(
5578+ volatile atomic_float __global *object, float __private *expected,
5579+ float desired, memory_order success, memory_order failure);
5580+bool __ovld atomic_compare_exchange_weak_explicit(
5581+ volatile atomic_float __local *object, float __private *expected,
5582+ float desired, memory_order success, memory_order failure);
5583+#endif // __opencl_c_atomic_scope_device
5584+bool __ovld atomic_compare_exchange_strong_explicit(
5585+ volatile atomic_int __global *object, int __global *expected, int desired,
5586+ memory_order success, memory_order failure, memory_scope scope);
5587+bool __ovld atomic_compare_exchange_strong_explicit(
5588+ volatile atomic_int __local *object, int __global *expected, int desired,
5589+ memory_order success, memory_order failure, memory_scope scope);
5590+bool __ovld atomic_compare_exchange_strong_explicit(
5591+ volatile atomic_int __global *object, int __local *expected, int desired,
5592+ memory_order success, memory_order failure, memory_scope scope);
5593+bool __ovld atomic_compare_exchange_strong_explicit(
5594+ volatile atomic_int __local *object, int __local *expected, int desired,
5595+ memory_order success, memory_order failure, memory_scope scope);
5596+bool __ovld atomic_compare_exchange_strong_explicit(
5597+ volatile atomic_int __global *object, int __private *expected, int desired,
5598+ memory_order success, memory_order failure, memory_scope scope);
5599+bool __ovld atomic_compare_exchange_strong_explicit(
5600+ volatile atomic_int __local *object, int __private *expected, int desired,
5601+ memory_order success, memory_order failure, memory_scope scope);
5602+bool __ovld atomic_compare_exchange_strong_explicit(
5603+ volatile atomic_uint __global *object, uint __global *expected,
5604+ uint desired, memory_order success, memory_order failure,
5605+ memory_scope scope);
5606+bool __ovld atomic_compare_exchange_strong_explicit(
5607+ volatile atomic_uint __local *object, uint __global *expected, uint desired,
5608+ memory_order success, memory_order failure, memory_scope scope);
5609+bool __ovld atomic_compare_exchange_strong_explicit(
5610+ volatile atomic_uint __global *object, uint __local *expected, uint desired,
5611+ memory_order success, memory_order failure, memory_scope scope);
5612+bool __ovld atomic_compare_exchange_strong_explicit(
5613+ volatile atomic_uint __local *object, uint __local *expected, uint desired,
5614+ memory_order success, memory_order failure, memory_scope scope);
5615+bool __ovld atomic_compare_exchange_strong_explicit(
5616+ volatile atomic_uint __global *object, uint __private *expected,
5617+ uint desired, memory_order success, memory_order failure,
5618+ memory_scope scope);
5619+bool __ovld atomic_compare_exchange_strong_explicit(
5620+ volatile atomic_uint __local *object, uint __private *expected,
5621+ uint desired, memory_order success, memory_order failure,
5622+ memory_scope scope);
5623+bool __ovld atomic_compare_exchange_weak_explicit(
5624+ volatile atomic_int __global *object, int __global *expected, int desired,
5625+ memory_order success, memory_order failure, memory_scope scope);
5626+bool __ovld atomic_compare_exchange_weak_explicit(
5627+ volatile atomic_int __local *object, int __global *expected, int desired,
5628+ memory_order success, memory_order failure, memory_scope scope);
5629+bool __ovld atomic_compare_exchange_weak_explicit(
5630+ volatile atomic_int __global *object, int __local *expected, int desired,
5631+ memory_order success, memory_order failure, memory_scope scope);
5632+bool __ovld atomic_compare_exchange_weak_explicit(
5633+ volatile atomic_int __local *object, int __local *expected, int desired,
5634+ memory_order success, memory_order failure, memory_scope scope);
5635+bool __ovld atomic_compare_exchange_weak_explicit(
5636+ volatile atomic_int __global *object, int __private *expected, int desired,
5637+ memory_order success, memory_order failure, memory_scope scope);
5638+bool __ovld atomic_compare_exchange_weak_explicit(
5639+ volatile atomic_int __local *object, int __private *expected, int desired,
5640+ memory_order success, memory_order failure, memory_scope scope);
5641+bool __ovld atomic_compare_exchange_weak_explicit(
5642+ volatile atomic_uint __global *object, uint __global *expected,
5643+ uint desired, memory_order success, memory_order failure,
5644+ memory_scope scope);
5645+bool __ovld atomic_compare_exchange_weak_explicit(
5646+ volatile atomic_uint __local *object, uint __global *expected, uint desired,
5647+ memory_order success, memory_order failure, memory_scope scope);
5648+bool __ovld atomic_compare_exchange_weak_explicit(
5649+ volatile atomic_uint __global *object, uint __local *expected, uint desired,
5650+ memory_order success, memory_order failure, memory_scope scope);
5651+bool __ovld atomic_compare_exchange_weak_explicit(
5652+ volatile atomic_uint __local *object, uint __local *expected, uint desired,
5653+ memory_order success, memory_order failure, memory_scope scope);
5654+bool __ovld atomic_compare_exchange_weak_explicit(
5655+ volatile atomic_uint __global *object, uint __private *expected,
5656+ uint desired, memory_order success, memory_order failure,
5657+ memory_scope scope);
5658+bool __ovld atomic_compare_exchange_weak_explicit(
5659+ volatile atomic_uint __local *object, uint __private *expected,
5660+ uint desired, memory_order success, memory_order failure,
5661+ memory_scope scope);
5662+bool __ovld atomic_compare_exchange_strong_explicit(
5663+ volatile atomic_float __global *object, float __global *expected,
5664+ float desired, memory_order success, memory_order failure,
5665+ memory_scope scope);
5666+bool __ovld atomic_compare_exchange_strong_explicit(
5667+ volatile atomic_float __local *object, float __global *expected,
5668+ float desired, memory_order success, memory_order failure,
5669+ memory_scope scope);
5670+bool __ovld atomic_compare_exchange_strong_explicit(
5671+ volatile atomic_float __global *object, float __local *expected,
5672+ float desired, memory_order success, memory_order failure,
5673+ memory_scope scope);
5674+bool __ovld atomic_compare_exchange_strong_explicit(
5675+ volatile atomic_float __local *object, float __local *expected,
5676+ float desired, memory_order success, memory_order failure,
5677+ memory_scope scope);
5678+bool __ovld atomic_compare_exchange_strong_explicit(
5679+ volatile atomic_float __global *object, float __private *expected,
5680+ float desired, memory_order success, memory_order failure,
5681+ memory_scope scope);
5682+bool __ovld atomic_compare_exchange_strong_explicit(
5683+ volatile atomic_float __local *object, float __private *expected,
5684+ float desired, memory_order success, memory_order failure,
5685+ memory_scope scope);
5686+bool __ovld atomic_compare_exchange_weak_explicit(
5687+ volatile atomic_float __global *object, float __global *expected,
5688+ float desired, memory_order success, memory_order failure,
5689+ memory_scope scope);
5690+bool __ovld atomic_compare_exchange_weak_explicit(
5691+ volatile atomic_float __local *object, float __global *expected,
5692+ float desired, memory_order success, memory_order failure,
5693+ memory_scope scope);
5694+bool __ovld atomic_compare_exchange_weak_explicit(
5695+ volatile atomic_float __global *object, float __local *expected,
5696+ float desired, memory_order success, memory_order failure,
5697+ memory_scope scope);
5698+bool __ovld atomic_compare_exchange_weak_explicit(
5699+ volatile atomic_float __local *object, float __local *expected,
5700+ float desired, memory_order success, memory_order failure,
5701+ memory_scope scope);
5702+bool __ovld atomic_compare_exchange_weak_explicit(
5703+ volatile atomic_float __global *object, float __private *expected,
5704+ float desired, memory_order success, memory_order failure,
5705+ memory_scope scope);
5706+bool __ovld atomic_compare_exchange_weak_explicit(
5707+ volatile atomic_float __local *object, float __private *expected,
5708+ float desired, memory_order success, memory_order failure,
5709+ memory_scope scope);
5710+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
5711+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
5712+#ifdef __opencl_c_atomic_scope_device
5713+bool __ovld atomic_compare_exchange_strong_explicit(
5714+ volatile atomic_double __global *object, double __global *expected,
5715+ double desired, memory_order success, memory_order failure);
5716+bool __ovld atomic_compare_exchange_strong_explicit(
5717+ volatile atomic_double __local *object, double __global *expected,
5718+ double desired, memory_order success, memory_order failure);
5719+bool __ovld atomic_compare_exchange_strong_explicit(
5720+ volatile atomic_double __global *object, double __local *expected,
5721+ double desired, memory_order success, memory_order failure);
5722+bool __ovld atomic_compare_exchange_strong_explicit(
5723+ volatile atomic_double __local *object, double __local *expected,
5724+ double desired, memory_order success, memory_order failure);
5725+bool __ovld atomic_compare_exchange_strong_explicit(
5726+ volatile atomic_double __global *object, double __private *expected,
5727+ double desired, memory_order success, memory_order failure);
5728+bool __ovld atomic_compare_exchange_strong_explicit(
5729+ volatile atomic_double __local *object, double __private *expected,
5730+ double desired, memory_order success, memory_order failure);
5731+bool __ovld atomic_compare_exchange_weak_explicit(
5732+ volatile atomic_double __global *object, double __global *expected,
5733+ double desired, memory_order success, memory_order failure);
5734+bool __ovld atomic_compare_exchange_weak_explicit(
5735+ volatile atomic_double __local *object, double __global *expected,
5736+ double desired, memory_order success, memory_order failure);
5737+bool __ovld atomic_compare_exchange_weak_explicit(
5738+ volatile atomic_double __global *object, double __local *expected,
5739+ double desired, memory_order success, memory_order failure);
5740+bool __ovld atomic_compare_exchange_weak_explicit(
5741+ volatile atomic_double __local *object, double __local *expected,
5742+ double desired, memory_order success, memory_order failure);
5743+bool __ovld atomic_compare_exchange_weak_explicit(
5744+ volatile atomic_double __global *object, double __private *expected,
5745+ double desired, memory_order success, memory_order failure);
5746+bool __ovld atomic_compare_exchange_weak_explicit(
5747+ volatile atomic_double __local *object, double __private *expected,
5748+ double desired, memory_order success, memory_order failure);
5749+#endif // __opencl_c_atomic_scope_device
5750+bool __ovld atomic_compare_exchange_strong_explicit(
5751+ volatile atomic_double __global *object, double __global *expected,
5752+ double desired, memory_order success, memory_order failure,
5753+ memory_scope scope);
5754+bool __ovld atomic_compare_exchange_strong_explicit(
5755+ volatile atomic_double __local *object, double __global *expected,
5756+ double desired, memory_order success, memory_order failure,
5757+ memory_scope scope);
5758+bool __ovld atomic_compare_exchange_strong_explicit(
5759+ volatile atomic_double __global *object, double __local *expected,
5760+ double desired, memory_order success, memory_order failure,
5761+ memory_scope scope);
5762+bool __ovld atomic_compare_exchange_strong_explicit(
5763+ volatile atomic_double __local *object, double __local *expected,
5764+ double desired, memory_order success, memory_order failure,
5765+ memory_scope scope);
5766+bool __ovld atomic_compare_exchange_strong_explicit(
5767+ volatile atomic_double __global *object, double __private *expected,
5768+ double desired, memory_order success, memory_order failure,
5769+ memory_scope scope);
5770+bool __ovld atomic_compare_exchange_strong_explicit(
5771+ volatile atomic_double __local *object, double __private *expected,
5772+ double desired, memory_order success, memory_order failure,
5773+ memory_scope scope);
5774+bool __ovld atomic_compare_exchange_weak_explicit(
5775+ volatile atomic_double __global *object, double __global *expected,
5776+ double desired, memory_order success, memory_order failure,
5777+ memory_scope scope);
5778+bool __ovld atomic_compare_exchange_weak_explicit(
5779+ volatile atomic_double __local *object, double __global *expected,
5780+ double desired, memory_order success, memory_order failure,
5781+ memory_scope scope);
5782+bool __ovld atomic_compare_exchange_weak_explicit(
5783+ volatile atomic_double __global *object, double __local *expected,
5784+ double desired, memory_order success, memory_order failure,
5785+ memory_scope scope);
5786+bool __ovld atomic_compare_exchange_weak_explicit(
5787+ volatile atomic_double __local *object, double __local *expected,
5788+ double desired, memory_order success, memory_order failure,
5789+ memory_scope scope);
5790+bool __ovld atomic_compare_exchange_weak_explicit(
5791+ volatile atomic_double __global *object, double __private *expected,
5792+ double desired, memory_order success, memory_order failure,
5793+ memory_scope scope);
5794+bool __ovld atomic_compare_exchange_weak_explicit(
5795+ volatile atomic_double __local *object, double __private *expected,
5796+ double desired, memory_order success, memory_order failure,
5797+ memory_scope scope);
5798+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
5799+#ifdef __opencl_c_atomic_scope_device
5800+bool __ovld atomic_compare_exchange_strong_explicit(
5801+ volatile atomic_long __global *object, long __global *expected,
5802+ long desired, memory_order success, memory_order failure);
5803+bool __ovld atomic_compare_exchange_strong_explicit(
5804+ volatile atomic_long __local *object, long __global *expected, long desired,
5805+ memory_order success, memory_order failure);
5806+bool __ovld atomic_compare_exchange_strong_explicit(
5807+ volatile atomic_long __global *object, long __local *expected, long desired,
5808+ memory_order success, memory_order failure);
5809+bool __ovld atomic_compare_exchange_strong_explicit(
5810+ volatile atomic_long __local *object, long __local *expected, long desired,
5811+ memory_order success, memory_order failure);
5812+bool __ovld atomic_compare_exchange_strong_explicit(
5813+ volatile atomic_long __global *object, long __private *expected,
5814+ long desired, memory_order success, memory_order failure);
5815+bool __ovld atomic_compare_exchange_strong_explicit(
5816+ volatile atomic_long __local *object, long __private *expected,
5817+ long desired, memory_order success, memory_order failure);
5818+bool __ovld atomic_compare_exchange_weak_explicit(
5819+ volatile atomic_long __global *object, long __global *expected,
5820+ long desired, memory_order success, memory_order failure);
5821+bool __ovld atomic_compare_exchange_weak_explicit(
5822+ volatile atomic_long __local *object, long __global *expected, long desired,
5823+ memory_order success, memory_order failure);
5824+bool __ovld atomic_compare_exchange_weak_explicit(
5825+ volatile atomic_long __global *object, long __local *expected, long desired,
5826+ memory_order success, memory_order failure);
5827+bool __ovld atomic_compare_exchange_weak_explicit(
5828+ volatile atomic_long __local *object, long __local *expected, long desired,
5829+ memory_order success, memory_order failure);
5830+bool __ovld atomic_compare_exchange_weak_explicit(
5831+ volatile atomic_long __global *object, long __private *expected,
5832+ long desired, memory_order success, memory_order failure);
5833+bool __ovld atomic_compare_exchange_weak_explicit(
5834+ volatile atomic_long __local *object, long __private *expected,
5835+ long desired, memory_order success, memory_order failure);
5836+bool __ovld atomic_compare_exchange_strong_explicit(
5837+ volatile atomic_ulong __global *object, ulong __global *expected,
5838+ ulong desired, memory_order success, memory_order failure);
5839+bool __ovld atomic_compare_exchange_strong_explicit(
5840+ volatile atomic_ulong __local *object, ulong __global *expected,
5841+ ulong desired, memory_order success, memory_order failure);
5842+bool __ovld atomic_compare_exchange_strong_explicit(
5843+ volatile atomic_ulong __global *object, ulong __local *expected,
5844+ ulong desired, memory_order success, memory_order failure);
5845+bool __ovld atomic_compare_exchange_strong_explicit(
5846+ volatile atomic_ulong __local *object, ulong __local *expected,
5847+ ulong desired, memory_order success, memory_order failure);
5848+bool __ovld atomic_compare_exchange_strong_explicit(
5849+ volatile atomic_ulong __global *object, ulong __private *expected,
5850+ ulong desired, memory_order success, memory_order failure);
5851+bool __ovld atomic_compare_exchange_strong_explicit(
5852+ volatile atomic_ulong __local *object, ulong __private *expected,
5853+ ulong desired, memory_order success, memory_order failure);
5854+bool __ovld atomic_compare_exchange_weak_explicit(
5855+ volatile atomic_ulong __global *object, ulong __global *expected,
5856+ ulong desired, memory_order success, memory_order failure);
5857+bool __ovld atomic_compare_exchange_weak_explicit(
5858+ volatile atomic_ulong __local *object, ulong __global *expected,
5859+ ulong desired, memory_order success, memory_order failure);
5860+bool __ovld atomic_compare_exchange_weak_explicit(
5861+ volatile atomic_ulong __global *object, ulong __local *expected,
5862+ ulong desired, memory_order success, memory_order failure);
5863+bool __ovld atomic_compare_exchange_weak_explicit(
5864+ volatile atomic_ulong __local *object, ulong __local *expected,
5865+ ulong desired, memory_order success, memory_order failure);
5866+bool __ovld atomic_compare_exchange_weak_explicit(
5867+ volatile atomic_ulong __global *object, ulong __private *expected,
5868+ ulong desired, memory_order success, memory_order failure);
5869+bool __ovld atomic_compare_exchange_weak_explicit(
5870+ volatile atomic_ulong __local *object, ulong __private *expected,
5871+ ulong desired, memory_order success, memory_order failure);
5872+#endif // __opencl_c_atomic_scope_device
5873+bool __ovld atomic_compare_exchange_strong_explicit(
5874+ volatile atomic_long __global *object, long __global *expected,
5875+ long desired, memory_order success, memory_order failure,
5876+ memory_scope scope);
5877+bool __ovld atomic_compare_exchange_strong_explicit(
5878+ volatile atomic_long __local *object, long __global *expected, long desired,
5879+ memory_order success, memory_order failure, memory_scope scope);
5880+bool __ovld atomic_compare_exchange_strong_explicit(
5881+ volatile atomic_long __global *object, long __local *expected, long desired,
5882+ memory_order success, memory_order failure, memory_scope scope);
5883+bool __ovld atomic_compare_exchange_strong_explicit(
5884+ volatile atomic_long __local *object, long __local *expected, long desired,
5885+ memory_order success, memory_order failure, memory_scope scope);
5886+bool __ovld atomic_compare_exchange_strong_explicit(
5887+ volatile atomic_long __global *object, long __private *expected,
5888+ long desired, memory_order success, memory_order failure,
5889+ memory_scope scope);
5890+bool __ovld atomic_compare_exchange_strong_explicit(
5891+ volatile atomic_long __local *object, long __private *expected,
5892+ long desired, memory_order success, memory_order failure,
5893+ memory_scope scope);
5894+bool __ovld atomic_compare_exchange_weak_explicit(
5895+ volatile atomic_long __global *object, long __global *expected,
5896+ long desired, memory_order success, memory_order failure,
5897+ memory_scope scope);
5898+bool __ovld atomic_compare_exchange_weak_explicit(
5899+ volatile atomic_long __local *object, long __global *expected, long desired,
5900+ memory_order success, memory_order failure, memory_scope scope);
5901+bool __ovld atomic_compare_exchange_weak_explicit(
5902+ volatile atomic_long __global *object, long __local *expected, long desired,
5903+ memory_order success, memory_order failure, memory_scope scope);
5904+bool __ovld atomic_compare_exchange_weak_explicit(
5905+ volatile atomic_long __local *object, long __local *expected, long desired,
5906+ memory_order success, memory_order failure, memory_scope scope);
5907+bool __ovld atomic_compare_exchange_weak_explicit(
5908+ volatile atomic_long __global *object, long __private *expected,
5909+ long desired, memory_order success, memory_order failure,
5910+ memory_scope scope);
5911+bool __ovld atomic_compare_exchange_weak_explicit(
5912+ volatile atomic_long __local *object, long __private *expected,
5913+ long desired, memory_order success, memory_order failure,
5914+ memory_scope scope);
5915+bool __ovld atomic_compare_exchange_strong_explicit(
5916+ volatile atomic_ulong __global *object, ulong __global *expected,
5917+ ulong desired, memory_order success, memory_order failure,
5918+ memory_scope scope);
5919+bool __ovld atomic_compare_exchange_strong_explicit(
5920+ volatile atomic_ulong __local *object, ulong __global *expected,
5921+ ulong desired, memory_order success, memory_order failure,
5922+ memory_scope scope);
5923+bool __ovld atomic_compare_exchange_strong_explicit(
5924+ volatile atomic_ulong __global *object, ulong __local *expected,
5925+ ulong desired, memory_order success, memory_order failure,
5926+ memory_scope scope);
5927+bool __ovld atomic_compare_exchange_strong_explicit(
5928+ volatile atomic_ulong __local *object, ulong __local *expected,
5929+ ulong desired, memory_order success, memory_order failure,
5930+ memory_scope scope);
5931+bool __ovld atomic_compare_exchange_strong_explicit(
5932+ volatile atomic_ulong __global *object, ulong __private *expected,
5933+ ulong desired, memory_order success, memory_order failure,
5934+ memory_scope scope);
5935+bool __ovld atomic_compare_exchange_strong_explicit(
5936+ volatile atomic_ulong __local *object, ulong __private *expected,
5937+ ulong desired, memory_order success, memory_order failure,
5938+ memory_scope scope);
5939+bool __ovld atomic_compare_exchange_weak_explicit(
5940+ volatile atomic_ulong __global *object, ulong __global *expected,
5941+ ulong desired, memory_order success, memory_order failure,
5942+ memory_scope scope);
5943+bool __ovld atomic_compare_exchange_weak_explicit(
5944+ volatile atomic_ulong __local *object, ulong __global *expected,
5945+ ulong desired, memory_order success, memory_order failure,
5946+ memory_scope scope);
5947+bool __ovld atomic_compare_exchange_weak_explicit(
5948+ volatile atomic_ulong __global *object, ulong __local *expected,
5949+ ulong desired, memory_order success, memory_order failure,
5950+ memory_scope scope);
5951+bool __ovld atomic_compare_exchange_weak_explicit(
5952+ volatile atomic_ulong __local *object, ulong __local *expected,
5953+ ulong desired, memory_order success, memory_order failure,
5954+ memory_scope scope);
5955+bool __ovld atomic_compare_exchange_weak_explicit(
5956+ volatile atomic_ulong __global *object, ulong __private *expected,
5957+ ulong desired, memory_order success, memory_order failure,
5958+ memory_scope scope);
5959+bool __ovld atomic_compare_exchange_weak_explicit(
5960+ volatile atomic_ulong __local *object, ulong __private *expected,
5961+ ulong desired, memory_order success, memory_order failure,
5962+ memory_scope scope);
5963+#endif // defined(cl_khr_int64_base_atomics) &&
5964+ // defined(cl_khr_int64_extended_atomics)
5965+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
5966
5967 // atomic_flag_test_and_set() and atomic_flag_clear()
5968-
5969+#if defined(__opencl_c_atomic_scope_device) && \
5970+ defined(__opencl_c_atomic_order_seq_cst)
5971+#ifdef __opencl_c_generic_address_space
5972 bool __ovld atomic_flag_test_and_set(volatile atomic_flag *object);
5973-bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order);
5974-bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order, memory_scope scope);
5975 void __ovld atomic_flag_clear(volatile atomic_flag *object);
5976-void __ovld atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order);
5977-void __ovld atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order, memory_scope scope);
5978+#endif // __opencl_c_generic_address_space
5979+
5980+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
5981+bool __ovld atomic_flag_test_and_set(volatile atomic_flag __global *object);
5982+bool __ovld atomic_flag_test_and_set(volatile atomic_flag __local *object);
5983+void __ovld atomic_flag_clear(volatile atomic_flag __global *object);
5984+void __ovld atomic_flag_clear(volatile atomic_flag __local *object);
5985+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
5986+#endif // defined(__opencl_c_atomic_scope_device) &&
5987+ // defined(__opencl_c_atomic_order_seq_cst)
5988+
5989+#ifdef __opencl_c_generic_address_space
5990+#ifdef __opencl_c_atomic_scope_device
5991+bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *object,
5992+ memory_order order);
5993+void __ovld atomic_flag_clear_explicit(volatile atomic_flag *object,
5994+ memory_order order);
5995+#endif // __opencl_c_atomic_scope_device
5996+bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *object,
5997+ memory_order order,
5998+ memory_scope scope);
5999+void __ovld atomic_flag_clear_explicit(volatile atomic_flag *object,
6000+ memory_order order, memory_scope scope);
6001+#endif // __opencl_c_generic_address_space
6002+
6003+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
6004+#ifdef __opencl_c_atomic_scope_device
6005+bool __ovld atomic_flag_test_and_set_explicit(
6006+ volatile atomic_flag __global *object, memory_order order);
6007+bool __ovld atomic_flag_test_and_set_explicit(
6008+ volatile atomic_flag __local *object, memory_order order);
6009+void __ovld atomic_flag_clear_explicit(volatile atomic_flag __global *object,
6010+ memory_order order);
6011+void __ovld atomic_flag_clear_explicit(volatile atomic_flag __local *object,
6012+ memory_order order);
6013+#endif // __opencl_c_atomic_scope_device
6014+bool __ovld
6015+atomic_flag_test_and_set_explicit(volatile atomic_flag __global *object,
6016+ memory_order order, memory_scope scope);
6017+bool __ovld
6018+atomic_flag_test_and_set_explicit(volatile atomic_flag __local *object,
6019+ memory_order order, memory_scope scope);
6020+void __ovld atomic_flag_clear_explicit(volatile atomic_flag __global *object,
6021+ memory_order order, memory_scope scope);
6022+void __ovld atomic_flag_clear_explicit(volatile atomic_flag __local *object,
6023+ memory_order order, memory_scope scope);
6024+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
6025
6026 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6027
6028@@ -13918,7 +15943,7 @@ float16 __ovld __cnfn shuffle(float4 x, uint16 mask);
6029 float16 __ovld __cnfn shuffle(float8 x, uint16 mask);
6030 float16 __ovld __cnfn shuffle(float16 x, uint16 mask);
6031
6032-#ifdef cl_khr_fp64
6033+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6034 double2 __ovld __cnfn shuffle(double2 x, ulong2 mask);
6035 double2 __ovld __cnfn shuffle(double4 x, ulong2 mask);
6036 double2 __ovld __cnfn shuffle(double8 x, ulong2 mask);
6037@@ -13938,7 +15963,7 @@ double16 __ovld __cnfn shuffle(double2 x, ulong16 mask);
6038 double16 __ovld __cnfn shuffle(double4 x, ulong16 mask);
6039 double16 __ovld __cnfn shuffle(double8 x, ulong16 mask);
6040 double16 __ovld __cnfn shuffle(double16 x, ulong16 mask);
6041-#endif //cl_khr_fp64
6042+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6043
6044 #ifdef cl_khr_fp16
6045 half2 __ovld __cnfn shuffle(half2 x, ushort2 mask);
6046@@ -14142,7 +16167,7 @@ float16 __ovld __cnfn shuffle2(float4 x, float4 y, uint16 mask);
6047 float16 __ovld __cnfn shuffle2(float8 x, float8 y, uint16 mask);
6048 float16 __ovld __cnfn shuffle2(float16 x, float16 y, uint16 mask);
6049
6050-#ifdef cl_khr_fp64
6051+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6052 double2 __ovld __cnfn shuffle2(double2 x, double2 y, ulong2 mask);
6053 double2 __ovld __cnfn shuffle2(double4 x, double4 y, ulong2 mask);
6054 double2 __ovld __cnfn shuffle2(double8 x, double8 y, ulong2 mask);
6055@@ -14162,7 +16187,7 @@ double16 __ovld __cnfn shuffle2(double2 x, double2 y, ulong16 mask);
6056 double16 __ovld __cnfn shuffle2(double4 x, double4 y, ulong16 mask);
6057 double16 __ovld __cnfn shuffle2(double8 x, double8 y, ulong16 mask);
6058 double16 __ovld __cnfn shuffle2(double16 x, double16 y, ulong16 mask);
6059-#endif //cl_khr_fp64
6060+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6061
6062 #ifdef cl_khr_fp16
6063 half2 __ovld __cnfn shuffle2(half2 x, half2 y, ushort2 mask);
6064@@ -14198,6 +16223,7 @@ int printf(__constant const char* st, ...) __attribute__((format(printf, 1, 2)))
6065 #pragma OPENCL EXTENSION cl_khr_gl_msaa_sharing : enable
6066 #endif //cl_khr_gl_msaa_sharing
6067
6068+#ifdef __opencl_c_images
6069 /**
6070 * Use the coordinate (coord.xy) to do an element lookup in
6071 * the 2D image object specified by image.
6072@@ -14476,6 +16502,7 @@ half4 __purefn __ovld read_imageh(read_only image1d_buffer_t image, int coord);
6073
6074 // Image read functions for read_write images
6075 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6076+#ifdef __opencl_c_read_write_images
6077 float4 __purefn __ovld read_imagef(read_write image1d_t image, int coord);
6078 int4 __purefn __ovld read_imagei(read_write image1d_t image, int coord);
6079 uint4 __purefn __ovld read_imageui(read_write image1d_t image, int coord);
6080@@ -14519,6 +16546,7 @@ float __purefn __ovld read_imagef(read_write image2d_array_msaa_depth_t image, i
6081 #endif //cl_khr_gl_msaa_sharing
6082
6083 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6084+#ifdef __opencl_c_read_write_images
6085 #ifdef cl_khr_mipmap_image
6086 float4 __purefn __ovld read_imagef(read_write image1d_t image, sampler_t sampler, float coord, float lod);
6087 int4 __purefn __ovld read_imagei(read_write image1d_t image, sampler_t sampler, float coord, float lod);
6088@@ -14569,6 +16597,7 @@ int4 __purefn __ovld read_imagei(read_write image3d_t image, sampler_t sampler,
6089 uint4 __purefn __ovld read_imageui(read_write image3d_t image, sampler_t sampler, float4 coord, float4 gradientX, float4 gradientY);
6090
6091 #endif //cl_khr_mipmap_image
6092+#endif //__opencl_c_read_write_images
6093 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6094
6095 // Image read functions returning half4 type
6096@@ -14580,6 +16609,7 @@ half4 __purefn __ovld read_imageh(read_write image1d_array_t image, int2 coord);
6097 half4 __purefn __ovld read_imageh(read_write image2d_array_t image, int4 coord);
6098 half4 __purefn __ovld read_imageh(read_write image1d_buffer_t image, int coord);
6099 #endif //cl_khr_fp16
6100+#endif //__opencl_c_read_write_images
6101 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6102
6103 /**
6104@@ -14669,7 +16699,7 @@ void __ovld write_imagef(write_only image1d_array_t image_array, int2 coord, flo
6105 void __ovld write_imagei(write_only image1d_array_t image_array, int2 coord, int4 color);
6106 void __ovld write_imageui(write_only image1d_array_t image_array, int2 coord, uint4 color);
6107
6108-#ifdef cl_khr_3d_image_writes
6109+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6110 void __ovld write_imagef(write_only image3d_t image, int4 coord, float4 color);
6111 void __ovld write_imagei(write_only image3d_t image, int4 coord, int4 color);
6112 void __ovld write_imageui(write_only image3d_t image, int4 coord, uint4 color);
6113@@ -14702,7 +16732,7 @@ void __ovld write_imageui(write_only image2d_array_t image_array, int4 coord, in
6114 void __ovld write_imagef(write_only image2d_depth_t image, int2 coord, int lod, float depth);
6115 void __ovld write_imagef(write_only image2d_array_depth_t image, int4 coord, int lod, float depth);
6116
6117-#ifdef cl_khr_3d_image_writes
6118+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6119 void __ovld write_imagef(write_only image3d_t image, int4 coord, int lod, float4 color);
6120 void __ovld write_imagei(write_only image3d_t image, int4 coord, int lod, int4 color);
6121 void __ovld write_imageui(write_only image3d_t image, int4 coord, int lod, uint4 color);
6122@@ -14715,7 +16745,7 @@ void __ovld write_imageui(write_only image3d_t image, int4 coord, int lod, uint4
6123 #ifdef cl_khr_fp16
6124 void __ovld write_imageh(write_only image1d_t image, int coord, half4 color);
6125 void __ovld write_imageh(write_only image2d_t image, int2 coord, half4 color);
6126-#ifdef cl_khr_3d_image_writes
6127+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6128 void __ovld write_imageh(write_only image3d_t image, int4 coord, half4 color);
6129 #endif
6130 void __ovld write_imageh(write_only image1d_array_t image, int2 coord, half4 color);
6131@@ -14725,6 +16755,7 @@ void __ovld write_imageh(write_only image1d_buffer_t image, int coord, half4 col
6132
6133 // Image write functions for read_write images
6134 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6135+#ifdef __opencl_c_read_write_images
6136 void __ovld write_imagef(read_write image2d_t image, int2 coord, float4 color);
6137 void __ovld write_imagei(read_write image2d_t image, int2 coord, int4 color);
6138 void __ovld write_imageui(read_write image2d_t image, int2 coord, uint4 color);
6139@@ -14745,7 +16776,7 @@ void __ovld write_imagef(read_write image1d_array_t image_array, int2 coord, flo
6140 void __ovld write_imagei(read_write image1d_array_t image_array, int2 coord, int4 color);
6141 void __ovld write_imageui(read_write image1d_array_t image_array, int2 coord, uint4 color);
6142
6143-#ifdef cl_khr_3d_image_writes
6144+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6145 void __ovld write_imagef(read_write image3d_t image, int4 coord, float4 color);
6146 void __ovld write_imagei(read_write image3d_t image, int4 coord, int4 color);
6147 void __ovld write_imageui(read_write image3d_t image, int4 coord, uint4 color);
6148@@ -14777,7 +16808,7 @@ void __ovld write_imageui(read_write image2d_array_t image_array, int4 coord, in
6149 void __ovld write_imagef(read_write image2d_depth_t image, int2 coord, int lod, float color);
6150 void __ovld write_imagef(read_write image2d_array_depth_t image, int4 coord, int lod, float color);
6151
6152-#ifdef cl_khr_3d_image_writes
6153+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6154 void __ovld write_imagef(read_write image3d_t image, int4 coord, int lod, float4 color);
6155 void __ovld write_imagei(read_write image3d_t image, int4 coord, int lod, int4 color);
6156 void __ovld write_imageui(read_write image3d_t image, int4 coord, int lod, uint4 color);
6157@@ -14790,13 +16821,14 @@ void __ovld write_imageui(read_write image3d_t image, int4 coord, int lod, uint4
6158 #ifdef cl_khr_fp16
6159 void __ovld write_imageh(read_write image1d_t image, int coord, half4 color);
6160 void __ovld write_imageh(read_write image2d_t image, int2 coord, half4 color);
6161-#ifdef cl_khr_3d_image_writes
6162+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6163 void __ovld write_imageh(read_write image3d_t image, int4 coord, half4 color);
6164 #endif
6165 void __ovld write_imageh(read_write image1d_array_t image, int2 coord, half4 color);
6166 void __ovld write_imageh(read_write image2d_array_t image, int4 coord, half4 color);
6167 void __ovld write_imageh(read_write image1d_buffer_t image, int coord, half4 color);
6168 #endif //cl_khr_fp16
6169+#endif //__opencl_c_read_write_images
6170 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6171
6172 // Note: In OpenCL v1.0/1.1/1.2, image argument of image query builtin functions does not have
6173@@ -14810,7 +16842,7 @@ void __ovld write_imageh(read_write image1d_buffer_t image, int coord, half4 col
6174 int __ovld __cnfn get_image_width(read_only image1d_t image);
6175 int __ovld __cnfn get_image_width(read_only image1d_buffer_t image);
6176 int __ovld __cnfn get_image_width(read_only image2d_t image);
6177-#ifdef cl_khr_3d_image_writes
6178+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6179 int __ovld __cnfn get_image_width(read_only image3d_t image);
6180 #endif
6181 int __ovld __cnfn get_image_width(read_only image1d_array_t image);
6182@@ -14829,7 +16861,7 @@ int __ovld __cnfn get_image_width(read_only image2d_array_msaa_depth_t image);
6183 int __ovld __cnfn get_image_width(write_only image1d_t image);
6184 int __ovld __cnfn get_image_width(write_only image1d_buffer_t image);
6185 int __ovld __cnfn get_image_width(write_only image2d_t image);
6186-#ifdef cl_khr_3d_image_writes
6187+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6188 int __ovld __cnfn get_image_width(write_only image3d_t image);
6189 #endif
6190 int __ovld __cnfn get_image_width(write_only image1d_array_t image);
6191@@ -14846,6 +16878,7 @@ int __ovld __cnfn get_image_width(write_only image2d_array_msaa_depth_t image);
6192 #endif //cl_khr_gl_msaa_sharing
6193
6194 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6195+#ifdef __opencl_c_read_write_images
6196 int __ovld __cnfn get_image_width(read_write image1d_t image);
6197 int __ovld __cnfn get_image_width(read_write image1d_buffer_t image);
6198 int __ovld __cnfn get_image_width(read_write image2d_t image);
6199@@ -14862,6 +16895,7 @@ int __ovld __cnfn get_image_width(read_write image2d_msaa_depth_t image);
6200 int __ovld __cnfn get_image_width(read_write image2d_array_msaa_t image);
6201 int __ovld __cnfn get_image_width(read_write image2d_array_msaa_depth_t image);
6202 #endif //cl_khr_gl_msaa_sharing
6203+#endif //__opencl_c_read_write_images
6204 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6205
6206 /**
6207@@ -14882,7 +16916,7 @@ int __ovld __cnfn get_image_height(read_only image2d_array_msaa_depth_t image);
6208 #endif //cl_khr_gl_msaa_sharing
6209
6210 int __ovld __cnfn get_image_height(write_only image2d_t image);
6211-#ifdef cl_khr_3d_image_writes
6212+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6213 int __ovld __cnfn get_image_height(write_only image3d_t image);
6214 #endif
6215 int __ovld __cnfn get_image_height(write_only image2d_array_t image);
6216@@ -14898,6 +16932,7 @@ int __ovld __cnfn get_image_height(write_only image2d_array_msaa_depth_t image);
6217 #endif //cl_khr_gl_msaa_sharing
6218
6219 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6220+#ifdef __opencl_c_read_write_images
6221 int __ovld __cnfn get_image_height(read_write image2d_t image);
6222 int __ovld __cnfn get_image_height(read_write image3d_t image);
6223 int __ovld __cnfn get_image_height(read_write image2d_array_t image);
6224@@ -14911,6 +16946,7 @@ int __ovld __cnfn get_image_height(read_write image2d_msaa_depth_t image);
6225 int __ovld __cnfn get_image_height(read_write image2d_array_msaa_t image);
6226 int __ovld __cnfn get_image_height(read_write image2d_array_msaa_depth_t image);
6227 #endif //cl_khr_gl_msaa_sharing
6228+#endif //__opencl_c_read_write_images
6229 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6230
6231 /**
6232@@ -14918,12 +16954,14 @@ int __ovld __cnfn get_image_height(read_write image2d_array_msaa_depth_t image);
6233 */
6234 int __ovld __cnfn get_image_depth(read_only image3d_t image);
6235
6236-#ifdef cl_khr_3d_image_writes
6237+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6238 int __ovld __cnfn get_image_depth(write_only image3d_t image);
6239 #endif
6240
6241 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6242+#ifdef __opencl_c_read_write_images
6243 int __ovld __cnfn get_image_depth(read_write image3d_t image);
6244+#endif //__opencl_c_read_write_images
6245 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6246
6247 // OpenCL Extension v2.0 s9.18 - Mipmaps
6248@@ -14939,13 +16977,15 @@ int __ovld get_image_num_mip_levels(read_only image3d_t image);
6249
6250 int __ovld get_image_num_mip_levels(write_only image1d_t image);
6251 int __ovld get_image_num_mip_levels(write_only image2d_t image);
6252-#ifdef cl_khr_3d_image_writes
6253+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6254 int __ovld get_image_num_mip_levels(write_only image3d_t image);
6255 #endif
6256
6257+#ifdef __opencl_c_read_write_images
6258 int __ovld get_image_num_mip_levels(read_write image1d_t image);
6259 int __ovld get_image_num_mip_levels(read_write image2d_t image);
6260 int __ovld get_image_num_mip_levels(read_write image3d_t image);
6261+#endif //__opencl_c_read_write_images
6262
6263 int __ovld get_image_num_mip_levels(read_only image1d_array_t image);
6264 int __ovld get_image_num_mip_levels(read_only image2d_array_t image);
6265@@ -14957,10 +16997,12 @@ int __ovld get_image_num_mip_levels(write_only image2d_array_t image);
6266 int __ovld get_image_num_mip_levels(write_only image2d_array_depth_t image);
6267 int __ovld get_image_num_mip_levels(write_only image2d_depth_t image);
6268
6269+#ifdef __opencl_c_read_write_images
6270 int __ovld get_image_num_mip_levels(read_write image1d_array_t image);
6271 int __ovld get_image_num_mip_levels(read_write image2d_array_t image);
6272 int __ovld get_image_num_mip_levels(read_write image2d_array_depth_t image);
6273 int __ovld get_image_num_mip_levels(read_write image2d_depth_t image);
6274+#endif //__opencl_c_read_write_images
6275
6276 #endif //cl_khr_mipmap_image
6277 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6278@@ -15004,7 +17046,7 @@ int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_msaa_depth
6279 int __ovld __cnfn get_image_channel_data_type(write_only image1d_t image);
6280 int __ovld __cnfn get_image_channel_data_type(write_only image1d_buffer_t image);
6281 int __ovld __cnfn get_image_channel_data_type(write_only image2d_t image);
6282-#ifdef cl_khr_3d_image_writes
6283+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6284 int __ovld __cnfn get_image_channel_data_type(write_only image3d_t image);
6285 #endif
6286 int __ovld __cnfn get_image_channel_data_type(write_only image1d_array_t image);
6287@@ -15021,6 +17063,7 @@ int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_msaa_dept
6288 #endif //cl_khr_gl_msaa_sharing
6289
6290 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6291+#ifdef __opencl_c_read_write_images
6292 int __ovld __cnfn get_image_channel_data_type(read_write image1d_t image);
6293 int __ovld __cnfn get_image_channel_data_type(read_write image1d_buffer_t image);
6294 int __ovld __cnfn get_image_channel_data_type(read_write image2d_t image);
6295@@ -15037,6 +17080,7 @@ int __ovld __cnfn get_image_channel_data_type(read_write image2d_msaa_depth_t im
6296 int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_msaa_t image);
6297 int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_msaa_depth_t image);
6298 #endif //cl_khr_gl_msaa_sharing
6299+#endif //__opencl_c_read_write_images
6300 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6301
6302 /**
6303@@ -15076,7 +17120,7 @@ int __ovld __cnfn get_image_channel_order(read_only image2d_array_msaa_depth_t i
6304 int __ovld __cnfn get_image_channel_order(write_only image1d_t image);
6305 int __ovld __cnfn get_image_channel_order(write_only image1d_buffer_t image);
6306 int __ovld __cnfn get_image_channel_order(write_only image2d_t image);
6307-#ifdef cl_khr_3d_image_writes
6308+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6309 int __ovld __cnfn get_image_channel_order(write_only image3d_t image);
6310 #endif
6311 int __ovld __cnfn get_image_channel_order(write_only image1d_array_t image);
6312@@ -15093,6 +17137,7 @@ int __ovld __cnfn get_image_channel_order(write_only image2d_array_msaa_depth_t
6313 #endif //cl_khr_gl_msaa_sharing
6314
6315 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6316+#ifdef __opencl_c_read_write_images
6317 int __ovld __cnfn get_image_channel_order(read_write image1d_t image);
6318 int __ovld __cnfn get_image_channel_order(read_write image1d_buffer_t image);
6319 int __ovld __cnfn get_image_channel_order(read_write image2d_t image);
6320@@ -15109,6 +17154,7 @@ int __ovld __cnfn get_image_channel_order(read_write image2d_msaa_depth_t image)
6321 int __ovld __cnfn get_image_channel_order(read_write image2d_array_msaa_t image);
6322 int __ovld __cnfn get_image_channel_order(read_write image2d_array_msaa_depth_t image);
6323 #endif //cl_khr_gl_msaa_sharing
6324+#endif //__opencl_c_read_write_images
6325 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6326
6327 /**
6328@@ -15143,6 +17189,7 @@ int2 __ovld __cnfn get_image_dim(write_only image2d_array_msaa_depth_t image);
6329 #endif //cl_khr_gl_msaa_sharing
6330
6331 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6332+#ifdef __opencl_c_read_write_images
6333 int2 __ovld __cnfn get_image_dim(read_write image2d_t image);
6334 int2 __ovld __cnfn get_image_dim(read_write image2d_array_t image);
6335 #ifdef cl_khr_depth_images
6336@@ -15155,6 +17202,7 @@ int2 __ovld __cnfn get_image_dim(read_write image2d_msaa_depth_t image);
6337 int2 __ovld __cnfn get_image_dim(read_write image2d_array_msaa_t image);
6338 int2 __ovld __cnfn get_image_dim(read_write image2d_array_msaa_depth_t image);
6339 #endif //cl_khr_gl_msaa_sharing
6340+#endif //__opencl_c_read_write_images
6341 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6342
6343 /**
6344@@ -15164,11 +17212,13 @@ int2 __ovld __cnfn get_image_dim(read_write image2d_array_msaa_depth_t image);
6345 * component and the w component is 0.
6346 */
6347 int4 __ovld __cnfn get_image_dim(read_only image3d_t image);
6348-#ifdef cl_khr_3d_image_writes
6349+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6350 int4 __ovld __cnfn get_image_dim(write_only image3d_t image);
6351 #endif
6352 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6353+#ifdef __opencl_c_read_write_images
6354 int4 __ovld __cnfn get_image_dim(read_write image3d_t image);
6355+#endif //__opencl_c_read_write_images
6356 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6357
6358 /**
6359@@ -15196,6 +17246,7 @@ size_t __ovld __cnfn get_image_array_size(write_only image2d_array_msaa_depth_t
6360 #endif //cl_khr_gl_msaa_sharing
6361
6362 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6363+#ifdef __opencl_c_read_write_images
6364 size_t __ovld __cnfn get_image_array_size(read_write image1d_array_t image_array);
6365 size_t __ovld __cnfn get_image_array_size(read_write image2d_array_t image_array);
6366 #ifdef cl_khr_depth_images
6367@@ -15205,6 +17256,7 @@ size_t __ovld __cnfn get_image_array_size(read_write image2d_array_depth_t image
6368 size_t __ovld __cnfn get_image_array_size(read_write image2d_array_msaa_t image_array);
6369 size_t __ovld __cnfn get_image_array_size(read_write image2d_array_msaa_depth_t image_array);
6370 #endif //cl_khr_gl_msaa_sharing
6371+#endif //__opencl_c_read_write_images
6372 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6373
6374 /**
6375@@ -15222,16 +17274,21 @@ int __ovld get_image_num_samples(write_only image2d_array_msaa_t image);
6376 int __ovld get_image_num_samples(write_only image2d_array_msaa_depth_t image);
6377
6378 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6379+#ifdef __opencl_c_read_write_images
6380 int __ovld get_image_num_samples(read_write image2d_msaa_t image);
6381 int __ovld get_image_num_samples(read_write image2d_msaa_depth_t image);
6382 int __ovld get_image_num_samples(read_write image2d_array_msaa_t image);
6383 int __ovld get_image_num_samples(read_write image2d_array_msaa_depth_t image);
6384+#endif //__opencl_c_read_write_images
6385 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6386 #endif
6387
6388+#endif //__opencl_c_images
6389+
6390 // OpenCL v2.0 s6.13.15 - Work-group Functions
6391
6392 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6393+#ifdef __opencl_c_work_group_collective_functions
6394 int __ovld __conv work_group_all(int predicate);
6395 int __ovld __conv work_group_any(int predicate);
6396
6397@@ -15255,11 +17312,11 @@ ulong __ovld __conv work_group_broadcast(ulong a, size_t x, size_t y, size_t z);
6398 float __ovld __conv work_group_broadcast(float a, size_t local_id);
6399 float __ovld __conv work_group_broadcast(float a, size_t x, size_t y);
6400 float __ovld __conv work_group_broadcast(float a, size_t x, size_t y, size_t z);
6401-#ifdef cl_khr_fp64
6402+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6403 double __ovld __conv work_group_broadcast(double a, size_t local_id);
6404 double __ovld __conv work_group_broadcast(double a, size_t x, size_t y);
6405 double __ovld __conv work_group_broadcast(double a, size_t x, size_t y, size_t z);
6406-#endif //cl_khr_fp64
6407+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6408
6409 #ifdef cl_khr_fp16
6410 half __ovld __conv work_group_reduce_add(half x);
6411@@ -15317,7 +17374,7 @@ float __ovld __conv work_group_scan_exclusive_max(float x);
6412 float __ovld __conv work_group_scan_inclusive_add(float x);
6413 float __ovld __conv work_group_scan_inclusive_min(float x);
6414 float __ovld __conv work_group_scan_inclusive_max(float x);
6415-#ifdef cl_khr_fp64
6416+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6417 double __ovld __conv work_group_reduce_add(double x);
6418 double __ovld __conv work_group_reduce_min(double x);
6419 double __ovld __conv work_group_reduce_max(double x);
6420@@ -15327,19 +17384,18 @@ double __ovld __conv work_group_scan_exclusive_max(double x);
6421 double __ovld __conv work_group_scan_inclusive_add(double x);
6422 double __ovld __conv work_group_scan_inclusive_min(double x);
6423 double __ovld __conv work_group_scan_inclusive_max(double x);
6424-#endif //cl_khr_fp64
6425-
6426+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6427+#endif //__opencl_c_work_group_collective_functions
6428 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6429
6430 // OpenCL v2.0 s6.13.16 - Pipe Functions
6431-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6432+#ifdef __opencl_c_pipes
6433 bool __ovld is_valid_reserve_id(reserve_id_t reserve_id);
6434-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6435-
6436+#endif //__opencl_c_pipes
6437
6438 // OpenCL v2.0 s6.13.17 - Enqueue Kernels
6439 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6440-
6441+#ifdef __opencl_c_device_enqueue
6442 ndrange_t __ovld ndrange_1D(size_t);
6443 ndrange_t __ovld ndrange_1D(size_t, size_t);
6444 ndrange_t __ovld ndrange_1D(size_t, size_t, size_t);
6445@@ -15367,11 +17423,13 @@ bool __ovld is_valid_event (clk_event_t event);
6446 void __ovld capture_event_profiling_info(clk_event_t, clk_profiling_info, __global void* value);
6447
6448 queue_t __ovld get_default_queue(void);
6449+#endif //__opencl_c_device_enqueue
6450 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6451
6452 // OpenCL Extension v2.0 s9.17 - Sub-groups
6453
6454-#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups)
6455+#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups) || \
6456+ defined(__opencl_c_subgroups)
6457 // Shared Sub Group Functions
6458 uint __ovld get_sub_group_size(void);
6459 uint __ovld get_max_sub_group_size(void);
6460@@ -15457,7 +17515,7 @@ half __ovld __conv sub_group_scan_inclusive_min(half x);
6461 half __ovld __conv sub_group_scan_inclusive_max(half x);
6462 #endif //cl_khr_fp16
6463
6464-#ifdef cl_khr_fp64
6465+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6466 double __ovld __conv sub_group_broadcast(double x, uint sub_group_local_id);
6467 double __ovld __conv sub_group_reduce_add(double x);
6468 double __ovld __conv sub_group_reduce_min(double x);
6469@@ -15468,7 +17526,7 @@ double __ovld __conv sub_group_scan_exclusive_max(double x);
6470 double __ovld __conv sub_group_scan_inclusive_add(double x);
6471 double __ovld __conv sub_group_scan_inclusive_min(double x);
6472 double __ovld __conv sub_group_scan_inclusive_max(double x);
6473-#endif //cl_khr_fp64
6474+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6475
6476 #endif //cl_khr_subgroups cl_intel_subgroups
6477
6478@@ -15570,16 +17628,22 @@ uint16 __ovld __conv intel_sub_group_shuffle_xor( uint16 x, uint c );
6479 long __ovld __conv intel_sub_group_shuffle_xor( long x, uint c );
6480 ulong __ovld __conv intel_sub_group_shuffle_xor( ulong x, uint c );
6481
6482+#ifdef __opencl_c_images
6483 uint __ovld __conv intel_sub_group_block_read( read_only image2d_t image, int2 coord );
6484 uint2 __ovld __conv intel_sub_group_block_read2( read_only image2d_t image, int2 coord );
6485 uint4 __ovld __conv intel_sub_group_block_read4( read_only image2d_t image, int2 coord );
6486 uint8 __ovld __conv intel_sub_group_block_read8( read_only image2d_t image, int2 coord );
6487+#endif //__opencl_c_images
6488
6489 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6490+#ifdef __opencl_c_images
6491+#ifdef __opencl_c_read_write_images
6492 uint __ovld __conv intel_sub_group_block_read(read_write image2d_t image, int2 coord);
6493 uint2 __ovld __conv intel_sub_group_block_read2(read_write image2d_t image, int2 coord);
6494 uint4 __ovld __conv intel_sub_group_block_read4(read_write image2d_t image, int2 coord);
6495 uint8 __ovld __conv intel_sub_group_block_read8(read_write image2d_t image, int2 coord);
6496+#endif //__opencl_c_read_write_images
6497+#endif //__opencl_c_images
6498 #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6499
6500 uint __ovld __conv intel_sub_group_block_read( const __global uint* p );
6501@@ -15587,16 +17651,22 @@ uint2 __ovld __conv intel_sub_group_block_read2( const __global uint* p );
6502 uint4 __ovld __conv intel_sub_group_block_read4( const __global uint* p );
6503 uint8 __ovld __conv intel_sub_group_block_read8( const __global uint* p );
6504
6505+#ifdef __opencl_c_images
6506 void __ovld __conv intel_sub_group_block_write(write_only image2d_t image, int2 coord, uint data);
6507 void __ovld __conv intel_sub_group_block_write2(write_only image2d_t image, int2 coord, uint2 data);
6508 void __ovld __conv intel_sub_group_block_write4(write_only image2d_t image, int2 coord, uint4 data);
6509 void __ovld __conv intel_sub_group_block_write8(write_only image2d_t image, int2 coord, uint8 data);
6510+#endif //__opencl_c_images
6511
6512 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6513+#ifdef __opencl_c_images
6514+#ifdef __opencl_c_read_write_images
6515 void __ovld __conv intel_sub_group_block_write(read_write image2d_t image, int2 coord, uint data);
6516 void __ovld __conv intel_sub_group_block_write2(read_write image2d_t image, int2 coord, uint2 data);
6517 void __ovld __conv intel_sub_group_block_write4(read_write image2d_t image, int2 coord, uint4 data);
6518 void __ovld __conv intel_sub_group_block_write8(read_write image2d_t image, int2 coord, uint8 data);
6519+#endif // __opencl_c_read_write_images
6520+#endif // __opencl_c_images
6521 #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6522
6523 void __ovld __conv intel_sub_group_block_write( __global uint* p, uint data );
6524@@ -15611,7 +17681,7 @@ half __ovld __conv intel_sub_group_shuffle_up( half prev, half cur, uint c );
6525 half __ovld __conv intel_sub_group_shuffle_xor( half x, uint c );
6526 #endif
6527
6528-#if defined(cl_khr_fp64)
6529+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6530 double __ovld __conv intel_sub_group_shuffle( double x, uint c );
6531 double __ovld __conv intel_sub_group_shuffle_down( double prev, double cur, uint c );
6532 double __ovld __conv intel_sub_group_shuffle_up( double prev, double cur, uint c );
6533@@ -15710,16 +17780,22 @@ ushort __ovld __conv intel_sub_group_scan_inclusive_min( ushort x );
6534 short __ovld __conv intel_sub_group_scan_inclusive_max( short x );
6535 ushort __ovld __conv intel_sub_group_scan_inclusive_max( ushort x );
6536
6537+#ifdef __opencl_c_images
6538 uint __ovld __conv intel_sub_group_block_read_ui( read_only image2d_t image, int2 byte_coord );
6539 uint2 __ovld __conv intel_sub_group_block_read_ui2( read_only image2d_t image, int2 byte_coord );
6540 uint4 __ovld __conv intel_sub_group_block_read_ui4( read_only image2d_t image, int2 byte_coord );
6541 uint8 __ovld __conv intel_sub_group_block_read_ui8( read_only image2d_t image, int2 byte_coord );
6542+#endif //__opencl_c_images
6543
6544 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6545+#ifdef __opencl_c_images
6546+#ifdef __opencl_c_read_write_images
6547 uint __ovld __conv intel_sub_group_block_read_ui( read_write image2d_t image, int2 byte_coord );
6548 uint2 __ovld __conv intel_sub_group_block_read_ui2( read_write image2d_t image, int2 byte_coord );
6549 uint4 __ovld __conv intel_sub_group_block_read_ui4( read_write image2d_t image, int2 byte_coord );
6550 uint8 __ovld __conv intel_sub_group_block_read_ui8( read_write image2d_t image, int2 byte_coord );
6551+#endif //__opencl_c_read_write_images
6552+#endif //__opencl_c_images
6553 #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6554
6555 uint __ovld __conv intel_sub_group_block_read_ui( const __global uint* p );
6556@@ -15727,16 +17803,22 @@ uint2 __ovld __conv intel_sub_group_block_read_ui2( const __global uint* p
6557 uint4 __ovld __conv intel_sub_group_block_read_ui4( const __global uint* p );
6558 uint8 __ovld __conv intel_sub_group_block_read_ui8( const __global uint* p );
6559
6560+#ifdef __opencl_c_images
6561 void __ovld __conv intel_sub_group_block_write_ui( read_only image2d_t image, int2 byte_coord, uint data );
6562 void __ovld __conv intel_sub_group_block_write_ui2( read_only image2d_t image, int2 byte_coord, uint2 data );
6563 void __ovld __conv intel_sub_group_block_write_ui4( read_only image2d_t image, int2 byte_coord, uint4 data );
6564 void __ovld __conv intel_sub_group_block_write_ui8( read_only image2d_t image, int2 byte_coord, uint8 data );
6565+#endif //__opencl_c_images
6566
6567 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6568+#ifdef __opencl_c_images
6569+#ifdef __opencl_c_read_write_images
6570 void __ovld __conv intel_sub_group_block_write_ui( read_write image2d_t image, int2 byte_coord, uint data );
6571 void __ovld __conv intel_sub_group_block_write_ui2( read_write image2d_t image, int2 byte_coord, uint2 data );
6572 void __ovld __conv intel_sub_group_block_write_ui4( read_write image2d_t image, int2 byte_coord, uint4 data );
6573 void __ovld __conv intel_sub_group_block_write_ui8( read_write image2d_t image, int2 byte_coord, uint8 data );
6574+#endif //__opencl_c_read_write_images
6575+#endif //__opencl_c_images
6576 #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6577
6578 void __ovld __conv intel_sub_group_block_write_ui( __global uint* p, uint data );
6579@@ -15744,16 +17826,22 @@ void __ovld __conv intel_sub_group_block_write_ui2( __global uint* p, uint
6580 void __ovld __conv intel_sub_group_block_write_ui4( __global uint* p, uint4 data );
6581 void __ovld __conv intel_sub_group_block_write_ui8( __global uint* p, uint8 data );
6582
6583+#ifdef __opencl_c_images
6584 ushort __ovld __conv intel_sub_group_block_read_us( read_only image2d_t image, int2 coord );
6585 ushort2 __ovld __conv intel_sub_group_block_read_us2( read_only image2d_t image, int2 coord );
6586 ushort4 __ovld __conv intel_sub_group_block_read_us4( read_only image2d_t image, int2 coord );
6587 ushort8 __ovld __conv intel_sub_group_block_read_us8( read_only image2d_t image, int2 coord );
6588+#endif //__opencl_c_images
6589
6590 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6591+#ifdef __opencl_c_images
6592+#ifdef __opencl_c_read_write_images
6593 ushort __ovld __conv intel_sub_group_block_read_us(read_write image2d_t image, int2 coord);
6594 ushort2 __ovld __conv intel_sub_group_block_read_us2(read_write image2d_t image, int2 coord);
6595 ushort4 __ovld __conv intel_sub_group_block_read_us4(read_write image2d_t image, int2 coord);
6596 ushort8 __ovld __conv intel_sub_group_block_read_us8(read_write image2d_t image, int2 coord);
6597+#endif //__opencl_c_read_write_images
6598+#endif //__opencl_c_images
6599 #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6600
6601 ushort __ovld __conv intel_sub_group_block_read_us( const __global ushort* p );
6602@@ -15761,16 +17849,22 @@ ushort2 __ovld __conv intel_sub_group_block_read_us2( const __global ushort*
6603 ushort4 __ovld __conv intel_sub_group_block_read_us4( const __global ushort* p );
6604 ushort8 __ovld __conv intel_sub_group_block_read_us8( const __global ushort* p );
6605
6606+#ifdef __opencl_c_images
6607 void __ovld __conv intel_sub_group_block_write_us(write_only image2d_t image, int2 coord, ushort data);
6608 void __ovld __conv intel_sub_group_block_write_us2(write_only image2d_t image, int2 coord, ushort2 data);
6609 void __ovld __conv intel_sub_group_block_write_us4(write_only image2d_t image, int2 coord, ushort4 data);
6610 void __ovld __conv intel_sub_group_block_write_us8(write_only image2d_t image, int2 coord, ushort8 data);
6611+#endif //__opencl_c_images
6612
6613 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6614+#ifdef __opencl_c_images
6615+#ifdef __opencl_c_read_write_images
6616 void __ovld __conv intel_sub_group_block_write_us(read_write image2d_t image, int2 coord, ushort data);
6617 void __ovld __conv intel_sub_group_block_write_us2(read_write image2d_t image, int2 coord, ushort2 data);
6618 void __ovld __conv intel_sub_group_block_write_us4(read_write image2d_t image, int2 coord, ushort4 data);
6619 void __ovld __conv intel_sub_group_block_write_us8(read_write image2d_t image, int2 coord, ushort8 data);
6620+#endif //__opencl_c_read_write_images
6621+#endif //__opencl_c_images
6622 #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6623
6624 void __ovld __conv intel_sub_group_block_write_us( __global ushort* p, ushort data );
6625@@ -15889,6 +17983,7 @@ short2 __ovld intel_sub_group_avc_ime_adjust_ref_offset(
6626 short2 ref_offset, ushort2 src_coord, ushort2 ref_window_size,
6627 ushort2 image_size);
6628
6629+#ifdef __opencl_c_images
6630 intel_sub_group_avc_ime_result_t __ovld
6631 intel_sub_group_avc_ime_evaluate_with_single_reference(
6632 read_only image2d_t src_image, read_only image2d_t ref_image,
6633@@ -15929,6 +18024,7 @@ intel_sub_group_avc_ime_evaluate_with_dual_reference_streaminout(
6634 read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,
6635 intel_sub_group_avc_ime_payload_t payload,
6636 intel_sub_group_avc_ime_dual_reference_streamin_t streamin_components);
6637+#endif //__opencl_c_images
6638
6639 intel_sub_group_avc_ime_single_reference_streamin_t __ovld
6640 intel_sub_group_avc_ime_get_single_reference_streamin(
6641@@ -15993,6 +18089,7 @@ intel_sub_group_avc_ref_payload_t __ovld
6642 intel_sub_group_avc_ref_set_bilinear_filter_enable(
6643 intel_sub_group_avc_ref_payload_t payload);
6644
6645+#ifdef __opencl_c_images
6646 intel_sub_group_avc_ref_result_t __ovld
6647 intel_sub_group_avc_ref_evaluate_with_single_reference(
6648 read_only image2d_t src_image, read_only image2d_t ref_image,
6649@@ -16011,6 +18108,7 @@ intel_sub_group_avc_ref_evaluate_with_multi_reference(
6650 read_only image2d_t src_image, uint packed_reference_ids,
6651 uchar packed_reference_field_polarities, sampler_t vme_media_sampler,
6652 intel_sub_group_avc_ref_payload_t payload);
6653+#endif //__opencl_c_images
6654
6655 // SIC built-in functions
6656 intel_sub_group_avc_sic_payload_t __ovld
6657@@ -16061,6 +18159,7 @@ intel_sub_group_avc_sic_set_block_based_raw_skip_sad(
6658 uchar block_based_skip_type,
6659 intel_sub_group_avc_sic_payload_t payload);
6660
6661+#ifdef __opencl_c_images
6662 intel_sub_group_avc_sic_result_t __ovld
6663 intel_sub_group_avc_sic_evaluate_ipe(
6664 read_only image2d_t src_image, sampler_t vme_media_sampler,
6665@@ -16083,6 +18182,7 @@ intel_sub_group_avc_sic_evaluate_with_multi_reference(
6666 read_only image2d_t src_image, uint packed_reference_ids,
6667 uchar packed_reference_field_polarities, sampler_t vme_media_sampler,
6668 intel_sub_group_avc_sic_payload_t payload);
6669+#endif //__opencl_c_images
6670
6671 uchar __ovld intel_sub_group_avc_sic_get_ipe_luma_shape(
6672 intel_sub_group_avc_sic_result_t result);
6673diff --git a/clang/lib/Parse/ParseDecl.cpp b/clang/lib/Parse/ParseDecl.cpp
6674index 6353e14bc41a..a8c216de6e04 100644
6675--- a/clang/lib/Parse/ParseDecl.cpp
6676+++ b/clang/lib/Parse/ParseDecl.cpp
6677@@ -3904,8 +3904,7 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
6678 isInvalid = DS.SetTypeAltiVecBool(true, Loc, PrevSpec, DiagID, Policy);
6679 break;
6680 case tok::kw_pipe:
6681- if (!getLangOpts().OpenCL || (getLangOpts().OpenCLVersion < 200 &&
6682- !getLangOpts().OpenCLCPlusPlus)) {
6683+ if (!getLangOpts().OpenCLPipeKeyword) {
6684 // OpenCL 2.0 defined this keyword. OpenCL 1.2 and earlier should
6685 // support the "pipe" word as identifier.
6686 Tok.getIdentifierInfo()->revertTokenIDToIdentifier();
6687@@ -4027,8 +4026,7 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
6688 case tok::kw___generic:
6689 // generic address space is introduced only in OpenCL v2.0
6690 // see OpenCL C Spec v2.0 s6.5.5
6691- if (Actions.getLangOpts().OpenCLVersion < 200 &&
6692- !Actions.getLangOpts().OpenCLCPlusPlus) {
6693+ if (!Actions.getLangOpts().OpenCLGenericKeyword) {
6694 DiagID = diag::err_opencl_unknown_type_specifier;
6695 PrevSpec = Tok.getIdentifierInfo()->getNameStart();
6696 isInvalid = true;
6697@@ -5050,8 +5048,7 @@ bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) {
6698 default: return false;
6699
6700 case tok::kw_pipe:
6701- return (getLangOpts().OpenCL && getLangOpts().OpenCLVersion >= 200) ||
6702- getLangOpts().OpenCLCPlusPlus;
6703+ return getLangOpts().OpenCLPipeKeyword;
6704
6705 case tok::identifier: // foo::bar
6706 // Unfortunate hack to support "Class.factoryMethod" notation.
6707@@ -5557,8 +5554,7 @@ static bool isPtrOperatorToken(tok::TokenKind Kind, const LangOptions &Lang,
6708 if (Kind == tok::star || Kind == tok::caret)
6709 return true;
6710
6711- if (Kind == tok::kw_pipe &&
6712- ((Lang.OpenCL && Lang.OpenCLVersion >= 200) || Lang.OpenCLCPlusPlus))
6713+ if (Kind == tok::kw_pipe && Lang.OpenCLPipeKeyword)
6714 return true;
6715
6716 if (!Lang.CPlusPlus)
6717diff --git a/clang/lib/Parse/ParsePragma.cpp b/clang/lib/Parse/ParsePragma.cpp
6718index df411e1928d6..9a40ce888695 100644
6719--- a/clang/lib/Parse/ParsePragma.cpp
6720+++ b/clang/lib/Parse/ParsePragma.cpp
6721@@ -697,12 +697,14 @@ void Parser::HandlePragmaOpenCLExtension() {
6722 if (Name == "all") {
6723 if (State == Disable) {
6724 Opt.disableAll();
6725- Opt.enableSupportedCore(getLangOpts());
6726+ Opt.enableSupportedCore();
6727 } else {
6728 PP.Diag(NameLoc, diag::warn_pragma_expected_predicate) << 1;
6729 }
6730+ } else if (Opt.isFeature(Name)) {
6731+ PP.Diag(NameLoc, diag::warn_opencl_pragma_feature_ignore) << Ident;
6732 } else if (State == Begin) {
6733- if (!Opt.isKnown(Name) || !Opt.isSupported(Name, getLangOpts())) {
6734+ if (!Opt.isKnown(Name) || !Opt.isSupported(Name)) {
6735 Opt.support(Name);
6736 }
6737 Actions.setCurrentOpenCLExtension(Name);
6738@@ -712,9 +714,9 @@ void Parser::HandlePragmaOpenCLExtension() {
6739 Actions.setCurrentOpenCLExtension("");
6740 } else if (!Opt.isKnown(Name))
6741 PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << Ident;
6742- else if (Opt.isSupportedExtension(Name, getLangOpts()))
6743+ else if (Opt.isSupportedExtension(Name))
6744 Opt.enable(Name, State == Enable);
6745- else if (Opt.isSupportedCore(Name, getLangOpts()))
6746+ else if (Opt.isSupportedCore(Name))
6747 PP.Diag(NameLoc, diag::warn_pragma_extension_is_core) << Ident;
6748 else
6749 PP.Diag(NameLoc, diag::warn_pragma_unsupported_extension) << Ident;
6750diff --git a/clang/lib/Sema/OpenCLBuiltins.td b/clang/lib/Sema/OpenCLBuiltins.td
6751index 9d6bb411eff8..d352d35f1e46 100644
6752--- a/clang/lib/Sema/OpenCLBuiltins.td
6753+++ b/clang/lib/Sema/OpenCLBuiltins.td
6754@@ -22,11 +22,13 @@
6755 class Version<int _Version> {
6756 int ID = _Version;
6757 }
6758+
6759 def CLAll : Version< 0>;
6760 def CL10 : Version<100>;
6761 def CL11 : Version<110>;
6762 def CL12 : Version<120>;
6763 def CL20 : Version<200>;
6764+def CL30 : Version<300>;
6765
6766 // Address spaces
6767 // Pointer types need to be assigned an address space.
6768@@ -65,6 +67,14 @@ def FuncExtKhrGlMsaaSharing : FunctionExtension<"cl_khr_gl_msaa_sha
6769 // Multiple extensions
6770 def FuncExtKhrMipmapAndWrite3d : FunctionExtension<"cl_khr_mipmap_image cl_khr_3d_image_writes">;
6771
6772+// Features
6773+def FuncExtGenericAddressSpace : FunctionExtension<"__opencl_c_generic_address_space">;
6774+def FuncExtWorkGroupCollective : FunctionExtension<"__opencl_c_work_group_collective_functions">;
6775+def FuncExtPipes : FunctionExtension<"__opencl_c_pipes">;
6776+def FuncExtDeviceSidEenqueue : FunctionExtension<"__opencl_c_device_enqueue">;
6777+def FuncNonExplicitAtomicFeatures : FunctionExtension<"__opencl_c_atomic_order_seq_cst __opencl_c_atomic_scope_device">;
6778+def FuncNonExplicitAtomicFeaturesAndGenericAS : FunctionExtension<"__opencl_c_atomic_order_seq_cst __opencl_c_atomic_scope_device __opencl_c_generic_address_space">;
6779+
6780 // Qualified Type. These map to ASTContext::QualType.
6781 class QualType<string _Name, bit _IsAbstract=0> {
6782 // Name of the field or function in a clang::ASTContext
6783@@ -230,13 +240,9 @@ class Builtin<string _Name, list<Type> _Signature, list<bit> _Attributes = Attr.
6784 bit IsConv = _Attributes[2];
6785 // OpenCL extensions to which the function belongs.
6786 FunctionExtension Extension = FuncExtNone;
6787- // Version of OpenCL from which the function is available (e.g.: CL10).
6788- // MinVersion is inclusive.
6789- Version MinVersion = CL10;
6790- // Version of OpenCL from which the function is not supported anymore.
6791- // MaxVersion is exclusive.
6792+ // List of OpenCL version in which this function available.
6793 // CLAll makes the function available for all versions.
6794- Version MaxVersion = CLAll;
6795+ list<Version> Versions = [CLAll];
6796 }
6797
6798 //===----------------------------------------------------------------------===//
6799@@ -398,7 +404,7 @@ foreach name = ["get_global_size", "get_global_id", "get_local_size",
6800 def : Builtin<name, [Size, UInt], Attr.Const>;
6801 }
6802
6803-let MinVersion = CL20 in {
6804+let Versions = [CL20, CL30] in {
6805 def : Builtin<"get_enqueued_local_size", [Size, UInt]>;
6806 foreach name = ["get_global_linear_id", "get_local_linear_id"] in {
6807 def : Builtin<name, [Size]>;
6808@@ -471,7 +477,7 @@ foreach name = ["fma", "mad"] in {
6809 }
6810
6811 // --- Version dependent ---
6812-let MaxVersion = CL20 in {
6813+let Versions = [CL10, CL11, CL12, CL30] in {
6814 foreach AS = [GlobalAS, LocalAS, PrivateAS] in {
6815 foreach name = ["fract", "modf", "sincos"] in {
6816 def : Builtin<name, [FGenTypeN, FGenTypeN, PointerType<FGenTypeN, AS>]>;
6817@@ -488,7 +494,9 @@ let MaxVersion = CL20 in {
6818 }
6819 }
6820 }
6821-let MinVersion = CL20 in {
6822+
6823+let Versions = [CL20, CL30] in {
6824+ let Extension = FuncExtGenericAddressSpace in {
6825 foreach name = ["fract", "modf", "sincos"] in {
6826 def : Builtin<name, [FGenTypeN, FGenTypeN, PointerType<FGenTypeN, GenericAS>]>;
6827 }
6828@@ -501,6 +509,7 @@ let MinVersion = CL20 in {
6829 def : Builtin<name, [Type, Type, Type, PointerType<GenTypeIntVecAndScalar, GenericAS>]>;
6830 }
6831 }
6832+ }
6833 }
6834
6835 // --- Table 9 ---
6836@@ -531,7 +540,7 @@ foreach name = ["abs"] in {
6837 foreach name = ["clz", "popcount"] in {
6838 def : Builtin<name, [AIGenTypeN, AIGenTypeN], Attr.Const>;
6839 }
6840-let MinVersion = CL20 in {
6841+let Versions = [CL20, CL30] in {
6842 foreach name = ["ctz"] in {
6843 def : Builtin<name, [AIGenTypeN, AIGenTypeN]>;
6844 }
6845@@ -705,7 +714,7 @@ foreach name = ["select"] in {
6846 // --- Table 15 ---
6847 // Variants for OpenCL versions below 2.0, using pointers to the global, local
6848 // and private address spaces.
6849-let MaxVersion = CL20 in {
6850+let Versions = [CL10, CL11, CL12, CL30] in {
6851 foreach AS = [GlobalAS, LocalAS, PrivateAS] in {
6852 foreach VSize = [2, 3, 4, 8, 16] in {
6853 foreach name = ["vload" # VSize] in {
6854@@ -748,7 +757,8 @@ let MaxVersion = CL20 in {
6855 }
6856 // Variants for OpenCL versions above 2.0, using pointers to the generic
6857 // address space.
6858-let MinVersion = CL20 in {
6859+let Versions = [CL20, CL30] in {
6860+ let Extension = FuncExtGenericAddressSpace in {
6861 foreach VSize = [2, 3, 4, 8, 16] in {
6862 foreach name = ["vload" # VSize] in {
6863 def : Builtin<name, [VectorType<Char, VSize>, Size, PointerType<ConstType<Char>, GenericAS>]>;
6864@@ -786,6 +796,7 @@ let MinVersion = CL20 in {
6865 }
6866 }
6867 }
6868+ }
6869 }
6870 // Variants using pointers to the constant address space.
6871 foreach VSize = [2, 3, 4, 8, 16] in {
6872@@ -812,7 +823,7 @@ foreach VSize = [2, 3, 4, 8, 16] in {
6873 }
6874 }
6875 }
6876-let MaxVersion = CL20 in {
6877+let Versions = [CL10, CL11, CL12, CL30] in {
6878 foreach AS = [GlobalAS, LocalAS, PrivateAS] in {
6879 def : Builtin<"vload_half", [Float, Size, PointerType<ConstType<Half>, AS>]>;
6880 foreach VSize = [2, 3, 4, 8, 16] in {
6881@@ -832,7 +843,8 @@ let MaxVersion = CL20 in {
6882 }
6883 }
6884 }
6885-let MinVersion = CL20 in {
6886+let Versions = [CL20, CL30] in {
6887+ let Extension = FuncExtGenericAddressSpace in {
6888 foreach AS = [GenericAS] in {
6889 def : Builtin<"vload_half", [Float, Size, PointerType<ConstType<Half>, AS>]>;
6890 foreach VSize = [2, 3, 4, 8, 16] in {
6891@@ -851,6 +863,7 @@ let MinVersion = CL20 in {
6892 }
6893 }
6894 }
6895+ }
6896 }
6897
6898 foreach AS = [ConstantAS] in {
6899@@ -875,7 +888,9 @@ foreach name = ["async_work_group_strided_copy"] in {
6900 def : Builtin<name, [Event, PointerType<AGenTypeN, GlobalAS>, PointerType<ConstType<AGenTypeN>, LocalAS>, Size, Size, Event]>;
6901 }
6902 foreach name = ["wait_group_events"] in {
6903+ let Extension = FuncExtGenericAddressSpace in {
6904 def : Builtin<name, [Void, Int, PointerType<Event, GenericAS>]>;
6905+ }
6906 }
6907 foreach name = ["prefetch"] in {
6908 def : Builtin<name, [Void, PointerType<ConstType<AGenTypeN>, GlobalAS>, Size]>;
6909@@ -1154,7 +1169,8 @@ foreach aQual = ["WO", "RW"] in {
6910 //--------------------------------------------------------------------
6911 // OpenCL v2.0 s6.13.15 - Work-group Functions
6912 // --- Table 26 ---
6913-let MinVersion = CL20 in {
6914+let Versions = [CL20, CL30] in {
6915+ let Extension = FuncExtWorkGroupCollective in {
6916 foreach name = ["work_group_all", "work_group_any"] in {
6917 def : Builtin<name, [Int, Int], Attr.Convergent>;
6918 }
6919@@ -1169,11 +1185,12 @@ let MinVersion = CL20 in {
6920 def : Builtin<name # op, [IntLongFloatGenType1, IntLongFloatGenType1], Attr.Convergent>;
6921 }
6922 }
6923+ }
6924 }
6925
6926
6927 // OpenCL v2.0 s9.17.3: Additions to section 6.13.1: Work-Item Functions
6928-let MinVersion = CL20 in {
6929+let Versions = [CL20] in {
6930 let Extension = FuncExtKhrSubgroups in {
6931 def get_sub_group_size : Builtin<"get_sub_group_size", [UInt]>;
6932 def get_max_sub_group_size : Builtin<"get_max_sub_group_size", [UInt]>;
6933diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp
6934index 9cfce5a63b1d..c26f45f62668 100644
6935--- a/clang/lib/Sema/Sema.cpp
6936+++ b/clang/lib/Sema/Sema.cpp
6937@@ -286,9 +286,10 @@ void Sema::Initialize() {
6938 // Initialize predefined OpenCL types and supported extensions and (optional)
6939 // core features.
6940 if (getLangOpts().OpenCL) {
6941+ getOpenCLOptions().setOpenCLVersion(getLangOpts());
6942 getOpenCLOptions().addSupport(
6943 Context.getTargetInfo().getSupportedOpenCLOpts());
6944- getOpenCLOptions().enableSupportedCore(getLangOpts());
6945+ getOpenCLOptions().enableSupportedCore();
6946 addImplicitTypedef("sampler_t", Context.OCLSamplerTy);
6947 addImplicitTypedef("event_t", Context.OCLEventTy);
6948 if (getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) {
6949@@ -344,12 +345,18 @@ void Sema::Initialize() {
6950 "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics");
6951
6952 setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64");
6953+ setOpenCLExtensionForType(Context.OCLReserveIDTy, "__opencl_c_pipes");
6954+ setOpenCLExtensionForType(Context.OCLClkEventTy,
6955+ "__opencl_c_device_enqueue");
6956+ setOpenCLExtensionForType(Context.OCLQueueTy,
6957+ "__opencl_c_device_enqueue");
6958 }
6959
6960 setOpenCLExtensionForType(Context.DoubleTy, "cl_khr_fp64");
6961
6962-#define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \
6963- setOpenCLExtensionForType(Context.Id, Ext);
6964+#define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \
6965+ setOpenCLExtensionForType(Context.Id, Ext); \
6966+ setOpenCLExtensionForType(Context.Id, "__opencl_c_images");
6967 #include "clang/Basic/OpenCLImageTypes.def"
6968 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
6969 addImplicitTypedef(#ExtType, Context.Id##Ty); \
6970@@ -2293,6 +2300,27 @@ bool Sema::isOpenCLDisabledDecl(Decl *FD) {
6971 return false;
6972 }
6973
6974+template <typename DiagLocT, typename DiagInfoT>
6975+void Sema::DiagnoseOpenCLRequiresOption(llvm::StringRef OpenCLOptName,
6976+ DiagLocT DiagLoc, DiagInfoT DiagInfo,
6977+ unsigned Selector,
6978+ SourceRange SrcRange) {
6979+ const auto &LO = getLangOpts();
6980+ auto CLVer = LO.OpenCLCPlusPlus ? 200 : LO.OpenCLVersion;
6981+ // For versions higher that 3.0 diagnosing feature
6982+ if (CLVer >= 300) {
6983+ OpenCLOptName =
6984+ llvm::StringSwitch<llvm::StringRef>(OpenCLOptName)
6985+ .Case("cl_khr_3d_image_writes", "__opencl_c_3d_image_writes")
6986+ .Case("cl_khr_subgroups", "__opencl_c_subgroups")
6987+ .Case("cl_khr_fp64", "__opencl_c_fp64")
6988+ .Default(OpenCLOptName);
6989+ }
6990+
6991+ Diag(DiagLoc, diag::err_opencl_requires_extension)
6992+ << Selector << DiagInfo << OpenCLOptName << SrcRange;
6993+}
6994+
6995 template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
6996 bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
6997 DiagInfoT DiagInfo, MapT &Map,
6998@@ -2304,8 +2332,7 @@ bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
6999 bool Disabled = false;
7000 for (auto &I : Loc->second) {
7001 if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
7002- Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
7003- << I << SrcRange;
7004+ DiagnoseOpenCLRequiresOption(I, DiagLoc, DiagInfo, Selector, SrcRange);
7005 Disabled = true;
7006 }
7007 }
7008@@ -2341,3 +2368,13 @@ bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) {
7009 return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
7010 OpenCLDeclExtMap, 1, D.getSourceRange());
7011 }
7012+
7013+bool Sema::checkOpenCLSubgroupExtForCallExpr(CallExpr *Call) {
7014+ if (!getOpenCLOptions().isEnabled("cl_khr_subgroups")) {
7015+ DiagnoseOpenCLRequiresOption("cl_khr_subgroups", Call->getBeginLoc(),
7016+ Call->getDirectCallee(), 1,
7017+ Call->getSourceRange());
7018+ return true;
7019+ }
7020+ return false;
7021+}
7022diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
7023index 74742023d1b3..efa3b6ab0eb6 100644
7024--- a/clang/lib/Sema/SemaChecking.cpp
7025+++ b/clang/lib/Sema/SemaChecking.cpp
7026@@ -597,20 +597,11 @@ static bool checkOpenCLBlockArgs(Sema &S, Expr *BlockArg) {
7027 return IllegalParams;
7028 }
7029
7030-static bool checkOpenCLSubgroupExt(Sema &S, CallExpr *Call) {
7031- if (!S.getOpenCLOptions().isEnabled("cl_khr_subgroups")) {
7032- S.Diag(Call->getBeginLoc(), diag::err_opencl_requires_extension)
7033- << 1 << Call->getDirectCallee() << "cl_khr_subgroups";
7034- return true;
7035- }
7036- return false;
7037-}
7038-
7039 static bool SemaOpenCLBuiltinNDRangeAndBlock(Sema &S, CallExpr *TheCall) {
7040 if (checkArgCount(S, TheCall, 2))
7041 return true;
7042
7043- if (checkOpenCLSubgroupExt(S, TheCall))
7044+ if (S.checkOpenCLSubgroupExtForCallExpr(TheCall))
7045 return true;
7046
7047 // First argument is an ndrange_t type.
7048@@ -1564,7 +1555,7 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
7049 break;
7050 case Builtin::BIsub_group_reserve_read_pipe:
7051 case Builtin::BIsub_group_reserve_write_pipe:
7052- if (checkOpenCLSubgroupExt(*this, TheCall) ||
7053+ if (checkOpenCLSubgroupExtForCallExpr(TheCall) ||
7054 SemaBuiltinReserveRWPipe(*this, TheCall))
7055 return ExprError();
7056 break;
7057@@ -1577,7 +1568,7 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
7058 break;
7059 case Builtin::BIsub_group_commit_read_pipe:
7060 case Builtin::BIsub_group_commit_write_pipe:
7061- if (checkOpenCLSubgroupExt(*this, TheCall) ||
7062+ if (checkOpenCLSubgroupExtForCallExpr(TheCall) ||
7063 SemaBuiltinCommitRWPipe(*this, TheCall))
7064 return ExprError();
7065 break;
7066@@ -4314,6 +4305,20 @@ DiagnoseCStringFormatDirectiveInCFAPI(Sema &S,
7067 }
7068 }
7069
7070+bool Sema::isSupportedOpenCLOMemoryOrdering(int64_t Ordering) const {
7071+ assert(llvm::isValidAtomicOrderingCABI(Ordering));
7072+ auto OrderingCABI = (llvm::AtomicOrderingCABI)Ordering;
7073+ switch (OrderingCABI) {
7074+ case llvm::AtomicOrderingCABI::acquire:
7075+ case llvm::AtomicOrderingCABI::release:
7076+ case llvm::AtomicOrderingCABI::acq_rel:
7077+ return OpenCLFeatures.isEnabled("__opencl_c_atomic_order_acq_rel");
7078+
7079+ default:
7080+ return true;
7081+ }
7082+}
7083+
7084 /// Determine whether the given type has a non-null nullability annotation.
7085 static bool isNonNullType(ASTContext &ctx, QualType type) {
7086 if (auto nullability = type->getNullability(ctx))
7087@@ -5067,10 +5072,17 @@ ExprResult Sema::BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
7088 if (SubExprs.size() >= 2 && Form != Init) {
7089 llvm::APSInt Result(32);
7090 if (SubExprs[1]->isIntegerConstantExpr(Result, Context) &&
7091- !isValidOrderingForOp(Result.getSExtValue(), Op))
7092+ !isValidOrderingForOp(Result.getSExtValue(), Op)) {
7093 Diag(SubExprs[1]->getBeginLoc(),
7094 diag::warn_atomic_op_has_invalid_memory_order)
7095 << SubExprs[1]->getSourceRange();
7096+ } else if (IsOpenCL &&
7097+ !isSupportedOpenCLOMemoryOrdering(Result.getSExtValue())) {
7098+ Diag(SubExprs[1]->getBeginLoc(),
7099+ diag::err_opencl_memory_ordering_require_feat)
7100+ << SubExprs[1]->getSourceRange();
7101+ return ExprError();
7102+ }
7103 }
7104
7105 if (auto ScopeModel = AtomicExpr::getScopeModel(Op)) {
7106diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
7107index 64146f4a912f..c1e629b5dc76 100644
7108--- a/clang/lib/Sema/SemaDecl.cpp
7109+++ b/clang/lib/Sema/SemaDecl.cpp
7110@@ -6152,7 +6152,9 @@ void Sema::deduceOpenCLAddressSpace(ValueDecl *Decl) {
7111 if (Type->isSamplerT() || Type->isVoidType())
7112 return;
7113 LangAS ImplAS = LangAS::opencl_private;
7114- if ((getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) &&
7115+ if ((getLangOpts().OpenCLCPlusPlus ||
7116+ getOpenCLOptions().isEnabled(
7117+ "__opencl_c_program_scope_global_variables")) &&
7118 Var->hasGlobalStorage())
7119 ImplAS = LangAS::opencl_global;
7120 // If the original type from a decayed type is an array type and that array
7121@@ -7682,6 +7684,10 @@ void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {
7122 // OpenCL C v2.0 s6.5.1 - Variables defined at program scope and static
7123 // variables inside a function can also be declared in the global
7124 // address space.
7125+ // OpenCL C v3.0 s5.5 - For OpenCL C 2.0, or with the
7126+ // __opencl_c_program_scope_global_variables feature macro, the
7127+ // address space for a variable at program scope or a static variable
7128+ // also be __global
7129 // C++ for OpenCL inherits rule from OpenCL C v2.0.
7130 // FIXME: Adding local AS in C++ for OpenCL might make sense.
7131 if (NewVD->isFileVarDecl() || NewVD->isStaticLocal() ||
7132@@ -7689,10 +7695,11 @@ void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {
7133 if (!T->isSamplerT() &&
7134 !(T.getAddressSpace() == LangAS::opencl_constant ||
7135 (T.getAddressSpace() == LangAS::opencl_global &&
7136- (getLangOpts().OpenCLVersion == 200 ||
7137- getLangOpts().OpenCLCPlusPlus)))) {
7138+ (OpenCLFeatures.isEnabled(
7139+ "__opencl_c_program_scope_global_variables"))))) {
7140 int Scope = NewVD->isStaticLocal() | NewVD->hasExternalStorage() << 1;
7141- if (getLangOpts().OpenCLVersion == 200 || getLangOpts().OpenCLCPlusPlus)
7142+ if (OpenCLFeatures.isEnabled(
7143+ "__opencl_c_program_scope_global_variables"))
7144 Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space)
7145 << Scope << "global or constant";
7146 else
7147diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp
7148index 849bc09063b3..c963b95b131a 100644
7149--- a/clang/lib/Sema/SemaDeclAttr.cpp
7150+++ b/clang/lib/Sema/SemaDeclAttr.cpp
7151@@ -6362,7 +6362,7 @@ static void handleInternalLinkageAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
7152 }
7153
7154 static void handleOpenCLNoSVMAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
7155- if (S.LangOpts.OpenCLVersion != 200)
7156+ if (S.LangOpts.OpenCLVersion < 200)
7157 S.Diag(AL.getLoc(), diag::err_attribute_requires_opencl_version)
7158 << AL << "2.0" << 0;
7159 else
7160@@ -6446,6 +6446,13 @@ static void handleOpenCLAccessAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
7161 << AL << PDecl->getType() << DeclTy->isImageType();
7162 D->setInvalidDecl(true);
7163 return;
7164+ } else if ((!S.getLangOpts().OpenCLCPlusPlus &&
7165+ S.getLangOpts().OpenCLVersion >= 200) &&
7166+ !S.getOpenCLOptions().isEnabled(
7167+ "__opencl_c_read_write_images")) {
7168+ S.Diag(AL.getLoc(), diag::err_opencl_requires_extension)
7169+ << 0 << PDecl->getType() << "__opencl_c_read_write_images";
7170+ return;
7171 }
7172 }
7173 }
7174diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
7175index 831e55046e80..4481a59b4517 100644
7176--- a/clang/lib/Sema/SemaDeclCXX.cpp
7177+++ b/clang/lib/Sema/SemaDeclCXX.cpp
7178@@ -14906,6 +14906,11 @@ CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl,
7179 if (auto *PtrTy = ResultType->getAs<PointerType>()) {
7180 ResultType = RemoveAddressSpaceFromPtr(SemaRef, PtrTy);
7181 }
7182+ if (CanQual<PointerType> ExpectedPtrTy =
7183+ ExpectedResultType->getAs<PointerType>()) {
7184+ ExpectedResultType = SemaRef.Context.getCanonicalType(
7185+ RemoveAddressSpaceFromPtr(SemaRef, ExpectedPtrTy->getTypePtr()));
7186+ }
7187 }
7188
7189 // Check that the result type is what we expect.
7190@@ -14939,6 +14944,11 @@ CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl,
7191 FnDecl->getParamDecl(0)->getType()->getAs<PointerType>()) {
7192 FirstParamType = RemoveAddressSpaceFromPtr(SemaRef, PtrTy);
7193 }
7194+ if (CanQual<PointerType> ExpectedPtrTy =
7195+ ExpectedFirstParamType->getAs<PointerType>()) {
7196+ ExpectedFirstParamType = SemaRef.Context.getCanonicalType(
7197+ RemoveAddressSpaceFromPtr(SemaRef, ExpectedPtrTy->getTypePtr()));
7198+ }
7199 }
7200 if (SemaRef.Context.getCanonicalType(FirstParamType).getUnqualifiedType() !=
7201 ExpectedFirstParamType)
7202diff --git a/clang/lib/Sema/SemaLookup.cpp b/clang/lib/Sema/SemaLookup.cpp
7203index 8d96404a5c27..8f21203b9508 100644
7204--- a/clang/lib/Sema/SemaLookup.cpp
7205+++ b/clang/lib/Sema/SemaLookup.cpp
7206@@ -771,19 +771,20 @@ static void InsertOCLBuiltinDeclarationsFromTable(Sema &S, LookupResult &LR,
7207 // as argument. Only meaningful for generic types, otherwise equals 1.
7208 unsigned GenTypeMaxCnt;
7209
7210+ ASTContext &Context = S.Context;
7211+
7212+ // Ignore this BIF if its version does not match the language options.
7213+ unsigned OpenCLVersion = Context.getLangOpts().OpenCLVersion;
7214+ if (Context.getLangOpts().OpenCLCPlusPlus)
7215+ OpenCLVersion = 200;
7216+
7217+ unsigned short VersionCode = OpenCLOptions::EncodeVersion(OpenCLVersion);
7218+
7219 for (unsigned SignatureIndex = 0; SignatureIndex < Len; SignatureIndex++) {
7220 const OpenCLBuiltinStruct &OpenCLBuiltin =
7221 BuiltinTable[FctIndex + SignatureIndex];
7222- ASTContext &Context = S.Context;
7223
7224- // Ignore this BIF if its version does not match the language options.
7225- unsigned OpenCLVersion = Context.getLangOpts().OpenCLVersion;
7226- if (Context.getLangOpts().OpenCLCPlusPlus)
7227- OpenCLVersion = 200;
7228- if (OpenCLVersion < OpenCLBuiltin.MinVersion)
7229- continue;
7230- if ((OpenCLBuiltin.MaxVersion != 0) &&
7231- (OpenCLVersion >= OpenCLBuiltin.MaxVersion))
7232+ if (!(OpenCLBuiltin.AllVersions & VersionCode))
7233 continue;
7234
7235 SmallVector<QualType, 1> RetTypes;
7236diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
7237index 93ddd047e09b..93211b801f8d 100644
7238--- a/clang/lib/Sema/SemaType.cpp
7239+++ b/clang/lib/Sema/SemaType.cpp
7240@@ -2016,7 +2016,7 @@ static QualType deduceOpenCLPointeeAddrSpace(Sema &S, QualType PointeeType) {
7241 !PointeeType.hasAddressSpace())
7242 PointeeType = S.getASTContext().getAddrSpaceQualType(
7243 PointeeType,
7244- S.getLangOpts().OpenCLCPlusPlus || S.getLangOpts().OpenCLVersion == 200
7245+ S.getOpenCLOptions().isEnabled("__opencl_c_generic_address_space")
7246 ? LangAS::opencl_generic
7247 : LangAS::opencl_private);
7248 return PointeeType;
7249@@ -5160,9 +5160,15 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
7250 }
7251
7252 case DeclaratorChunk::Pipe: {
7253- T = S.BuildReadPipeType(T, DeclType.Loc);
7254- processTypeAttrs(state, T, TAL_DeclSpec,
7255- D.getMutableDeclSpec().getAttributes());
7256+ if (S.getOpenCLOptions().isEnabled("__opencl_c_pipes")) {
7257+ T = S.BuildReadPipeType(T, DeclType.Loc);
7258+ processTypeAttrs(state, T, TAL_DeclSpec,
7259+ D.getMutableDeclSpec().getAttributes());
7260+ } else {
7261+ D.setInvalidType(true);
7262+ T = Context.IntTy;
7263+ S.Diag(D.getIdentifierLoc(), diag::err_opencl_pipes_require_feat);
7264+ }
7265 break;
7266 }
7267 }
7268diff --git a/clang/test/CodeGenOpenCL/addr-space-struct-arg.cl b/clang/test/CodeGenOpenCL/addr-space-struct-arg.cl
7269index cdbf28bbcad8..0bedff5ef0f3 100644
7270--- a/clang/test/CodeGenOpenCL/addr-space-struct-arg.cl
7271+++ b/clang/test/CodeGenOpenCL/addr-space-struct-arg.cl
7272@@ -2,7 +2,8 @@
7273 // RUN: %clang_cc1 %s -emit-llvm -o - -O0 -triple amdgcn | FileCheck -enable-var-scope -check-prefixes=COM,AMDGCN %s
7274 // RUN: %clang_cc1 %s -emit-llvm -o - -cl-std=CL2.0 -O0 -triple amdgcn | FileCheck -enable-var-scope -check-prefixes=COM,AMDGCN,AMDGCN20 %s
7275 // RUN: %clang_cc1 %s -emit-llvm -o - -cl-std=CL1.2 -O0 -triple spir-unknown-unknown-unknown | FileCheck -enable-var-scope -check-prefixes=SPIR %s
7276-
7277+// RUN: %clang_cc1 %s -emit-llvm -o - -cl-std=CL3.0 -O0 -triple spir-unknown-unknown-unknown | FileCheck -enable-var-scope -check-prefixes=SPIR %s
7278+// RUN: %clang_cc1 %s -emit-llvm -o - -cl-std=CL3.0 -cl-ext=__opencl_c_program_scope_global_variables -O0 -triple spir-unknown-unknown-unknown | FileCheck -enable-var-scope -check-prefixes=SPIR %s
7279 typedef int int2 __attribute__((ext_vector_type(2)));
7280
7281 typedef struct {
7282@@ -39,7 +40,7 @@ struct LargeStructTwoMember {
7283 int2 y[20];
7284 };
7285
7286-#if __OPENCL_C_VERSION__ >= 200
7287+#ifdef __opencl_c_program_scope_global_variables
7288 struct LargeStructOneMember g_s;
7289 #endif
7290
7291@@ -98,7 +99,7 @@ void FuncOneLargeMember(struct LargeStructOneMember u) {
7292 // AMDGCN20: %[[r0:.*]] = bitcast %struct.LargeStructOneMember addrspace(5)* %[[byval_temp]] to i8 addrspace(5)*
7293 // AMDGCN20: call void @llvm.memcpy.p5i8.p1i8.i64(i8 addrspace(5)* align 8 %[[r0]], i8 addrspace(1)* align 8 bitcast (%struct.LargeStructOneMember addrspace(1)* @g_s to i8 addrspace(1)*), i64 800, i1 false)
7294 // AMDGCN20: call void @FuncOneLargeMember(%struct.LargeStructOneMember addrspace(5)* byval(%struct.LargeStructOneMember) align 8 %[[byval_temp]])
7295-#if __OPENCL_C_VERSION__ >= 200
7296+#ifdef __opencl_c_program_scope_global_variables
7297 void test_indirect_arg_globl(void) {
7298 FuncOneLargeMember(g_s);
7299 }
7300diff --git a/clang/test/CodeGenOpenCL/address-spaces-conversions.cl b/clang/test/CodeGenOpenCL/address-spaces-conversions.cl
7301index 52feccc540bb..9ecffcca5ee9 100644
7302--- a/clang/test/CodeGenOpenCL/address-spaces-conversions.cl
7303+++ b/clang/test/CodeGenOpenCL/address-spaces-conversions.cl
7304@@ -1,5 +1,7 @@
7305 // RUN: %clang_cc1 %s -triple x86_64-unknown-linux-gnu -O0 -ffake-address-space-map -cl-std=CL2.0 -emit-llvm -o - | FileCheck %s
7306+// RUN: %clang_cc1 %s -triple x86_64-unknown-linux-gnu -O0 -ffake-address-space-map -cl-std=CL3.0 -cl-ext=__opencl_c_generic_address_space -emit-llvm -o - | FileCheck %s
7307 // RUN: %clang_cc1 %s -triple x86_64-unknown-linux-gnu -O0 -cl-std=CL2.0 -emit-llvm -o - | FileCheck --check-prefix=CHECK-NOFAKE %s
7308+// RUN: %clang_cc1 %s -triple x86_64-unknown-linux-gnu -O0 -cl-std=CL3.0 -cl-ext=__opencl_c_generic_address_space -emit-llvm -o - | FileCheck --check-prefix=CHECK-NOFAKE %s
7309 // When -ffake-address-space-map is not used, all addr space mapped to 0 for x86_64.
7310
7311 // test that we generate address space casts everywhere we need conversions of
7312diff --git a/clang/test/CodeGenOpenCL/address-spaces-mangling.cl b/clang/test/CodeGenOpenCL/address-spaces-mangling.cl
7313index 50622f099143..e19ec8451d0d 100644
7314--- a/clang/test/CodeGenOpenCL/address-spaces-mangling.cl
7315+++ b/clang/test/CodeGenOpenCL/address-spaces-mangling.cl
7316@@ -6,6 +6,7 @@
7317 // We check that the address spaces are mangled the same in both version of OpenCL
7318 // RUN: %clang_cc1 %s -triple spir-unknown-unknown -cl-std=CL2.0 -emit-llvm -o - | FileCheck -check-prefix=OCL-20 %s
7319 // RUN: %clang_cc1 %s -triple spir-unknown-unknown -cl-std=CL1.2 -emit-llvm -o - | FileCheck -check-prefix=OCL-12 %s
7320+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -cl-std=CL3.0 -emit-llvm -o - | FileCheck -check-prefix=OCL-12 %s
7321
7322 // We can't name this f as private is equivalent to default
7323 // no specifier given address space so we get multiple definition
7324@@ -47,7 +48,7 @@ void f(constant int *arg) { }
7325 // OCL-20-DAG: @_Z1fPU3AS2i
7326 // OCL-12-DAG: @_Z1fPU3AS2i
7327
7328-#if __OPENCL_C_VERSION__ >= 200
7329+#if __OPENCL_C_VERSION__ == 200
7330 __attribute__((overloadable))
7331 void f(generic int *arg) { }
7332 // ASMANG20: @_Z1fPU3AS4i
7333diff --git a/clang/test/CodeGenOpenCL/address-spaces.cl b/clang/test/CodeGenOpenCL/address-spaces.cl
7334index 3c8fea2a80bc..26a741338b3a 100644
7335--- a/clang/test/CodeGenOpenCL/address-spaces.cl
7336+++ b/clang/test/CodeGenOpenCL/address-spaces.cl
7337@@ -1,9 +1,13 @@
7338 // RUN: %clang_cc1 %s -O0 -ffake-address-space-map -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,SPIR
7339+// RUN: %clang_cc1 %s -O0 -cl-std=CL3.0 -ffake-address-space-map -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,SPIR
7340 // RUN: %clang_cc1 %s -O0 -DCL20 -cl-std=CL2.0 -ffake-address-space-map -emit-llvm -o - | FileCheck %s --check-prefixes=CL20,CL20SPIR
7341 // RUN: %clang_cc1 %s -O0 -triple amdgcn-amd-amdhsa -emit-llvm -o - | FileCheck --check-prefixes=CHECK,AMDGCN %s
7342+// RUN: %clang_cc1 %s -O0 -cl-std=CL3.0 -triple amdgcn-amd-amdhsa -emit-llvm -o - | FileCheck --check-prefixes=CHECK,AMDGCN %s
7343 // RUN: %clang_cc1 %s -O0 -triple amdgcn-amd-amdhsa -DCL20 -cl-std=CL2.0 -emit-llvm -o - | FileCheck %s --check-prefixes=CL20,CL20AMDGCN
7344 // RUN: %clang_cc1 %s -O0 -triple amdgcn-mesa-mesa3d -emit-llvm -o - | FileCheck --check-prefixes=CHECK,AMDGCN %s
7345+// RUN: %clang_cc1 %s -O0 -cl-std=CL3.0 -triple amdgcn-mesa-mesa3d -emit-llvm -o - | FileCheck --check-prefixes=CHECK,AMDGCN %s
7346 // RUN: %clang_cc1 %s -O0 -triple r600-- -emit-llvm -o - | FileCheck --check-prefixes=CHECK,AMDGCN %s
7347+// RUN: %clang_cc1 %s -O0 -cl-std=CL3.0 -triple r600-- -emit-llvm -o - | FileCheck --check-prefixes=CHECK,AMDGCN %s
7348
7349 // SPIR: %struct.S = type { i32, i32, i32* }
7350 // CL20SPIR: %struct.S = type { i32, i32, i32 addrspace(4)* }
7351diff --git a/clang/test/CodeGenOpenCL/amdgcn-automatic-variable.cl b/clang/test/CodeGenOpenCL/amdgcn-automatic-variable.cl
7352index 7216cb517495..8d3b30fe8074 100644
7353--- a/clang/test/CodeGenOpenCL/amdgcn-automatic-variable.cl
7354+++ b/clang/test/CodeGenOpenCL/amdgcn-automatic-variable.cl
7355@@ -1,4 +1,5 @@
7356 // RUN: %clang_cc1 -O0 -cl-std=CL1.2 -triple amdgcn---amdgizcl -emit-llvm %s -o - | FileCheck -check-prefixes=CHECK,CL12 %s
7357+// RUN: %clang_cc1 -O0 -cl-std=CL3.0 -triple amdgcn---amdgizcl -emit-llvm %s -o - | FileCheck -check-prefixes=CHECK,CL12 %s
7358 // RUN: %clang_cc1 -O0 -cl-std=CL2.0 -triple amdgcn---amdgizcl -emit-llvm %s -o - | FileCheck -check-prefixes=CHECK,CL20 %s
7359
7360 // CL12-LABEL: define void @func1(i32 addrspace(5)* %x)
7361diff --git a/clang/test/CodeGenOpenCL/amdgpu-sizeof-alignof.cl b/clang/test/CodeGenOpenCL/amdgpu-sizeof-alignof.cl
7362index a5d438933fa4..8073c7756eb6 100644
7363--- a/clang/test/CodeGenOpenCL/amdgpu-sizeof-alignof.cl
7364+++ b/clang/test/CodeGenOpenCL/amdgpu-sizeof-alignof.cl
7365@@ -4,6 +4,17 @@
7366 // RUN: %clang_cc1 -triple amdgcn---opencl -cl-std=CL2.0 %s -emit-llvm -o - | FileCheck %s
7367 // RUN: %clang_cc1 -triple amdgcn---amdgizcl -cl-std=CL1.2 %s -emit-llvm -o - | FileCheck %s
7368 // RUN: %clang_cc1 -triple amdgcn---amdgizcl -cl-std=CL2.0 %s -emit-llvm -o - | FileCheck %s
7369+// RUN: %clang_cc1 -triple r600 -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7370+// RUN: %clang_cc1 -triple amdgcn-mesa-mesa3d -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7371+// RUN: %clang_cc1 -triple amdgcn---opencl -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7372+// RUN: %clang_cc1 -triple amdgcn---amdgizcl -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7373+// RUN: %clang_cc1 -triple amdgcn-mesa-mesa3d -cl-ext=__opencl_c_generic_address_space -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7374+// RUN: %clang_cc1 -triple amdgcn---opencl -cl-ext=__opencl_c_generic_address_space -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7375+// RUN: %clang_cc1 -triple amdgcn---amdgizcl -cl-ext=__opencl_c_generic_address_space -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7376+// RUN: %clang_cc1 -triple r600 -cl-ext=__opencl_c_fp64 -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7377+// RUN: %clang_cc1 -triple amdgcn-mesa-mesa3d -cl-ext=__opencl_c_fp64 -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7378+// RUN: %clang_cc1 -triple amdgcn---opencl -cl-ext=__opencl_c_fp64 -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7379+// RUN: %clang_cc1 -triple amdgcn---amdgizcl -cl-ext=__opencl_c_fp64 -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7380
7381 #ifdef __AMDGCN__
7382 #define PTSIZE 8
7383@@ -11,7 +22,7 @@
7384 #define PTSIZE 4
7385 #endif
7386
7387-#ifdef cl_khr_fp64
7388+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
7389 #pragma OPENCL EXTENSION cl_khr_fp64 : enable
7390 #endif
7391 #ifdef cl_khr_fp16
7392@@ -59,8 +70,12 @@ void test() {
7393 check(__alignof__(double) == 8);
7394 #endif
7395
7396- check(sizeof(void*) == (__OPENCL_C_VERSION__ >= 200 ? 8 : 4));
7397- check(__alignof__(void*) == (__OPENCL_C_VERSION__ >= 200 ? 8 : 4));
7398+ check(sizeof(private void*) == 4);
7399+ check(__alignof__(private void*) == 4);
7400+#ifdef __opencl_c_generic_address_space
7401+ check(sizeof(generic void*) == 8);
7402+ check(__alignof__(generic void*) == 8);
7403+#endif
7404 check(sizeof(global_ptr_t) == PTSIZE);
7405 check(__alignof__(global_ptr_t) == PTSIZE);
7406 check(sizeof(constant_ptr_t) == PTSIZE);
7407diff --git a/clang/test/CodeGenOpenCL/arm-integer-dot-product.cl b/clang/test/CodeGenOpenCL/arm-integer-dot-product.cl
7408index d1ab6aceac5c..70c5bace023b 100644
7409--- a/clang/test/CodeGenOpenCL/arm-integer-dot-product.cl
7410+++ b/clang/test/CodeGenOpenCL/arm-integer-dot-product.cl
7411@@ -1,4 +1,5 @@
7412 // RUN: %clang_cc1 %s -triple spir-unknown-unknown -finclude-default-header -cl-std=CL1.2 -emit-llvm -o - -O0 | FileCheck %s
7413+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -finclude-default-header -cl-std=CL3.0 -emit-llvm -o - -O0 | FileCheck %s
7414
7415 #pragma OPENCL EXTENSION cl_arm_integer_dot_product_int8 : enable
7416 void test_int8(uchar4 ua, uchar4 ub, char4 sa, char4 sb) {
7417diff --git a/clang/test/CodeGenOpenCL/cl-uniform-wg-size.cl b/clang/test/CodeGenOpenCL/cl-uniform-wg-size.cl
7418index 76ace5dca21e..5dc43e222f75 100644
7419--- a/clang/test/CodeGenOpenCL/cl-uniform-wg-size.cl
7420+++ b/clang/test/CodeGenOpenCL/cl-uniform-wg-size.cl
7421@@ -1,6 +1,8 @@
7422 // RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL1.2 -o - %s 2>&1 | FileCheck %s -check-prefixes CHECK,CHECK-UNIFORM
7423 // RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL2.0 -o - %s 2>&1 | FileCheck %s -check-prefixes CHECK,CHECK-NONUNIFORM
7424 // RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL2.0 -cl-uniform-work-group-size -o - %s 2>&1 | FileCheck %s -check-prefixes CHECK,CHECK-UNIFORM
7425+// RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL3.0 -o - %s 2>&1 | FileCheck %s -check-prefixes CHECK,CHECK-NONUNIFORM
7426+// RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL3.0 -cl-uniform-work-group-size -o - %s 2>&1 | FileCheck %s -check-prefixes CHECK,CHECK-UNIFORM
7427
7428 kernel void ker() {};
7429 // CHECK: define{{.*}}@ker() #0
7430diff --git a/clang/test/CodeGenOpenCL/fpmath.cl b/clang/test/CodeGenOpenCL/fpmath.cl
7431index 0108d909c94e..b28392739c71 100644
7432--- a/clang/test/CodeGenOpenCL/fpmath.cl
7433+++ b/clang/test/CodeGenOpenCL/fpmath.cl
7434@@ -2,6 +2,8 @@
7435 // RUN: %clang_cc1 %s -emit-llvm -o - -triple spir-unknown-unknown -cl-fp32-correctly-rounded-divide-sqrt | FileCheck --check-prefix=CHECK --check-prefix=DIVOPT %s
7436 // RUN: %clang_cc1 %s -emit-llvm -o - -DNOFP64 -cl-std=CL1.2 -triple r600-unknown-unknown -target-cpu r600 -pedantic | FileCheck --check-prefix=CHECK-FLT %s
7437 // RUN: %clang_cc1 %s -emit-llvm -o - -DFP64 -cl-std=CL1.2 -triple spir-unknown-unknown -pedantic | FileCheck --check-prefix=CHECK-DBL %s
7438+// RUN: %clang_cc1 %s -emit-llvm -o - -DNOFP64 -cl-std=CL3.0 -triple r600-unknown-unknown -target-cpu r600 -pedantic | FileCheck --check-prefix=CHECK-FLT %s
7439+// RUN: %clang_cc1 %s -emit-llvm -o - -DFP64 -cl-std=CL3.0 -cl-ext=__opencl_c_fp64 -triple spir-unknown-unknown -pedantic | FileCheck --check-prefix=CHECK-DBL %s
7440
7441 typedef __attribute__(( ext_vector_type(4) )) float float4;
7442
7443diff --git a/clang/test/CodeGenOpenCL/generic-address-space-feature.cl b/clang/test/CodeGenOpenCL/generic-address-space-feature.cl
7444new file mode 100644
7445index 000000000000..890860abe4d9
7446--- /dev/null
7447+++ b/clang/test/CodeGenOpenCL/generic-address-space-feature.cl
7448@@ -0,0 +1,28 @@
7449+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -O0 -cl-std=CL1.2 -cl-ext=-cl_khr_fp64 -finclude-default-header -emit-llvm -o - | FileCheck %s --check-prefixes=CL12
7450+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -O0 -cl-std=CL1.2 -cl-ext=-cl_khr_fp64 -fdeclare-opencl-builtins -emit-llvm -o - | FileCheck %s --check-prefixes=CL12
7451+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -O0 -cl-std=CL2.0 -cl-ext=-cl_khr_fp64 -finclude-default-header -emit-llvm -o - | FileCheck %s --check-prefixes=CL20
7452+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -O0 -cl-std=CL2.0 -cl-ext=-cl_khr_fp64 -fdeclare-opencl-builtins -emit-llvm -o - | FileCheck %s --check-prefixes=CL20
7453+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -O0 -cl-std=CL3.0 -cl-ext=-cl_khr_fp64 -finclude-default-header -emit-llvm -o - | FileCheck %s --check-prefixes=CL30
7454+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -O0 -cl-std=CL3.0 -cl-ext=-cl_khr_fp64,__opencl_c_generic_address_space -finclude-default-header -emit-llvm -o - | FileCheck %s --check-prefixes=CL30-GENERIC
7455+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -O0 -cl-std=CL3.0 -cl-ext=-cl_khr_fp64 -fdeclare-opencl-builtins -emit-llvm -o - | FileCheck %s --check-prefixes=CL30
7456+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -O0 -cl-std=CL3.0 -cl-ext=-cl_khr_fp64,__opencl_c_generic_address_space -fdeclare-opencl-builtins -emit-llvm -o - | FileCheck %s --check-prefixes=CL30-GENERIC
7457+
7458+void test(global float* src1, local float *src2, private float *src3, float *src4, float tmp) {
7459+ // CL20: %{{.+}} = addrspacecast float addrspace(1)* %{{.+}} to float addrspace(4)*
7460+ // CL12-NOT: addrspacecast
7461+ // CL30-NOT: addrspacecast
7462+ // CL30-GENERIC-NOT: addrspacecast
7463+ tmp = sincos(tmp, src1);
7464+ // CL20: %{{.+}} = addrspacecast float addrspace(3)* %{{.+}} to float addrspace(4)*
7465+ // CL12-NOT: addrspacecast
7466+ // CL30-NOT: addrspacecast
7467+ // CL30-GENERIC-NOT: addrspacecast
7468+ tmp = sincos(tmp, src2);
7469+
7470+ // CL12: %{{.+}} = call {{(spir_func )?}}float [[FUNCNAME:@.*sincos.*]](float %{{.+}}, float* {{.+}})
7471+ // CL20: %{{.+}} = call {{(spir_func )?}}float [[FUNCNAME:@.*sincos.*]](float %{{.+}}, float addrspace(4)* {{.+}})
7472+ // CL30: %{{.+}} = call {{(spir_func )?}}float [[FUNCNAME:@.*sincos.*]](float %{{.+}}, float* {{.+}})
7473+ // CL30-GENERIC: %{{.+}} = call {{(spir_func )?}}float [[FUNCNAME:@.*sincos.*]](float %{{.+}}, float addrspace(4)* {{.+}})
7474+ // CHECK: addrspacecast
7475+ tmp = sincos(tmp, src4);
7476+}
7477diff --git a/clang/test/CodeGenOpenCL/intel-subgroups-avc-ext-types.cl b/clang/test/CodeGenOpenCL/intel-subgroups-avc-ext-types.cl
7478index 515f13f6e768..5aa31ac6f345 100644
7479--- a/clang/test/CodeGenOpenCL/intel-subgroups-avc-ext-types.cl
7480+++ b/clang/test/CodeGenOpenCL/intel-subgroups-avc-ext-types.cl
7481@@ -1,4 +1,5 @@
7482 // RUN: %clang_cc1 %s -triple spir-unknown-unknown -cl-std=CL1.2 -cl-ext=+cl_intel_device_side_avc_motion_estimation -emit-llvm -o - -O0 | FileCheck %s
7483+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -cl-std=CL3.0 -cl-ext=+cl_intel_device_side_avc_motion_estimation -emit-llvm -o - -O0 | FileCheck %s
7484
7485 // CHECK: %opencl.intel_sub_group_avc_mce_payload_t = type opaque
7486 // CHECK: %opencl.intel_sub_group_avc_ime_payload_t = type opaque
7487diff --git a/clang/test/CodeGenOpenCL/kernels-have-spir-cc-by-default.cl b/clang/test/CodeGenOpenCL/kernels-have-spir-cc-by-default.cl
7488index e89237623478..3d6708ac361f 100644
7489--- a/clang/test/CodeGenOpenCL/kernels-have-spir-cc-by-default.cl
7490+++ b/clang/test/CodeGenOpenCL/kernels-have-spir-cc-by-default.cl
7491@@ -1,5 +1,8 @@
7492 // RUN: %clang_cc1 %s -cl-std=CL1.2 -emit-llvm -triple x86_64-unknown-unknown -o - | FileCheck %s
7493 // RUN: %clang_cc1 %s -cl-std=CL1.2 -emit-llvm -triple amdgcn-unknown-unknown -o - | FileCheck -check-prefixes=AMDGCN %s
7494+// RUN: %clang_cc1 %s -cl-std=CL3.0 -cl-ext=__opencl_c_fp64 -emit-llvm -triple x86_64-unknown-unknown -o - | FileCheck %s
7495+// RUN: %clang_cc1 %s -cl-std=CL3.0 -cl-ext=__opencl_c_fp64 -emit-llvm -triple amdgcn-unknown-unknown -o - | FileCheck -check-prefixes=AMDGCN %s
7496+
7497 // Test that the kernels always use the SPIR calling convention
7498 // to have unambiguous mapping of arguments to feasibly implement
7499 // clSetKernelArg().
7500diff --git a/clang/test/CodeGenOpenCL/logical-ops.cl b/clang/test/CodeGenOpenCL/logical-ops.cl
7501index f083a8580ee7..499eab65039b 100644
7502--- a/clang/test/CodeGenOpenCL/logical-ops.cl
7503+++ b/clang/test/CodeGenOpenCL/logical-ops.cl
7504@@ -1,4 +1,5 @@
7505 // RUN: %clang_cc1 %s -emit-llvm -o - -cl-std=CL1.2 -O1 -triple x86_64-unknown-linux-gnu | FileCheck %s
7506+// RUN: %clang_cc1 %s -emit-llvm -o - -cl-std=CL3.0 -cl-ext=__opencl_c_fp64 -O1 -triple x86_64-unknown-linux-gnu | FileCheck %s
7507 // RUN: %clang_cc1 %s -emit-llvm -o - -cl-std=clc++ -O1 -triple x86_64-unknown-linux-gnu | FileCheck %s
7508
7509 #pragma OPENCL EXTENSION cl_khr_fp64 : enable
7510diff --git a/clang/test/CodeGenOpenCL/no-half.cl b/clang/test/CodeGenOpenCL/no-half.cl
7511index aee8f678f01a..46da7fa339e8 100644
7512--- a/clang/test/CodeGenOpenCL/no-half.cl
7513+++ b/clang/test/CodeGenOpenCL/no-half.cl
7514@@ -1,6 +1,7 @@
7515 // RUN: %clang_cc1 %s -cl-std=cl2.0 -emit-llvm -o - -triple spir-unknown-unknown | FileCheck %s
7516 // RUN: %clang_cc1 %s -cl-std=cl1.2 -emit-llvm -o - -triple spir-unknown-unknown | FileCheck %s
7517 // RUN: %clang_cc1 %s -cl-std=cl1.1 -emit-llvm -o - -triple spir-unknown-unknown | FileCheck %s
7518+// RUN: %clang_cc1 %s -cl-std=cl3.0 -cl-ext=__opencl_c_fp64 -emit-llvm -o - -triple spir-unknown-unknown | FileCheck %s
7519
7520 #pragma OPENCL EXTENSION cl_khr_fp64:enable
7521
7522diff --git a/clang/test/CodeGenOpenCL/pipe_builtin.cl b/clang/test/CodeGenOpenCL/pipe_builtin.cl
7523index 02b9669b7ab1..0bf35c336199 100644
7524--- a/clang/test/CodeGenOpenCL/pipe_builtin.cl
7525+++ b/clang/test/CodeGenOpenCL/pipe_builtin.cl
7526@@ -1,4 +1,7 @@
7527 // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -cl-ext=+cl_khr_subgroups -O0 -cl-std=clc++ -o - %s | FileCheck %s
7528+// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -cl-ext=+cl_khr_subgroups -O0 -cl-std=cl2.0 -o - %s | FileCheck %s
7529+// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -cl-ext=+cl_khr_subgroups -O0 -cl-std=cl3.0 -cl-ext=__opencl_c_pipes,__opencl_c_subgroups -o - %s | FileCheck %s
7530+
7531 // FIXME: Add MS ABI manglings of OpenCL things and remove %itanium_abi_triple
7532 // above to support OpenCL in the MS C++ ABI.
7533
7534diff --git a/clang/test/CodeGenOpenCL/pipe_types.cl b/clang/test/CodeGenOpenCL/pipe_types.cl
7535index ba064c6d7557..b7a523d4f084 100644
7536--- a/clang/test/CodeGenOpenCL/pipe_types.cl
7537+++ b/clang/test/CodeGenOpenCL/pipe_types.cl
7538@@ -1,4 +1,5 @@
7539 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -O0 -cl-std=CL2.0 -o - %s | FileCheck %s
7540+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -O0 -cl-std=CL3.0 -cl-ext=__opencl_c_pipes -o - %s | FileCheck %s
7541
7542 // CHECK: %opencl.pipe_ro_t = type opaque
7543 // CHECK: %opencl.pipe_wo_t = type opaque
7544diff --git a/clang/test/CodeGenOpenCL/printf.cl b/clang/test/CodeGenOpenCL/printf.cl
7545index fc139d776db6..0133c5595d81 100644
7546--- a/clang/test/CodeGenOpenCL/printf.cl
7547+++ b/clang/test/CodeGenOpenCL/printf.cl
7548@@ -1,5 +1,7 @@
7549 // RUN: %clang_cc1 -cl-std=CL1.2 -cl-ext=-+cl_khr_fp64 -triple spir-unknown-unknown -disable-llvm-passes -emit-llvm -o - %s | FileCheck -check-prefixes=FP64,ALL %s
7550 // RUN: %clang_cc1 -cl-std=CL1.2 -cl-ext=-cl_khr_fp64 -triple spir-unknown-unknown -disable-llvm-passes -emit-llvm -o - %s | FileCheck -check-prefixes=NOFP64,ALL %s
7551+// RUN: %clang_cc1 -cl-std=CL3.0 -cl-ext=+__opencl_c_fp64 -triple spir-unknown-unknown -disable-llvm-passes -emit-llvm -o - %s | FileCheck -check-prefixes=FP64,ALL %s
7552+// RUN: %clang_cc1 -cl-std=CL3.0 -triple spir-unknown-unknown -disable-llvm-passes -emit-llvm -o - %s | FileCheck -check-prefixes=NOFP64,ALL %s
7553
7554 typedef __attribute__((ext_vector_type(2))) float float2;
7555 typedef __attribute__((ext_vector_type(2))) half half2;
7556diff --git a/clang/test/CodeGenOpenCL/unroll-hint.cl b/clang/test/CodeGenOpenCL/unroll-hint.cl
7557index 0f84450a1ae6..9347c935869b 100644
7558--- a/clang/test/CodeGenOpenCL/unroll-hint.cl
7559+++ b/clang/test/CodeGenOpenCL/unroll-hint.cl
7560@@ -1,5 +1,6 @@
7561 // RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL2.0 -o - %s | FileCheck %s
7562 // RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL1.2 -o - %s | FileCheck %s
7563+// RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL3.0 -o - %s | FileCheck %s
7564
7565 /*** for ***/
7566 void for_count()
7567diff --git a/clang/test/Driver/autocomplete.c b/clang/test/Driver/autocomplete.c
7568index 5c0bfb69f9a3..eabdf0b5938d 100644
7569--- a/clang/test/Driver/autocomplete.c
7570+++ b/clang/test/Driver/autocomplete.c
7571@@ -43,6 +43,8 @@
7572 // CLSTDALL-NEXT: CL1.2
7573 // CLSTDALL-NEXT: cl2.0
7574 // CLSTDALL-NEXT: CL2.0
7575+// CLSTDALL-NEXT: cl3.0
7576+// CLSTDALL-NEXT: CL3.0
7577 // CLSTDALL-NEXT: clc++
7578 // CLSTDALL-NEXT: CLC++
7579 // RUN: %clang --autocomplete=-fno-sanitize-coverage=,f | FileCheck %s -check-prefix=FNOSANICOVER
7580diff --git a/clang/test/Driver/opencl.cl b/clang/test/Driver/opencl.cl
7581index 63b04bc1af41..ffdd4f7d65bb 100644
7582--- a/clang/test/Driver/opencl.cl
7583+++ b/clang/test/Driver/opencl.cl
7584@@ -2,6 +2,7 @@
7585 // RUN: %clang -S -### -cl-std=CL1.1 %s 2>&1 | FileCheck --check-prefix=CHECK-CL11 %s
7586 // RUN: %clang -S -### -cl-std=CL1.2 %s 2>&1 | FileCheck --check-prefix=CHECK-CL12 %s
7587 // RUN: %clang -S -### -cl-std=CL2.0 %s 2>&1 | FileCheck --check-prefix=CHECK-CL20 %s
7588+// RUN: %clang -S -### -cl-std=CL3.0 %s 2>&1 | FileCheck --check-prefix=CHECK-CL30 %s
7589 // RUN: %clang -S -### -cl-std=clc++ %s 2>&1 | FileCheck --check-prefix=CHECK-CLCPP %s
7590 // RUN: %clang -S -### -cl-opt-disable %s 2>&1 | FileCheck --check-prefix=CHECK-OPT-DISABLE %s
7591 // RUN: %clang -S -### -cl-strict-aliasing %s 2>&1 | FileCheck --check-prefix=CHECK-STRICT-ALIASING %s
7592@@ -22,6 +23,7 @@
7593 // CHECK-CL11: "-cc1" {{.*}} "-cl-std=CL1.1"
7594 // CHECK-CL12: "-cc1" {{.*}} "-cl-std=CL1.2"
7595 // CHECK-CL20: "-cc1" {{.*}} "-cl-std=CL2.0"
7596+// CHECK-CL30: "-cc1" {{.*}} "-cl-std=CL3.0"
7597 // CHECK-CLCPP: "-cc1" {{.*}} "-cl-std=clc++"
7598 // CHECK-OPT-DISABLE: "-cc1" {{.*}} "-cl-opt-disable"
7599 // CHECK-STRICT-ALIASING: "-cc1" {{.*}} "-cl-strict-aliasing"
7600diff --git a/clang/test/Driver/unknown-std.cl b/clang/test/Driver/unknown-std.cl
7601index 6f371bac13ac..00209fb62556 100644
7602--- a/clang/test/Driver/unknown-std.cl
7603+++ b/clang/test/Driver/unknown-std.cl
7604@@ -10,6 +10,7 @@
7605 // CHECK-NEXT: note: use 'cl1.1' for 'OpenCL 1.1' standard
7606 // CHECK-NEXT: note: use 'cl1.2' for 'OpenCL 1.2' standard
7607 // CHECK-NEXT: note: use 'cl2.0' for 'OpenCL 2.0' standard
7608+// CHECK-NEXT: note: use 'cl3.0' for 'OpenCL 3.0' standard
7609 // CHECK-NEXT: note: use 'clc++' for 'C++ for OpenCL' standard
7610
7611 // Make sure that no other output is present.
7612diff --git a/clang/test/Frontend/stdlang.c b/clang/test/Frontend/stdlang.c
7613index 51484999e37a..eac4632fbdd6 100644
7614--- a/clang/test/Frontend/stdlang.c
7615+++ b/clang/test/Frontend/stdlang.c
7616@@ -9,6 +9,7 @@
7617 // RUN: %clang_cc1 -x cl -cl-std=CL1.1 -DOPENCL %s
7618 // RUN: %clang_cc1 -x cl -cl-std=CL1.2 -DOPENCL %s
7619 // RUN: %clang_cc1 -x cl -cl-std=CL2.0 -DOPENCL %s
7620+// RUN: %clang_cc1 -x cl -cl-std=CL3.0 -DOPENCL %s
7621 // RUN: %clang_cc1 -x cl -cl-std=CLC++ -DOPENCL %s
7622 // RUN: not %clang_cc1 -x cl -std=c99 -DOPENCL %s 2>&1 | FileCheck --check-prefix=CHECK-C99 %s
7623 // RUN: not %clang_cc1 -x cl -cl-std=invalid -DOPENCL %s 2>&1 | FileCheck --check-prefix=CHECK-INVALID %s
7624diff --git a/clang/test/Headers/opencl-c-header.cl b/clang/test/Headers/opencl-c-header.cl
7625index 1b151ffdd16a..2716076acdcf 100644
7626--- a/clang/test/Headers/opencl-c-header.cl
7627+++ b/clang/test/Headers/opencl-c-header.cl
7628@@ -1,6 +1,7 @@
7629 // RUN: %clang_cc1 -O0 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s -verify | FileCheck %s
7630 // RUN: %clang_cc1 -O0 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s -verify -cl-std=CL1.1 | FileCheck %s
7631 // RUN: %clang_cc1 -O0 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s -verify -cl-std=CL1.2 | FileCheck %s
7632+// RUN: %clang_cc1 -O0 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s -verify -cl-std=CL3.0 | FileCheck %s
7633 // RUN: %clang_cc1 -O0 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s -verify -cl-std=clc++ | FileCheck %s --check-prefix=CHECK20
7634
7635 // Test including the default header as a module.
7636@@ -39,9 +40,11 @@
7637 // RUN: rm -rf %t
7638 // RUN: mkdir -p %t
7639 // RUN: %clang_cc1 -triple spir64-unknown-unknown -emit-llvm -o - -cl-std=CL1.2 -finclude-default-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ftime-report %s 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=CHECK-MOD %s
7640+// RUN: %clang_cc1 -triple spir64-unknown-unknown -emit-llvm -o - -cl-std=CL3.0 -finclude-default-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ftime-report %s 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=CHECK-MOD %s
7641 // RUN: %clang_cc1 -triple amdgcn--amdhsa -O0 -emit-llvm -o - -cl-std=CL2.0 -finclude-default-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ftime-report %s 2>&1 | FileCheck --check-prefix=CHECK20 --check-prefix=CHECK-MOD %s
7642 // RUN: chmod u-w %t
7643 // RUN: %clang_cc1 -triple spir64-unknown-unknown -emit-llvm -o - -cl-std=CL1.2 -finclude-default-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ftime-report %s 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=CHECK-MOD %s
7644+// RUN: %clang_cc1 -triple spir64-unknown-unknown -emit-llvm -o - -cl-std=CL3.0 -finclude-default-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ftime-report %s 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=CHECK-MOD %s
7645 // RUN: %clang_cc1 -triple amdgcn--amdhsa -O0 -emit-llvm -o - -cl-std=CL2.0 -finclude-default-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ftime-report %s 2>&1 | FileCheck --check-prefix=CHECK20 --check-prefix=CHECK-MOD %s
7646 // RUN: chmod u+w %t
7647
7648@@ -67,7 +70,7 @@ char f(char x) {
7649 // from OpenCL 2.0 onwards.
7650
7651 // CHECK20: _Z12write_imagef14ocl_image3d_wo
7652-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
7653+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ == CL_VERSION_2_0)
7654 void test_image3dwo(write_only image3d_t img) {
7655 write_imagef(img, (0), (0.0f));
7656 }
7657@@ -81,7 +84,7 @@ void test_atomics(__generic volatile unsigned int* a) {
7658 #endif
7659
7660 // Verify that ATOMIC_VAR_INIT is defined.
7661-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
7662+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ == CL_VERSION_2_0)
7663 global atomic_int z = ATOMIC_VAR_INIT(99);
7664 #endif //__OPENCL_C_VERSION__
7665
7666diff --git a/clang/test/Index/pipe-size.cl b/clang/test/Index/pipe-size.cl
7667index 94a1255f0a48..59b76051eda1 100644
7668--- a/clang/test/Index/pipe-size.cl
7669+++ b/clang/test/Index/pipe-size.cl
7670@@ -2,6 +2,13 @@
7671 // RUN: %clang_cc1 -x cl -O0 -cl-std=CL2.0 -emit-llvm -triple spir-unknown-unknown %s -o - | FileCheck %s --check-prefix=SPIR
7672 // RUN: %clang_cc1 -x cl -O0 -cl-std=CL2.0 -emit-llvm -triple spir64-unknown-unknown %s -o - | FileCheck %s --check-prefix=SPIR64
7673 // RUN: %clang_cc1 -x cl -O0 -cl-std=CL2.0 -emit-llvm -triple amdgcn-amd-amdhsa %s -o - | FileCheck %s --check-prefix=AMDGCN
7674+// RUN: %clang_cc1 -x cl -O0 -cl-std=CL3.0 -cl-ext=__opencl_c_pipes -emit-llvm -triple x86_64-unknown-linux-gnu %s -o - | FileCheck %s --check-prefix=X86
7675+// RUN: %clang_cc1 -x cl -O0 -cl-std=CL3.0 -cl-ext=__opencl_c_pipes -emit-llvm -triple spir-unknown-unknown %s -o - | FileCheck %s --check-prefix=SPIR
7676+// RUN: %clang_cc1 -x cl -O0 -cl-std=CL3.0 -cl-ext=__opencl_c_pipes -emit-llvm -triple spir64-unknown-unknown %s -o - | FileCheck %s --check-prefix=SPIR64
7677+// RUN: %clang_cc1 -x cl -O0 -cl-std=CL3.0 -cl-ext=__opencl_c_pipes -emit-llvm -triple amdgcn-amd-amdhsa %s -o - | FileCheck %s --check-prefix=AMDGCN
7678+
7679+
7680+
7681 __kernel void testPipe( pipe int test )
7682 {
7683 int s = sizeof(test);
7684diff --git a/clang/test/Preprocessor/predefined-macros.c b/clang/test/Preprocessor/predefined-macros.c
7685index def105f4c52e..b088a37ba665 100644
7686--- a/clang/test/Preprocessor/predefined-macros.c
7687+++ b/clang/test/Preprocessor/predefined-macros.c
7688@@ -129,6 +129,8 @@
7689 // RUN: | FileCheck -match-full-lines %s --check-prefix=CHECK-CL12
7690 // RUN: %clang_cc1 %s -E -dM -o - -x cl -cl-std=CL2.0 \
7691 // RUN: | FileCheck -match-full-lines %s --check-prefix=CHECK-CL20
7692+// RUN: %clang_cc1 %s -E -dM -o - -x cl -cl-std=CL3.0 \
7693+// RUN: | FileCheck -match-full-lines %s --check-prefix=CHECK-CL30
7694 // RUN: %clang_cc1 %s -E -dM -o - -x cl -cl-fast-relaxed-math \
7695 // RUN: | FileCheck -match-full-lines %s --check-prefix=CHECK-FRM
7696 // RUN: %clang_cc1 %s -E -dM -o - -x cl -cl-std=clc++ \
7697@@ -137,26 +139,37 @@
7698 // CHECK-CL10: #define CL_VERSION_1_1 110
7699 // CHECK-CL10: #define CL_VERSION_1_2 120
7700 // CHECK-CL10: #define CL_VERSION_2_0 200
7701+// CHECK-CL10: #define CL_VERSION_3_0 300
7702 // CHECK-CL10: #define __OPENCL_C_VERSION__ 100
7703 // CHECK-CL10-NOT: #define __FAST_RELAXED_MATH__ 1
7704 // CHECK-CL11: #define CL_VERSION_1_0 100
7705 // CHECK-CL11: #define CL_VERSION_1_1 110
7706 // CHECK-CL11: #define CL_VERSION_1_2 120
7707 // CHECK-CL11: #define CL_VERSION_2_0 200
7708+// CHECK-CL11: #define CL_VERSION_3_0 300
7709 // CHECK-CL11: #define __OPENCL_C_VERSION__ 110
7710 // CHECK-CL11-NOT: #define __FAST_RELAXED_MATH__ 1
7711 // CHECK-CL12: #define CL_VERSION_1_0 100
7712 // CHECK-CL12: #define CL_VERSION_1_1 110
7713 // CHECK-CL12: #define CL_VERSION_1_2 120
7714 // CHECK-CL12: #define CL_VERSION_2_0 200
7715+// CHECK-CL12: #define CL_VERSION_3_0 300
7716 // CHECK-CL12: #define __OPENCL_C_VERSION__ 120
7717 // CHECK-CL12-NOT: #define __FAST_RELAXED_MATH__ 1
7718 // CHECK-CL20: #define CL_VERSION_1_0 100
7719 // CHECK-CL20: #define CL_VERSION_1_1 110
7720 // CHECK-CL20: #define CL_VERSION_1_2 120
7721 // CHECK-CL20: #define CL_VERSION_2_0 200
7722+// CHECK-CL20: #define CL_VERSION_3_0 300
7723 // CHECK-CL20: #define __OPENCL_C_VERSION__ 200
7724 // CHECK-CL20-NOT: #define __FAST_RELAXED_MATH__ 1
7725+// CHECK-CL30: #define CL_VERSION_1_0 100
7726+// CHECK-CL30: #define CL_VERSION_1_1 110
7727+// CHECK-CL30: #define CL_VERSION_1_2 120
7728+// CHECK-CL30: #define CL_VERSION_2_0 200
7729+// CHECK-CL30: #define CL_VERSION_3_0 300
7730+// CHECK-CL30: #define __OPENCL_C_VERSION__ 300
7731+// CHECK-CL30-NOT: #define __FAST_RELAXED_MATH__ 1
7732 // CHECK-FRM: #define __FAST_RELAXED_MATH__ 1
7733 // CHECK-CLCPP10: #define __CL_CPP_VERSION_1_0__ 100
7734 // CHECK-CLCPP10: #define __OPENCL_CPP_VERSION__ 100
7735diff --git a/clang/test/Sema/feature-extensions-simult-support.cl b/clang/test/Sema/feature-extensions-simult-support.cl
7736new file mode 100644
7737index 000000000000..0789105002b2
7738--- /dev/null
7739+++ b/clang/test/Sema/feature-extensions-simult-support.cl
7740@@ -0,0 +1,75 @@
7741+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2 -cl-ext=-cl_khr_fp64
7742+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2 -cl-ext=+cl_khr_fp64
7743+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2 -cl-ext=-cl_khr_3d_image_writes
7744+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2 -cl-ext=+cl_khr_3d_image_writes
7745+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2 -cl-ext=-cl_khr_subgroups
7746+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2 -cl-ext=+cl_khr_subgroups
7747+
7748+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -cl-ext=-cl_khr_fp64
7749+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -cl-ext=+cl_khr_fp64
7750+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -cl-ext=-cl_khr_3d_image_writes
7751+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -cl-ext=+cl_khr_3d_image_writes
7752+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -cl-ext=-cl_khr_subgroups
7753+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -cl-ext=+cl_khr_subgroups
7754+
7755+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_fp64
7756+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_3d_image_writes
7757+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_subgroups
7758+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_pipes
7759+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_device_enqueue
7760+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_read_write_images
7761+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_fp64,-cl_khr_fp64
7762+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_3d_image_writes,-cl_khr_3d_image_writes
7763+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_subgroups,-cl_khr_subgroups
7764+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+cl_khr_fp64
7765+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+cl_khr_3d_image_writes
7766+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+cl_khr_subgroups
7767+
7768+// expected-no-diagnostics
7769+
7770+#ifdef cl_khr_fp64
7771+ #ifndef __opencl_c_fp64
7772+ #error macros were not properly set up
7773+ #endif
7774+#endif
7775+#ifdef __opencl_c_fp64
7776+ #ifndef cl_khr_fp64
7777+ #error macros were not properly set up
7778+ #endif
7779+#endif
7780+
7781+#ifdef cl_khr_3d_image_writes
7782+ #ifndef __opencl_c_3d_image_writes
7783+ #error macros were not properly set up
7784+ #endif
7785+#endif
7786+#ifdef __opencl_c_3d_image_writes
7787+ #ifndef cl_khr_3d_image_writes
7788+ #error macros were not properly set up
7789+ #endif
7790+#endif
7791+
7792+#ifdef cl_khr_subgroups
7793+ #ifndef __opencl_c_subgroups
7794+ #error macros were not properly set up
7795+ #endif
7796+#endif
7797+#ifdef __opencl_c_subgroups
7798+ #ifndef cl_khr_subgroups
7799+ #error macros were not properly set up
7800+ #endif
7801+#endif
7802+
7803+#if defined(__opencl_c_pipes) || defined(__opencl_c_device_enqueue)
7804+ #ifndef __opencl_c_generic_address_space
7805+ #error macros were not properly set up
7806+ #endif
7807+#endif
7808+
7809+#if defined(__opencl_c_3d_image_writes) || defined(__opencl_c_read_write_images)
7810+ #ifndef __opencl_c_images
7811+ #error macros were not properly set up
7812+ #endif
7813+#endif
7814+
7815+kernel void test(){}
7816diff --git a/clang/test/Sema/features-ignore-pragma.cl b/clang/test/Sema/features-ignore-pragma.cl
7817new file mode 100644
7818index 000000000000..046ce5390754
7819--- /dev/null
7820+++ b/clang/test/Sema/features-ignore-pragma.cl
7821@@ -0,0 +1,24 @@
7822+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0
7823+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=__opencl_c_fp64
7824+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=__opencl_c_subgroups
7825+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=__opencl_c_3d_image_writes
7826+
7827+#pragma OPENCL EXTENSION __opencl_c_fp64 : enable
7828+// expected-warning@-1 {{OpenCL feature support can't be controlled via pragma, ignoring}}
7829+
7830+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
7831+#ifndef __opencl_c_fp64
7832+// expected-warning@-2{{unsupported OpenCL extension 'cl_khr_fp64' - ignoring}}
7833+#endif
7834+
7835+#pragma OPENCL EXTENSION cl_khr_subgroups : enable
7836+#ifndef __opencl_c_subgroups
7837+// expected-warning@-2{{unsupported OpenCL extension 'cl_khr_subgroups' - ignoring}}
7838+#endif
7839+
7840+#pragma OPENCL EXTENSION cl_khr_3d_image_writes : enable
7841+#ifndef __opencl_c_3d_image_writes
7842+// expected-warning@-2{{unsupported OpenCL extension 'cl_khr_3d_image_writes' - ignoring}}
7843+#endif
7844+
7845+kernel void foo() {}
7846diff --git a/clang/test/Sema/opencl-features-pipes.cl b/clang/test/Sema/opencl-features-pipes.cl
7847new file mode 100644
7848index 000000000000..c0ac778f24a6
7849--- /dev/null
7850+++ b/clang/test/Sema/opencl-features-pipes.cl
7851@@ -0,0 +1,18 @@
7852+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.1
7853+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2
7854+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -DHAS
7855+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0
7856+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=__opencl_c_pipes -DHAS
7857+// expected-no-diagnostics
7858+
7859+#ifdef HAS
7860+ #ifndef __opencl_c_pipes
7861+ #error Feature should be defined
7862+ #endif
7863+#else
7864+ #ifdef __opencl_c_pipes
7865+ #error Feature should not be defined
7866+ #endif
7867+#endif
7868+
7869+kernel void foo() {}
7870diff --git a/clang/test/Sema/opencl-features.cl b/clang/test/Sema/opencl-features.cl
7871new file mode 100644
7872index 000000000000..aa432f6b60bf
7873--- /dev/null
7874+++ b/clang/test/Sema/opencl-features.cl
7875@@ -0,0 +1,128 @@
7876+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0
7877+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -cl-ext=-__opencl_c_device_enqueue,-__opencl_c_pipes,-__opencl_c_read_write_images
7878+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CLC++
7879+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0
7880+// expected-no-diagnostics
7881+
7882+#ifndef __opencl_c_int64
7883+ #error Feature __opencl_c_int64 shouldn't be defined
7884+#endif
7885+
7886+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ == CL_VERSION_2_0)
7887+ #ifndef __opencl_c_3d_image_writes
7888+ #error Feature __opencl_c_3d_image_writes should be defined
7889+ #endif
7890+
7891+ #ifndef __opencl_c_atomic_order_acq_rel
7892+ #error Feature __opencl_c_atomic_order_acq_rel should be defined
7893+ #endif
7894+
7895+ #ifndef __opencl_c_atomic_order_seq_cst
7896+ #error Feature __opencl_c_atomic_order_seq_cst should be defined
7897+ #endif
7898+
7899+ #ifndef __opencl_c_atomic_scope_device
7900+ #error Feature __opencl_c_atomic_scope_device should be defined
7901+ #endif
7902+
7903+ #ifndef __opencl_c_atomic_scope_all_devices
7904+ #error Feature __opencl_c_atomic_scope_all_devices should be defined
7905+ #endif
7906+
7907+ #ifndef __opencl_c_device_enqueue
7908+ #error Feature __opencl_c_device_enqueue should be defined
7909+ #endif
7910+
7911+ #ifndef __opencl_c_generic_address_space
7912+ #error Feature __opencl_c_generic_address_space should be defined
7913+ #endif
7914+
7915+ #ifndef __opencl_c_pipes
7916+ #error Feature __opencl_c_pipes should be defined
7917+ #endif
7918+
7919+ #ifndef __opencl_c_program_scope_global_variables
7920+ #error Feature __opencl_c_program_scope_global_variables should be defined
7921+ #endif
7922+
7923+ #ifndef __opencl_c_read_write_images
7924+ #error Feature __opencl_c_read_write_images should be defined
7925+ #endif
7926+
7927+ #ifndef __opencl_c_subgroups
7928+ #error Feature __opencl_c_subgroups should be defined
7929+ #endif
7930+
7931+ #ifndef __opencl_c_work_group_collective_functions
7932+ #error Feature __opencl_c_work_group_collective_functions should be defined
7933+ #endif
7934+
7935+ #ifndef __opencl_c_fp64
7936+ #error Feature __opencl_c_fp64 should be defined
7937+ #endif
7938+
7939+ #ifndef __opencl_c_images
7940+ #error Feature __opencl_c_images should be defined
7941+ #endif
7942+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
7943+
7944+
7945+#if __OPENCL_C_VERSION__ == CL_VERSION_3_0
7946+ #ifdef __opencl_c_3d_image_writes
7947+ #error Feature __opencl_c_3d_image_writes shouldn't be defined
7948+ #endif
7949+
7950+ #ifdef __opencl_c_atomic_order_acq_rel
7951+ #error Feature __opencl_c_atomic_order_acq_rel shouldn't be defined
7952+ #endif
7953+
7954+ #ifdef __opencl_c_atomic_order_seq_cst
7955+ #error Feature __opencl_c_atomic_order_seq_cst shouldn't be defined
7956+ #endif
7957+
7958+ #ifdef __opencl_c_atomic_scope_device
7959+ #error Feature __opencl_c_atomic_scope_device shouldn't be defined
7960+ #endif
7961+
7962+ #ifdef __opencl_c_atomic_scope_all_devices
7963+ #error Feature __opencl_c_atomic_scope_all_devices shouldn't be defined
7964+ #endif
7965+
7966+ #ifdef __opencl_c_device_enqueue
7967+ #error Feature __opencl_c_device_enqueue shouldn't be defined
7968+ #endif
7969+
7970+ #ifdef __opencl_c_generic_address_space
7971+ #error Feature __opencl_c_generic_address_space shouldn't be defined
7972+ #endif
7973+
7974+ #ifdef __opencl_c_pipes
7975+ #error Feature __opencl_c_pipes shouldn't be defined
7976+ #endif
7977+
7978+ #ifdef __opencl_c_program_scope_global_variables
7979+ #error Feature __opencl_c_program_scope_global_variables shouldn't be defined
7980+ #endif
7981+
7982+ #ifdef __opencl_c_read_write_images
7983+ #error Feature __opencl_c_read_write_images shouldn't be defined
7984+ #endif
7985+
7986+ #ifdef __opencl_c_subgroups
7987+ #error Feature __opencl_c_subgroups shouldn't be defined
7988+ #endif
7989+
7990+ #ifdef __opencl_c_work_group_collective_functions
7991+ #error Feature __opencl_c_work_group_collective_functions shouldn't be defined
7992+ #endif
7993+
7994+ #ifdef __opencl_c_fp64
7995+ #error Feature __opencl_c_fp64 shouldn't be defined
7996+ #endif
7997+
7998+ #ifdef __opencl_c_images
7999+ #error Feature __opencl_c_images shouldn't be defined
8000+ #endif
8001+#endif // __OPENCL_C_VERSION__ == CL_VERSION_3_0
8002+
8003+kernel void foo() {}
8004diff --git a/clang/test/Sema/pipe_builtins_feature.cl b/clang/test/Sema/pipe_builtins_feature.cl
8005new file mode 100644
8006index 000000000000..56fa94fc7705
8007--- /dev/null
8008+++ b/clang/test/Sema/pipe_builtins_feature.cl
8009@@ -0,0 +1,21 @@
8010+// RUN: %clang_cc1 -cl-std=CL2.0 -fsyntax-only -verify %s
8011+// RUN: %clang_cc1 -cl-std=CL3.0 -fsyntax-only -verify %s
8012+// RUN: %clang_cc1 -cl-std=CL3.0 -cl-ext=__opencl_c_pipes -fsyntax-only -verify %s
8013+
8014+#ifdef __opencl_c_pipes
8015+ #ifndef __opencl_c_generic_address_space
8016+ #error Generic address space feature must also be defined
8017+ #endif
8018+// CHECK: expected-no-diagnostics
8019+// check that pragma disable all doesn't touch feature support
8020+ #pragma OPENCL EXTENSION all : disable
8021+#endif
8022+
8023+void test(read_only pipe int p, global int *ptr) {
8024+ reserve_id_t rid;
8025+}
8026+
8027+#ifndef __opencl_c_pipes
8028+// expected-error@-5 {{expected parameter declarator}} expected-error@-5 {{expected ')'}} expected-note@-5 {{to match this '('}}
8029+// expected-error@-5 {{use of type 'reserve_id_t' requires __opencl_c_pipes extension to be enabled}}
8030+#endif
8031diff --git a/clang/test/SemaOpenCL/address-spaces-conversions-cl2.0.cl b/clang/test/SemaOpenCL/address-spaces-conversions-cl2.0.cl
8032index 5efea216346a..09aea27ae6de 100644
8033--- a/clang/test/SemaOpenCL/address-spaces-conversions-cl2.0.cl
8034+++ b/clang/test/SemaOpenCL/address-spaces-conversions-cl2.0.cl
8035@@ -1,6 +1,9 @@
8036 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DCONSTANT -cl-std=CL2.0
8037 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DGLOBAL -cl-std=CL2.0
8038 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DGENERIC -cl-std=CL2.0
8039+// RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DCONSTANT -cl-std=CL3.0 -cl-ext=__opencl_c_generic_address_space
8040+// RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DGLOBAL -cl-std=CL3.0 -cl-ext=__opencl_c_generic_address_space
8041+// RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DGENERIC -cl-std=CL3.0 -cl-ext=__opencl_c_generic_address_space
8042 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DCONSTANT -cl-std=clc++
8043 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DGLOBAL -cl-std=clc++
8044 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DGENERIC -cl-std=clc++
8045diff --git a/clang/test/SemaOpenCL/address-spaces.cl b/clang/test/SemaOpenCL/address-spaces.cl
8046index 07547ea19680..e367a7c57292 100644
8047--- a/clang/test/SemaOpenCL/address-spaces.cl
8048+++ b/clang/test/SemaOpenCL/address-spaces.cl
8049@@ -1,5 +1,6 @@
8050 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only
8051 // RUN: %clang_cc1 %s -cl-std=CL2.0 -verify -pedantic -fsyntax-only
8052+// RUN: %clang_cc1 %s -cl-std=CL3.0 -cl-ext=__opencl_c_generic_address_space -verify -pedantic -fsyntax-only
8053 // RUN: %clang_cc1 %s -cl-std=clc++ -verify -pedantic -fsyntax-only
8054
8055 __constant int ci = 1;
8056diff --git a/clang/test/SemaOpenCL/cl20-device-side-enqueue.cl b/clang/test/SemaOpenCL/cl20-device-side-enqueue.cl
8057index f63e2913c749..727141190a0b 100644
8058--- a/clang/test/SemaOpenCL/cl20-device-side-enqueue.cl
8059+++ b/clang/test/SemaOpenCL/cl20-device-side-enqueue.cl
8060@@ -2,6 +2,12 @@
8061 // RUN: %clang_cc1 %s -cl-std=CL2.0 -triple "spir-unknown-unknown" -verify -pedantic -fsyntax-only -DB32 -DQUALS="const volatile"
8062 // RUN: %clang_cc1 %s -cl-std=CL2.0 -triple "spir64-unknown-unknown" -verify -pedantic -fsyntax-only -Wconversion -DWCONV -DQUALS=
8063 // RUN: %clang_cc1 %s -cl-std=CL2.0 -triple "spir64-unknown-unknown" -verify -pedantic -fsyntax-only -Wconversion -DWCONV -DQUALS="const volatile"
8064+// RUN: %clang_cc1 %s -cl-std=CL3.0 -triple "spir-unknown-unknown" -cl-ext=__opencl_c_device_enqueue,__opencl_c_subgroups -verify -pedantic -fsyntax-only -DB32 -DQUALS=
8065+// RUN: %clang_cc1 %s -cl-std=CL3.0 -triple "spir-unknown-unknown" -cl-ext=__opencl_c_device_enqueue,__opencl_c_subgroups -verify -pedantic -fsyntax-only -DB32 -DQUALS="const volatile"
8066+// RUN: %clang_cc1 %s -cl-std=CL3.0 -triple "spir64-unknown-unknown" -cl-ext=__opencl_c_device_enqueue,__opencl_c_subgroups -verify -pedantic -fsyntax-only -Wconversion -DWCONV -DQUALS=
8067+// RUN: %clang_cc1 %s -cl-std=CL3.0 -triple "spir64-unknown-unknown" -cl-ext=__opencl_c_device_enqueue,__opencl_c_subgroups -verify -pedantic -fsyntax-only -Wconversion -DWCONV -DQUALS="const volatile"
8068+
8069+
8070
8071 typedef struct {int a;} ndrange_t;
8072 // Diagnostic tests for different overloads of enqueue_kernel from Table 6.13.17.1 of OpenCL 2.0 Spec.
8073@@ -235,11 +241,17 @@ kernel void bar(global unsigned int *buf)
8074 kernel void foo1(global unsigned int *buf)
8075 {
8076 ndrange_t n;
8077- buf[0] = get_kernel_max_sub_group_size_for_ndrange(n, ^(){}); // expected-error {{use of declaration 'get_kernel_max_sub_group_size_for_ndrange' requires cl_khr_subgroups extension to be enabled}}
8078+ buf[0] = get_kernel_max_sub_group_size_for_ndrange(n, ^(){});
8079+#if __OPENCL_C_VERSION__ < 300
8080+// expected-error@-2 {{use of declaration 'get_kernel_max_sub_group_size_for_ndrange' requires cl_khr_subgroups extension to be enabled}}
8081+#endif
8082 }
8083
8084 kernel void bar1(global unsigned int *buf)
8085 {
8086 ndrange_t n;
8087- buf[0] = get_kernel_sub_group_count_for_ndrange(n, ^(){}); // expected-error {{use of declaration 'get_kernel_sub_group_count_for_ndrange' requires cl_khr_subgroups extension to be enabled}}
8088+ buf[0] = get_kernel_sub_group_count_for_ndrange(n, ^(){});
8089+#if __OPENCL_C_VERSION__ < 300
8090+// expected-error@-2 {{use of declaration 'get_kernel_sub_group_count_for_ndrange' requires cl_khr_subgroups extension to be enabled}}
8091+#endif
8092 }
8093diff --git a/clang/test/SemaOpenCL/forget-unsupported-builtins.cl b/clang/test/SemaOpenCL/forget-unsupported-builtins.cl
8094new file mode 100644
8095index 000000000000..14dd03e2c7db
8096--- /dev/null
8097+++ b/clang/test/SemaOpenCL/forget-unsupported-builtins.cl
8098@@ -0,0 +1,22 @@
8099+// RUN: %clang_cc1 -cl-std=cl3.0 -fsyntax-only -verify %s -triple spir-unknown-unknown
8100+// RUN: %clang_cc1 -cl-std=cl3.0 -fsyntax-only -cl-ext=__opencl_c_pipes,__opencl_c_generic_address_space,__opencl_c_device_enqueue -verify %s -triple spir-unknown-unknown -DFEATURES
8101+
8102+#ifndef FEATURES
8103+ // expected-no-diagnostics
8104+#else
8105+ // expected-error@+10 {{cannot redeclare builtin function 'get_pipe_max_packets'}}
8106+ // expected-note@+9 {{'get_pipe_max_packets' is a builtin with type 'unsigned int ()'}}
8107+ // expected-error@+9 {{cannot redeclare builtin function 'to_local'}}
8108+ // expected-note@+8 {{'to_local' is a builtin with type 'void *(void *)'}}
8109+ // expected-error@+8 {{cannot redeclare builtin function 'to_global'}}
8110+ // expected-note@+7 {{'to_global' is a builtin with type 'void *(void *)'}}
8111+ // expected-error@+7 {{cannot redeclare builtin function 'get_kernel_work_group_size'}}
8112+ // expected-note@+6 {{'get_kernel_work_group_size' is a builtin with type 'unsigned int ()'}}
8113+#endif
8114+
8115+int get_pipe_max_packets(int);
8116+int to_local(int);
8117+int to_global(int);
8118+int get_kernel_work_group_size(int);
8119+
8120+kernel void test(global int *dst) {}
8121diff --git a/clang/test/SemaOpenCL/image-features.cl b/clang/test/SemaOpenCL/image-features.cl
8122new file mode 100644
8123index 000000000000..ace6913bb31e
8124--- /dev/null
8125+++ b/clang/test/SemaOpenCL/image-features.cl
8126@@ -0,0 +1,20 @@
8127+// RUN: %clang_cc1 -cl-std=cl2.0 -fsyntax-only -verify %s -triple spir-unknown-unknown
8128+// RUN: %clang_cc1 -cl-std=cl3.0 -cl-ext=__opencl_c_images -fsyntax-only -verify %s -triple spir-unknown-unknown
8129+// RUN: %clang_cc1 -cl-std=cl3.0 -cl-ext=__opencl_c_3d_image_writes -fsyntax-only -verify %s -triple spir-unknown-unknown
8130+// RUN: %clang_cc1 -cl-std=cl3.0 -cl-ext=__opencl_c_read_write_images -fsyntax-only -verify %s -triple spir-unknown-unknown
8131+
8132+#if defined(__opencl_c_read_write_images) && defined(__opencl_c_3d_image_writes)
8133+ // expected-no-diagnostics
8134+#endif
8135+
8136+__kernel void write_3d_image(__write_only image3d_t i) {}
8137+
8138+#ifndef __opencl_c_3d_image_writes
8139+ // expected-error@-3 {{use of type '__write_only image3d_t' requires __opencl_c_3d_image_writes extension to be enabled}}
8140+#endif
8141+
8142+__kernel void read_write_3d_image(__read_write image3d_t i) { }
8143+
8144+#ifndef __opencl_c_read_write_images
8145+ // expected-error@-3 {{use of type '__read_write image3d_t' requires __opencl_c_read_write_images extension to be enabled}}
8146+#endif
8147diff --git a/clang/test/SemaOpenCL/invalid-pipe-builtin-cl2.0.cl b/clang/test/SemaOpenCL/invalid-pipe-builtin-cl2.0.cl
8148index 36e76621d24a..38b0a04726e3 100644
8149--- a/clang/test/SemaOpenCL/invalid-pipe-builtin-cl2.0.cl
8150+++ b/clang/test/SemaOpenCL/invalid-pipe-builtin-cl2.0.cl
8151@@ -1,4 +1,5 @@
8152 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -cl-ext=+cl_khr_subgroups
8153+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=__opencl_c_subgroups,__opencl_c_pipes
8154
8155 #pragma OPENCL EXTENSION cl_khr_subgroups : enable
8156
8157diff --git a/clang/test/SemaOpenCL/storageclass-cl20.cl b/clang/test/SemaOpenCL/storageclass-cl20.cl
8158index 581701d2a6a5..469c526ebc30 100644
8159--- a/clang/test/SemaOpenCL/storageclass-cl20.cl
8160+++ b/clang/test/SemaOpenCL/storageclass-cl20.cl
8161@@ -1,4 +1,5 @@
8162 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0
8163+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=__opencl_c_program_scope_global_variables,__opencl_c_generic_address_space
8164
8165 int G2 = 0;
8166 global int G3 = 0;
8167diff --git a/clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp b/clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp
8168index 41d33b550680..f50652493e5e 100644
8169--- a/clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp
8170+++ b/clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp
8171@@ -56,6 +56,7 @@
8172 //===----------------------------------------------------------------------===//
8173
8174 #include "TableGenBackends.h"
8175+#include "clang/Basic/OpenCLOptions.h"
8176 #include "llvm/ADT/MapVector.h"
8177 #include "llvm/ADT/STLExtras.h"
8178 #include "llvm/ADT/SmallString.h"
8179@@ -69,6 +70,7 @@
8180 #include "llvm/TableGen/Record.h"
8181 #include "llvm/TableGen/StringMatcher.h"
8182 #include "llvm/TableGen/TableGenBackend.h"
8183+#include <numeric>
8184 #include <set>
8185
8186 using namespace llvm;
8187@@ -228,6 +230,10 @@ private:
8188 // The function "tan", having the same signatures, would be mapped to the
8189 // same entry (<I1, I2, I3>).
8190 MapVector<BuiltinIndexListTy *, BuiltinTableEntries> SignatureListMap;
8191+
8192+ // Encode all versions
8193+ unsigned short
8194+ EncodeBuiltinVersions(std::vector<Record *> BuiltinVersionsRecords) const;
8195 };
8196 } // namespace
8197
8198@@ -338,12 +344,10 @@ struct OpenCLBuiltinStruct {
8199 const bool IsConst;
8200 // Function attribute __attribute__((convergent))
8201 const bool IsConv;
8202+ // All opencl versions encoded
8203+ const unsigned char AllVersions : 5;
8204 // OpenCL extension(s) required for this overload.
8205 const unsigned short Extension;
8206- // First OpenCL version in which this overload was introduced (e.g. CL20).
8207- const unsigned short MinVersion;
8208- // First OpenCL version in which this overload was removed (e.g. CL20).
8209- const unsigned short MaxVersion;
8210 };
8211
8212 )";
8213@@ -503,11 +507,9 @@ void BuiltinNameEmitter::EmitBuiltinTable() {
8214 << (Overload.first->getValueAsBit("IsPure")) << ", "
8215 << (Overload.first->getValueAsBit("IsConst")) << ", "
8216 << (Overload.first->getValueAsBit("IsConv")) << ", "
8217- << FunctionExtensionIndex[ExtName] << ", "
8218- << Overload.first->getValueAsDef("MinVersion")->getValueAsInt("ID")
8219- << ", "
8220- << Overload.first->getValueAsDef("MaxVersion")->getValueAsInt("ID")
8221- << " },\n";
8222+ << EncodeBuiltinVersions(
8223+ Overload.first->getValueAsListOfDefs("Versions"))
8224+ << ", " << FunctionExtensionIndex[ExtName] << " },\n";
8225 Index++;
8226 }
8227 }
8228@@ -528,10 +530,8 @@ bool BuiltinNameEmitter::CanReuseSignature(
8229 if (Rec->getValueAsBit("IsPure") == Rec2->getValueAsBit("IsPure") &&
8230 Rec->getValueAsBit("IsConst") == Rec2->getValueAsBit("IsConst") &&
8231 Rec->getValueAsBit("IsConv") == Rec2->getValueAsBit("IsConv") &&
8232- Rec->getValueAsDef("MinVersion")->getValueAsInt("ID") ==
8233- Rec2->getValueAsDef("MinVersion")->getValueAsInt("ID") &&
8234- Rec->getValueAsDef("MaxVersion")->getValueAsInt("ID") ==
8235- Rec2->getValueAsDef("MaxVersion")->getValueAsInt("ID") &&
8236+ EncodeBuiltinVersions(Rec->getValueAsListOfDefs("Versions")) ==
8237+ EncodeBuiltinVersions(Rec2->getValueAsListOfDefs("Versions")) &&
8238 Rec->getValueAsDef("Extension")->getName() ==
8239 Rec2->getValueAsDef("Extension")->getName()) {
8240 return true;
8241@@ -806,6 +806,15 @@ static void OCL2Qual(ASTContext &Context, const OpenCLTypeStruct &Ty,
8242 OS << "\n} // OCL2Qual\n";
8243 }
8244
8245+unsigned short BuiltinNameEmitter::EncodeBuiltinVersions(
8246+ std::vector<Record *> BuiltinVersionsRecords) const {
8247+ return std::accumulate(
8248+ BuiltinVersionsRecords.begin(), BuiltinVersionsRecords.end(),
8249+ (unsigned short)0, [](unsigned short C, Record *R) {
8250+ return C |= clang::OpenCLOptions::EncodeVersion(R->getValueAsInt("ID"));
8251+ });
8252+}
8253+
8254 void clang::EmitClangOpenCLBuiltins(RecordKeeper &Records, raw_ostream &OS) {
8255 BuiltinNameEmitter NameChecker(Records, OS);
8256 NameChecker.Emit();
8257--
82582.17.1
8259
diff --git a/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm10-Remove-repo-name-in-LLVM-IR.patch b/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm10-Remove-repo-name-in-LLVM-IR.patch
deleted file mode 100644
index 232ae063..00000000
--- a/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm10-Remove-repo-name-in-LLVM-IR.patch
+++ /dev/null
@@ -1,50 +0,0 @@
1From b53fd86ffdeacb9b13624bdb110fd25e8c35cb92 Mon Sep 17 00:00:00 2001
2From: Feng Zou <feng.zou@intel.com>
3Date: Mon, 19 Oct 2020 14:43:38 +0800
4Subject: [PATCH] Remove repo name in LLVM IR
5
6Upstream-Status: Backport [Taken from opencl-clang patches, https://github.com/intel/opencl-clang/blob/ocl-open-100/patches/llvm/0003-Remove-repo-name-in-LLVM-IR.patch]
7Signed-off-by: Feng Zou <feng.zou@intel.com>
8Signed-off-by: Naveen Saini <naveen.kumar.saini@intel.com>
9
10---
11 llvm/cmake/modules/VersionFromVCS.cmake | 23 ++++++++++++-----------
12 1 file changed, 12 insertions(+), 11 deletions(-)
13
14diff --git a/llvm/cmake/modules/VersionFromVCS.cmake b/llvm/cmake/modules/VersionFromVCS.cmake
15index 1b6519b4b7c..8fd6b23bb34 100644
16--- a/llvm/cmake/modules/VersionFromVCS.cmake
17+++ b/llvm/cmake/modules/VersionFromVCS.cmake
18@@ -33,17 +33,18 @@ function(get_source_info path revision repository)
19 else()
20 set(remote "origin")
21 endif()
22- execute_process(COMMAND ${GIT_EXECUTABLE} remote get-url ${remote}
23- WORKING_DIRECTORY ${path}
24- RESULT_VARIABLE git_result
25- OUTPUT_VARIABLE git_output
26- ERROR_QUIET)
27- if(git_result EQUAL 0)
28- string(STRIP "${git_output}" git_output)
29- set(${repository} ${git_output} PARENT_SCOPE)
30- else()
31- set(${repository} ${path} PARENT_SCOPE)
32- endif()
33+ # Do not show repo name in IR
34+ # execute_process(COMMAND ${GIT_EXECUTABLE} remote get-url ${remote}
35+ # WORKING_DIRECTORY ${path}
36+ # RESULT_VARIABLE git_result
37+ # OUTPUT_VARIABLE git_output
38+ # ERROR_QUIET)
39+ # if(git_result EQUAL 0)
40+ # string(STRIP "${git_output}" git_output)
41+ # set(${repository} ${git_output} PARENT_SCOPE)
42+ # else()
43+ # set(${repository} ${path} PARENT_SCOPE)
44+ # endif()
45 endif()
46 endif()
47 endfunction()
48--
492.18.1
50
diff --git a/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm10-skip-building-tests.patch b/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm10-skip-building-tests.patch
deleted file mode 100644
index 8e58ec25..00000000
--- a/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm10-skip-building-tests.patch
+++ /dev/null
@@ -1,51 +0,0 @@
1From 455ce9c25df5313f4a6649cc27075bdfbe25af18 Mon Sep 17 00:00:00 2001
2From: Naveen Saini <naveen.kumar.saini@intel.com>
3Date: Wed, 21 Aug 2019 14:35:31 +0800
4Subject: [PATCH] llvm-spirv: skip building tests
5
6Some of these need clang to be built and since we're building this in-tree,
7that leads to problems when compiling libcxx, compiler-rt which aren't built
8in-tree.
9
10Instead of using SPIRV_SKIP_CLANG_BUILD to skip clang build and adding this to
11all components, disable the building of tests altogether.
12
13Upstream-Status: Inappropriate
14
15Signed-off-by: Anuj Mittal <anuj.mittal@intel.com>
16Signed-off-by: Naveen Saini <naveen.kumar.saini@intel.com>
17---
18 CMakeLists.txt | 10 ----------
19 1 file changed, 10 deletions(-)
20
21diff --git a/CMakeLists.txt b/CMakeLists.txt
22index b718c00..9805140 100644
23--- a/CMakeLists.txt
24+++ b/CMakeLists.txt
25@@ -24,13 +24,6 @@ if(LLVM_SPIRV_BUILD_EXTERNAL)
26 set(CMAKE_CXX_STANDARD 14)
27 set(CMAKE_CXX_STANDARD_REQUIRED ON)
28
29- if(LLVM_SPIRV_INCLUDE_TESTS)
30- set(LLVM_TEST_COMPONENTS
31- llvm-as
32- llvm-dis
33- )
34- endif(LLVM_SPIRV_INCLUDE_TESTS)
35-
36 find_package(LLVM 10.0.0 REQUIRED
37 COMPONENTS
38 Analysis
39@@ -61,9 +54,6 @@ set(LLVM_SPIRV_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/include)
40
41 add_subdirectory(lib/SPIRV)
42 add_subdirectory(tools/llvm-spirv)
43-if(LLVM_SPIRV_INCLUDE_TESTS)
44- add_subdirectory(test)
45-endif(LLVM_SPIRV_INCLUDE_TESTS)
46
47 install(
48 FILES
49--
502.7.4
51
diff --git a/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm11-OpenCL-3.0-support.patch b/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm11-OpenCL-3.0-support.patch
deleted file mode 100644
index 98545db0..00000000
--- a/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm11-OpenCL-3.0-support.patch
+++ /dev/null
@@ -1,8453 +0,0 @@
1From d767afa79d1c8153081eac1ef33e348cadbea5bb Mon Sep 17 00:00:00 2001
2From: Anton Zabaznov <anton.zabaznov@intel.com>
3Date: Tue, 22 Sep 2020 19:03:50 +0300
4Subject: [PATCH] OpenCL 3.0 support
5
6Upstream-Status: Backport [Taken from opencl-clang patches, https://github.com/intel/opencl-clang/blob/ocl-open-110/patches/clang/0001-OpenCL-3.0-support.patch]
7Signed-off-by: Anton Zabaznov <anton.zabaznov@intel.com>
8Signed-off-by: Naveen Saini <naveen.kumar.saini@intel.com>
9
10
11---
12 clang/include/clang/Basic/Builtins.def | 65 +-
13 clang/include/clang/Basic/Builtins.h | 13 +-
14 .../clang/Basic/DiagnosticParseKinds.td | 2 +
15 .../clang/Basic/DiagnosticSemaKinds.td | 7 +
16 clang/include/clang/Basic/LangOptions.def | 2 +
17 clang/include/clang/Basic/LangStandards.def | 4 +
18 .../include/clang/Basic/OpenCLExtensions.def | 15 +
19 clang/include/clang/Basic/OpenCLOptions.h | 174 +-
20 clang/include/clang/Driver/Options.td | 2 +-
21 clang/include/clang/Sema/Sema.h | 9 +
22 clang/lib/AST/ASTContext.cpp | 3 +-
23 clang/lib/Basic/Builtins.cpp | 28 +-
24 clang/lib/Basic/TargetInfo.cpp | 11 +
25 clang/lib/Basic/Targets.cpp | 1 -
26 clang/lib/CodeGen/CodeGenFunction.cpp | 6 +-
27 clang/lib/Frontend/CompilerInvocation.cpp | 22 +-
28 clang/lib/Frontend/InitPreprocessor.cpp | 6 +-
29 clang/lib/Headers/opencl-c-base.h | 75 +-
30 clang/lib/Headers/opencl-c.h | 3216 ++++++++++++++---
31 clang/lib/Parse/ParseDecl.cpp | 12 +-
32 clang/lib/Parse/ParsePragma.cpp | 10 +-
33 clang/lib/Sema/OpenCLBuiltins.td | 153 +-
34 clang/lib/Sema/Sema.cpp | 47 +-
35 clang/lib/Sema/SemaChecking.cpp | 38 +-
36 clang/lib/Sema/SemaDecl.cpp | 18 +-
37 clang/lib/Sema/SemaDeclAttr.cpp | 9 +-
38 clang/lib/Sema/SemaDeclCXX.cpp | 12 +-
39 clang/lib/Sema/SemaLookup.cpp | 19 +-
40 clang/lib/Sema/SemaType.cpp | 14 +-
41 .../CodeGenOpenCL/addr-space-struct-arg.cl | 7 +-
42 .../address-spaces-conversions.cl | 2 +
43 .../CodeGenOpenCL/address-spaces-mangling.cl | 3 +-
44 clang/test/CodeGenOpenCL/address-spaces.cl | 4 +
45 .../amdgcn-automatic-variable.cl | 1 +
46 .../CodeGenOpenCL/amdgpu-sizeof-alignof.cl | 21 +-
47 .../CodeGenOpenCL/arm-integer-dot-product.cl | 1 +
48 .../test/CodeGenOpenCL/cl-uniform-wg-size.cl | 2 +
49 clang/test/CodeGenOpenCL/fpmath.cl | 2 +
50 .../generic-address-space-feature.cl | 28 +
51 .../intel-subgroups-avc-ext-types.cl | 1 +
52 .../kernels-have-spir-cc-by-default.cl | 3 +
53 clang/test/CodeGenOpenCL/logical-ops.cl | 1 +
54 clang/test/CodeGenOpenCL/no-half.cl | 1 +
55 clang/test/CodeGenOpenCL/pipe_builtin.cl | 3 +
56 clang/test/CodeGenOpenCL/pipe_types.cl | 1 +
57 clang/test/CodeGenOpenCL/printf.cl | 2 +
58 clang/test/CodeGenOpenCL/unroll-hint.cl | 1 +
59 clang/test/Driver/autocomplete.c | 2 +
60 clang/test/Driver/opencl.cl | 2 +
61 clang/test/Driver/unknown-std.cl | 1 +
62 clang/test/Frontend/stdlang.c | 1 +
63 clang/test/Headers/opencl-c-header.cl | 7 +-
64 clang/test/Index/pipe-size.cl | 7 +
65 clang/test/Preprocessor/init-aarch64.c | 12 +-
66 clang/test/Preprocessor/predefined-macros.c | 13 +
67 .../Sema/feature-extensions-simult-support.cl | 75 +
68 clang/test/Sema/features-ignore-pragma.cl | 24 +
69 clang/test/Sema/opencl-features-pipes.cl | 18 +
70 clang/test/Sema/opencl-features.cl | 128 +
71 clang/test/Sema/pipe_builtins_feature.cl | 21 +
72 .../address-spaces-conversions-cl2.0.cl | 3 +
73 clang/test/SemaOpenCL/address-spaces.cl | 1 +
74 .../SemaOpenCL/cl20-device-side-enqueue.cl | 16 +-
75 .../SemaOpenCL/forget-unsupported-builtins.cl | 22 +
76 clang/test/SemaOpenCL/image-features.cl | 20 +
77 .../SemaOpenCL/invalid-pipe-builtin-cl2.0.cl | 1 +
78 clang/test/SemaOpenCL/storageclass-cl20.cl | 1 +
79 .../TableGen/ClangOpenCLBuiltinEmitter.cpp | 35 +-
80 68 files changed, 3749 insertions(+), 738 deletions(-)
81 create mode 100644 clang/test/CodeGenOpenCL/generic-address-space-feature.cl
82 create mode 100644 clang/test/Sema/feature-extensions-simult-support.cl
83 create mode 100644 clang/test/Sema/features-ignore-pragma.cl
84 create mode 100644 clang/test/Sema/opencl-features-pipes.cl
85 create mode 100644 clang/test/Sema/opencl-features.cl
86 create mode 100644 clang/test/Sema/pipe_builtins_feature.cl
87 create mode 100644 clang/test/SemaOpenCL/forget-unsupported-builtins.cl
88 create mode 100644 clang/test/SemaOpenCL/image-features.cl
89
90diff --git a/clang/include/clang/Basic/Builtins.def b/clang/include/clang/Basic/Builtins.def
91index 5463b7dfc18c..e094beab9a6c 100644
92--- a/clang/include/clang/Basic/Builtins.def
93+++ b/clang/include/clang/Basic/Builtins.def
94@@ -111,6 +111,10 @@
95 # define LANGBUILTIN(ID, TYPE, ATTRS, BUILTIN_LANG) BUILTIN(ID, TYPE, ATTRS)
96 #endif
97
98+#if defined(BUILTIN) && !defined(OPENCLBUILTIN)
99+# define OPENCLBUILTIN(ID, TYPE, ATTRS, BUILTIN_LANG, FEATURE) BUILTIN(ID, TYPE, ATTRS)
100+#endif
101+
102 // Standard libc/libm functions:
103 BUILTIN(__builtin_atan2 , "ddd" , "Fne")
104 BUILTIN(__builtin_atan2f, "fff" , "Fne")
105@@ -1529,50 +1533,54 @@ BUILTIN(__builtin_coro_param, "bv*v*", "n")
106
107 // OpenCL v2.0 s6.13.16, s9.17.3.5 - Pipe functions.
108 // We need the generic prototype, since the packet type could be anything.
109-LANGBUILTIN(read_pipe, "i.", "tn", OCLC20_LANG)
110-LANGBUILTIN(write_pipe, "i.", "tn", OCLC20_LANG)
111+OPENCLBUILTIN(read_pipe, "i.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
112+OPENCLBUILTIN(write_pipe, "i.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
113
114-LANGBUILTIN(reserve_read_pipe, "i.", "tn", OCLC20_LANG)
115-LANGBUILTIN(reserve_write_pipe, "i.", "tn", OCLC20_LANG)
116+OPENCLBUILTIN(reserve_read_pipe, "i.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
117+OPENCLBUILTIN(reserve_write_pipe, "i.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
118
119-LANGBUILTIN(commit_write_pipe, "v.", "tn", OCLC20_LANG)
120-LANGBUILTIN(commit_read_pipe, "v.", "tn", OCLC20_LANG)
121+OPENCLBUILTIN(commit_write_pipe, "v.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
122+OPENCLBUILTIN(commit_read_pipe, "v.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
123
124-LANGBUILTIN(sub_group_reserve_read_pipe, "i.", "tn", OCLC20_LANG)
125-LANGBUILTIN(sub_group_reserve_write_pipe, "i.", "tn", OCLC20_LANG)
126+OPENCLBUILTIN(sub_group_reserve_read_pipe, "i.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
127+OPENCLBUILTIN(sub_group_reserve_write_pipe, "i.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
128
129-LANGBUILTIN(sub_group_commit_read_pipe, "v.", "tn", OCLC20_LANG)
130-LANGBUILTIN(sub_group_commit_write_pipe, "v.", "tn", OCLC20_LANG)
131+OPENCLBUILTIN(sub_group_commit_read_pipe, "v.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
132+OPENCLBUILTIN(sub_group_commit_write_pipe, "v.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
133
134-LANGBUILTIN(work_group_reserve_read_pipe, "i.", "tn", OCLC20_LANG)
135-LANGBUILTIN(work_group_reserve_write_pipe, "i.", "tn", OCLC20_LANG)
136+OPENCLBUILTIN(work_group_reserve_read_pipe, "i.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
137+OPENCLBUILTIN(work_group_reserve_write_pipe, "i.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
138
139-LANGBUILTIN(work_group_commit_read_pipe, "v.", "tn", OCLC20_LANG)
140-LANGBUILTIN(work_group_commit_write_pipe, "v.", "tn", OCLC20_LANG)
141+OPENCLBUILTIN(work_group_commit_read_pipe, "v.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
142+OPENCLBUILTIN(work_group_commit_write_pipe, "v.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
143
144-LANGBUILTIN(get_pipe_num_packets, "Ui.", "tn", OCLC20_LANG)
145-LANGBUILTIN(get_pipe_max_packets, "Ui.", "tn", OCLC20_LANG)
146+OPENCLBUILTIN(get_pipe_num_packets, "Ui.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
147+OPENCLBUILTIN(get_pipe_max_packets, "Ui.", "tn", OCLC2P_LANG, "__opencl_c_pipes")
148
149 // OpenCL v2.0 s6.13.17 - Enqueue kernel functions.
150 // Custom builtin check allows to perform special check of passed block arguments.
151-LANGBUILTIN(enqueue_kernel, "i.", "tn", OCLC20_LANG)
152-LANGBUILTIN(get_kernel_work_group_size, "Ui.", "tn", OCLC20_LANG)
153-LANGBUILTIN(get_kernel_preferred_work_group_size_multiple, "Ui.", "tn", OCLC20_LANG)
154-LANGBUILTIN(get_kernel_max_sub_group_size_for_ndrange, "Ui.", "tn", OCLC20_LANG)
155-LANGBUILTIN(get_kernel_sub_group_count_for_ndrange, "Ui.", "tn", OCLC20_LANG)
156+OPENCLBUILTIN(enqueue_kernel, "i.", "tn", OCLC2P_LANG,
157+ "__opencl_c_device_enqueue")
158+OPENCLBUILTIN(get_kernel_work_group_size, "Ui.", "tn", OCLC2P_LANG,
159+ "__opencl_c_device_enqueue")
160+OPENCLBUILTIN(get_kernel_preferred_work_group_size_multiple, "Ui.", "tn",
161+ OCLC2P_LANG, "__opencl_c_device_enqueue")
162+OPENCLBUILTIN(get_kernel_max_sub_group_size_for_ndrange, "Ui.", "tn",
163+ OCLC2P_LANG, "__opencl_c_device_enqueue")
164+OPENCLBUILTIN(get_kernel_sub_group_count_for_ndrange, "Ui.", "tn", OCLC2P_LANG, "__opencl_c_device_enqueue")
165
166 // OpenCL v2.0 s6.13.9 - Address space qualifier functions.
167 // FIXME: Pointer parameters of OpenCL builtins should have their address space
168 // requirement defined.
169-LANGBUILTIN(to_global, "v*v*", "tn", OCLC20_LANG)
170-LANGBUILTIN(to_local, "v*v*", "tn", OCLC20_LANG)
171-LANGBUILTIN(to_private, "v*v*", "tn", OCLC20_LANG)
172+OPENCLBUILTIN(to_global, "v*v*", "tn", OCLC2P_LANG, "__opencl_c_generic_address_space")
173+OPENCLBUILTIN(to_local, "v*v*", "tn", OCLC2P_LANG, "__opencl_c_generic_address_space")
174+OPENCLBUILTIN(to_private, "v*v*", "tn", OCLC2P_LANG, "__opencl_c_generic_address_space")
175
176 // OpenCL half load/store builtin
177-LANGBUILTIN(__builtin_store_half, "vdh*", "n", ALL_OCLC_LANGUAGES)
178-LANGBUILTIN(__builtin_store_halff, "vfh*", "n", ALL_OCLC_LANGUAGES)
179-LANGBUILTIN(__builtin_load_half, "dhC*", "nc", ALL_OCLC_LANGUAGES)
180-LANGBUILTIN(__builtin_load_halff, "fhC*", "nc", ALL_OCLC_LANGUAGES)
181+OPENCLBUILTIN(__builtin_store_half, "vdh*", "n", ALL_OCLC_LANGUAGES, "")
182+OPENCLBUILTIN(__builtin_store_halff, "vfh*", "n", ALL_OCLC_LANGUAGES, "")
183+OPENCLBUILTIN(__builtin_load_half, "dhC*", "nc", ALL_OCLC_LANGUAGES, "")
184+OPENCLBUILTIN(__builtin_load_halff, "fhC*", "nc", ALL_OCLC_LANGUAGES, "")
185
186 // Builtins for os_log/os_trace
187 BUILTIN(__builtin_os_log_format_buffer_size, "zcC*.", "p:0:nut")
188@@ -1593,3 +1601,4 @@ BUILTIN(__builtin_ms_va_copy, "vc*&c*&", "n")
189 #undef BUILTIN
190 #undef LIBBUILTIN
191 #undef LANGBUILTIN
192+#undef OPENCLBUILTIN
193diff --git a/clang/include/clang/Basic/Builtins.h b/clang/include/clang/Basic/Builtins.h
194index 15bfcf797917..ba3e7853444c 100644
195--- a/clang/include/clang/Basic/Builtins.h
196+++ b/clang/include/clang/Basic/Builtins.h
197@@ -33,13 +33,13 @@ enum LanguageID {
198 CXX_LANG = 0x4, // builtin for cplusplus only.
199 OBJC_LANG = 0x8, // builtin for objective-c and objective-c++
200 MS_LANG = 0x10, // builtin requires MS mode.
201- OCLC20_LANG = 0x20, // builtin for OpenCL C 2.0 only.
202+ OCLC2P_LANG = 0x20, // builtin for OpenCL C 2.0+ versions.
203 OCLC1X_LANG = 0x40, // builtin for OpenCL C 1.x only.
204 OMP_LANG = 0x80, // builtin requires OpenMP.
205 ALL_LANGUAGES = C_LANG | CXX_LANG | OBJC_LANG, // builtin for all languages.
206 ALL_GNU_LANGUAGES = ALL_LANGUAGES | GNU_LANG, // builtin requires GNU mode.
207 ALL_MS_LANGUAGES = ALL_LANGUAGES | MS_LANG, // builtin requires MS mode.
208- ALL_OCLC_LANGUAGES = OCLC1X_LANG | OCLC20_LANG // builtin for OCLC languages.
209+ ALL_OCLC_LANGUAGES = OCLC1X_LANG | OCLC2P_LANG // builtin for OCLC languages.
210 };
211
212 namespace Builtin {
213@@ -235,6 +235,10 @@ public:
214 /// for non-builtins.
215 bool canBeRedeclared(unsigned ID) const;
216
217+ bool requiresFeatures(unsigned ID) const {
218+ return requiresFeatures(getRecord(ID));
219+ }
220+
221 private:
222 const Info &getRecord(unsigned ID) const;
223
224@@ -242,6 +246,11 @@ private:
225 bool builtinIsSupported(const Builtin::Info &BuiltinInfo,
226 const LangOptions &LangOpts);
227
228+ bool OclBuiltinIsSupported(const Builtin::Info &BuiltinInfo,
229+ const LangOptions &LangOpts) const;
230+
231+ bool requiresFeatures(const Builtin::Info &BuiltinInfo) const;
232+
233 /// Helper function for isPrintfLike and isScanfLike.
234 bool isLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg,
235 const char *Fmt) const;
236diff --git a/clang/include/clang/Basic/DiagnosticParseKinds.td b/clang/include/clang/Basic/DiagnosticParseKinds.td
237index 1038a4119d4c..ba1b1b67a131 100644
238--- a/clang/include/clang/Basic/DiagnosticParseKinds.td
239+++ b/clang/include/clang/Basic/DiagnosticParseKinds.td
240@@ -1206,6 +1206,8 @@ def warn_pragma_unsupported_extension : Warning<
241 "unsupported OpenCL extension %0 - ignoring">, InGroup<IgnoredPragmas>;
242 def warn_pragma_extension_is_core : Warning<
243 "OpenCL extension %0 is core feature or supported optional core feature - ignoring">, InGroup<DiagGroup<"pedantic-core-features">>, DefaultIgnore;
244+def warn_opencl_pragma_feature_ignore : Warning<
245+ "OpenCL feature support can't be controlled via pragma, ignoring">, InGroup<IgnoredPragmas>;
246
247 // OpenCL errors.
248 def err_opencl_taking_function_address_parser : Error<
249diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
250index 941f2cafc372..aa9e8b7b011b 100644
251--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
252+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
253@@ -9741,6 +9741,13 @@ def ext_opencl_ext_vector_type_rgba_selector: ExtWarn<
254 def err_openclcxx_placement_new : Error<
255 "use of placement new requires explicit declaration">;
256
257+def err_opencl_pipes_require_feat : Error<
258+ "usage of OpenCL pipes requires feature support">;
259+def err_opencl_memory_scope_require_feat : Error<
260+ "usage of memory scope requires feature support">;
261+def err_opencl_memory_ordering_require_feat : Error<
262+ "usage of memory ordering requires feature support">;
263+
264 // MIG routine annotations.
265 def warn_mig_server_routine_does_not_return_kern_return_t : Warning<
266 "'mig_server_routine' attribute only applies to routines that return a kern_return_t">,
267diff --git a/clang/include/clang/Basic/LangOptions.def b/clang/include/clang/Basic/LangOptions.def
268index 70f68d664bb7..e683f5956975 100644
269--- a/clang/include/clang/Basic/LangOptions.def
270+++ b/clang/include/clang/Basic/LangOptions.def
271@@ -215,6 +215,8 @@ LANGOPT(OpenCL , 1, 0, "OpenCL")
272 LANGOPT(OpenCLVersion , 32, 0, "OpenCL C version")
273 LANGOPT(OpenCLCPlusPlus , 1, 0, "C++ for OpenCL")
274 LANGOPT(OpenCLCPlusPlusVersion , 32, 0, "C++ for OpenCL version")
275+LANGOPT(OpenCLGenericKeyword , 1, 0, "OpenCL generic keyword")
276+LANGOPT(OpenCLPipeKeyword , 1, 0, "OpenCL pipe keyword")
277 LANGOPT(NativeHalfType , 1, 0, "Native half type support")
278 LANGOPT(NativeHalfArgsAndReturns, 1, 0, "Native half args and returns")
279 LANGOPT(HalfArgsAndReturns, 1, 0, "half args and returns")
280diff --git a/clang/include/clang/Basic/LangStandards.def b/clang/include/clang/Basic/LangStandards.def
281index b09568e8b3e8..7b915c312746 100644
282--- a/clang/include/clang/Basic/LangStandards.def
283+++ b/clang/include/clang/Basic/LangStandards.def
284@@ -167,6 +167,9 @@ LANGSTANDARD(opencl12, "cl1.2",
285 LANGSTANDARD(opencl20, "cl2.0",
286 OpenCL, "OpenCL 2.0",
287 LineComment | C99 | Digraphs | HexFloat | OpenCL)
288+LANGSTANDARD(opencl30, "cl3.0",
289+ OpenCL, "OpenCL 3.0",
290+ LineComment | C99 | Digraphs | HexFloat | OpenCL)
291 LANGSTANDARD(openclcpp, "clc++",
292 OpenCL, "C++ for OpenCL",
293 LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 |
294@@ -176,6 +179,7 @@ LANGSTANDARD_ALIAS_DEPR(opencl10, "CL")
295 LANGSTANDARD_ALIAS_DEPR(opencl11, "CL1.1")
296 LANGSTANDARD_ALIAS_DEPR(opencl12, "CL1.2")
297 LANGSTANDARD_ALIAS_DEPR(opencl20, "CL2.0")
298+LANGSTANDARD_ALIAS_DEPR(opencl30, "CL3.0")
299 LANGSTANDARD_ALIAS_DEPR(openclcpp, "CLC++")
300
301 // CUDA
302diff --git a/clang/include/clang/Basic/OpenCLExtensions.def b/clang/include/clang/Basic/OpenCLExtensions.def
303index 1ae36b32fb0a..d1574164f9b2 100644
304--- a/clang/include/clang/Basic/OpenCLExtensions.def
305+++ b/clang/include/clang/Basic/OpenCLExtensions.def
306@@ -100,6 +100,21 @@ OPENCLEXT_INTERNAL(cl_intel_subgroups, 120, ~0U)
307 OPENCLEXT_INTERNAL(cl_intel_subgroups_short, 120, ~0U)
308 OPENCLEXT_INTERNAL(cl_intel_device_side_avc_motion_estimation, 120, ~0U)
309
310+OPENCLEXT_INTERNAL(__opencl_c_pipes, 200, ~0U)
311+OPENCLEXT_INTERNAL(__opencl_c_generic_address_space, 200, ~0U)
312+OPENCLEXT_INTERNAL(__opencl_c_work_group_collective_functions, 200, ~0U)
313+OPENCLEXT_INTERNAL(__opencl_c_atomic_order_acq_rel, 200, ~0U)
314+OPENCLEXT_INTERNAL(__opencl_c_atomic_order_seq_cst, 200, ~0U)
315+OPENCLEXT_INTERNAL(__opencl_c_atomic_scope_device, 200, ~0U)
316+OPENCLEXT_INTERNAL(__opencl_c_atomic_scope_all_devices, 200, ~0U)
317+OPENCLEXT_INTERNAL(__opencl_c_subgroups, 200, ~0U)
318+OPENCLEXT_INTERNAL(__opencl_c_3d_image_writes, 100, ~0U)
319+OPENCLEXT_INTERNAL(__opencl_c_device_enqueue, 200, ~0U)
320+OPENCLEXT_INTERNAL(__opencl_c_read_write_images, 200, ~0U)
321+OPENCLEXT_INTERNAL(__opencl_c_program_scope_global_variables, 200, ~0U)
322+OPENCLEXT_INTERNAL(__opencl_c_fp64, 120, ~0U)
323+OPENCLEXT_INTERNAL(__opencl_c_int64, 100, ~0U)
324+OPENCLEXT_INTERNAL(__opencl_c_images, 100, ~0U)
325 #undef OPENCLEXT_INTERNAL
326
327 #ifdef OPENCLEXT
328diff --git a/clang/include/clang/Basic/OpenCLOptions.h b/clang/include/clang/Basic/OpenCLOptions.h
329index 15661154eab5..d5800f5611c6 100644
330--- a/clang/include/clang/Basic/OpenCLOptions.h
331+++ b/clang/include/clang/Basic/OpenCLOptions.h
332@@ -21,6 +21,10 @@ namespace clang {
333
334 /// OpenCL supported extensions and optional core features
335 class OpenCLOptions {
336+ // OpenCL Version
337+ unsigned CLVer = 120;
338+ bool IsOpenCLCPlusPlus = false;
339+
340 struct Info {
341 bool Supported; // Is this option supported
342 bool Enabled; // Is this option enabled
343@@ -31,7 +35,38 @@ class OpenCLOptions {
344 :Supported(S), Enabled(E), Avail(A), Core(C){}
345 };
346 llvm::StringMap<Info> OptMap;
347+
348 public:
349+ void setOpenCLVersion(const LangOptions &LO) {
350+ IsOpenCLCPlusPlus = LO.OpenCLCPlusPlus;
351+ CLVer = IsOpenCLCPlusPlus ? 200 : LO.OpenCLVersion;
352+ }
353+
354+ // Get extension which is semantically equivalent to a given feature
355+ // if exists (e.g. __opencl_c_subgroups -> cl_khr_subgroups)
356+ llvm::Optional<StringRef> getEquivalentExtension(StringRef Feature) const {
357+ return llvm::StringSwitch<llvm::Optional<StringRef>>(Feature)
358+ .Case("__opencl_c_3d_image_writes",
359+ Optional<StringRef>("cl_khr_3d_image_writes"))
360+ .Case("__opencl_c_subgroups", Optional<StringRef>("cl_khr_subgroups"))
361+ .Case("__opencl_c_fp64", Optional<StringRef>("cl_khr_fp64"))
362+ .Default(Optional<StringRef>());
363+ }
364+
365+ // Same as above but for extensions
366+ llvm::Optional<StringRef> getEquivalentFeature(StringRef Extension) const {
367+ return llvm::StringSwitch<llvm::Optional<StringRef>>(Extension)
368+ .Case("cl_khr_3d_image_writes",
369+ Optional<StringRef>("__opencl_c_3d_image_writes"))
370+ .Case("cl_khr_subgroups", Optional<StringRef>("__opencl_c_subgroups"))
371+ .Case("cl_khr_fp64", Optional<StringRef>("__opencl_c_fp64"))
372+ .Default(Optional<StringRef>());
373+ }
374+
375+ bool isFeature(llvm::StringRef Ext) const {
376+ return Ext.startswith("__opencl_c");
377+ }
378+
379 bool isKnown(llvm::StringRef Ext) const {
380 return OptMap.find(Ext) != OptMap.end();
381 }
382@@ -42,32 +77,88 @@ public:
383
384 // Is supported as either an extension or an (optional) core feature for
385 // OpenCL version \p CLVer.
386- bool isSupported(llvm::StringRef Ext, const LangOptions &LO) const {
387+ bool isSupported(llvm::StringRef Ext) const {
388 // In C++ mode all extensions should work at least as in v2.0.
389- auto CLVer = LO.OpenCLCPlusPlus ? 200 : LO.OpenCLVersion;
390 auto I = OptMap.find(Ext)->getValue();
391 return I.Supported && I.Avail <= CLVer;
392 }
393
394 // Is supported (optional) OpenCL core features for OpenCL version \p CLVer.
395 // For supported extension, return false.
396- bool isSupportedCore(llvm::StringRef Ext, const LangOptions &LO) const {
397+ bool isSupportedCore(llvm::StringRef Ext) const {
398 // In C++ mode all extensions should work at least as in v2.0.
399- auto CLVer = LO.OpenCLCPlusPlus ? 200 : LO.OpenCLVersion;
400 auto I = OptMap.find(Ext)->getValue();
401 return I.Supported && I.Avail <= CLVer && I.Core != ~0U && CLVer >= I.Core;
402 }
403
404 // Is supported OpenCL extension for OpenCL version \p CLVer.
405 // For supported (optional) core feature, return false.
406- bool isSupportedExtension(llvm::StringRef Ext, const LangOptions &LO) const {
407+ bool isSupportedExtension(llvm::StringRef Ext) const {
408 // In C++ mode all extensions should work at least as in v2.0.
409- auto CLVer = LO.OpenCLCPlusPlus ? 200 : LO.OpenCLVersion;
410 auto I = OptMap.find(Ext)->getValue();
411 return I.Supported && I.Avail <= CLVer && (I.Core == ~0U || CLVer < I.Core);
412 }
413
414+ // Support features whose support is directly related to the
415+ // specific OpenCL version. For example, OpenCL 2.0 supports
416+ // all features that are optional in 3.0
417+ void adjustFeatures() {
418+ // Support int64 by default (assume compiling for FULL profile)
419+ OptMap["__opencl_c_int64"].Supported = true;
420+
421+ if (CLVer >= 300) {
422+ // Simultaneously support extension and corresponding feature
423+ for (llvm::StringRef F :
424+ {"__opencl_c_subgroups", "__opencl_c_3d_image_writes",
425+ "__opencl_c_fp64"}) {
426+ auto Ext = getEquivalentExtension(F);
427+ OptMap[*Ext].Supported = OptMap[F].Supported;
428+ }
429+
430+ // OpenCL C compilers that define the feature macro __opencl_c_pipes or
431+ // or __opencl_c_device_enqueue must also define the
432+ // feature macro __opencl_c_generic_address_space.
433+ if (OptMap["__opencl_c_pipes"].Supported ||
434+ OptMap["__opencl_c_device_enqueue"].Supported)
435+ OptMap["__opencl_c_generic_address_space"].Supported = true;
436+
437+ // OpenCL C compilers that define the feature macro
438+ // __opencl_c_3d_image_writes or __opencl_c_read_write_images must also
439+ // define the feature macro __opencl_c_images
440+ if (OptMap["__opencl_c_3d_image_writes"].Supported ||
441+ OptMap["__opencl_c_read_write_images"].Supported)
442+ OptMap["__opencl_c_images"].Supported = true;
443+
444+ // All other features are already supported with options
445+ // or in target settings
446+ return;
447+ }
448+
449+ auto FeaturesRange = llvm::make_filter_range(
450+ OptMap, [&](llvm::StringMapEntry<Info> &OptVal) {
451+ auto Opt = OptVal.getKey();
452+ return isFeature(Opt);
453+ });
454+
455+ for (auto &It : FeaturesRange) {
456+ auto &Info = It.getValue();
457+ // For OpenCL version less then 3.0 some
458+ // features should be supported simulateneously
459+ // with specific extension
460+ if (Optional<llvm::StringRef> Ext = getEquivalentExtension(It.getKey()))
461+ Info.Supported = Info.Enabled = OptMap[*Ext].Supported;
462+ else if (Info.Avail <= CLVer)
463+ Info.Supported = Info.Enabled = true;
464+ }
465+ }
466+
467 void enable(llvm::StringRef Ext, bool V = true) {
468+ // Ignore disabling extensions if corresponding features
469+ // already supported for OpenCL version higher then 3.0
470+ if (CLVer >= 300)
471+ if (Optional<llvm::StringRef> F = getEquivalentFeature(Ext))
472+ if (V != OptMap[*F].Enabled)
473+ return;
474 OptMap[Ext].Enabled = V;
475 }
476
477@@ -96,7 +187,7 @@ public:
478 OptMap[Ext].Supported = V;
479 }
480
481- OpenCLOptions(){
482+ OpenCLOptions() {
483 #define OPENCLEXT_INTERNAL(Ext, AvailVer, CoreVer) \
484 OptMap[#Ext].Avail = AvailVer; \
485 OptMap[#Ext].Core = CoreVer;
486@@ -104,35 +195,86 @@ public:
487 }
488
489 void addSupport(const OpenCLOptions &Opts) {
490+ assert(IsOpenCLCPlusPlus == Opts.IsOpenCLCPlusPlus && CLVer == Opts.CLVer);
491 for (auto &I:Opts.OptMap)
492- if (I.second.Supported)
493+ if (I.second.Supported) {
494 OptMap[I.getKey()].Supported = true;
495+ // All features are enabled as they are supported
496+ if (isFeature(I.getKey()))
497+ OptMap[I.getKey()].Enabled = true;
498+ }
499+ if (CLVer >= 300) {
500+ // Enabling extensions with respect to features
501+ for (llvm::StringRef Ext :
502+ {"cl_khr_3d_image_writes", "cl_khr_subgroups", "cl_khr_fp64"}) {
503+ auto Feature = getEquivalentFeature(Ext);
504+ enable(Ext, OptMap[*Feature].Enabled);
505+ }
506+ }
507 }
508
509 void copy(const OpenCLOptions &Opts) {
510+ CLVer = Opts.CLVer;
511+ IsOpenCLCPlusPlus = Opts.IsOpenCLCPlusPlus;
512 OptMap = Opts.OptMap;
513 }
514
515 // Turn on or off support of all options.
516 void supportAll(bool On = true) {
517- for (llvm::StringMap<Info>::iterator I = OptMap.begin(),
518- E = OptMap.end(); I != E; ++I)
519- I->second.Supported = On;
520+ for (llvm::StringMap<Info>::iterator I = OptMap.begin(), E = OptMap.end();
521+ I != E; ++I)
522+ if (!isFeature(I->getKey()))
523+ I->second.Supported = On;
524 }
525
526 void disableAll() {
527- for (llvm::StringMap<Info>::iterator I = OptMap.begin(),
528- E = OptMap.end(); I != E; ++I)
529- I->second.Enabled = false;
530+ for (llvm::StringMap<Info>::iterator I = OptMap.begin(), E = OptMap.end();
531+ I != E; ++I) {
532+ auto Ext = I->getKey();
533+ if (!isFeature(Ext))
534+ enable(Ext, false);
535+ }
536 }
537
538- void enableSupportedCore(LangOptions LO) {
539+ void enableSupportedCore() {
540 for (llvm::StringMap<Info>::iterator I = OptMap.begin(), E = OptMap.end();
541 I != E; ++I)
542- if (isSupportedCore(I->getKey(), LO))
543+ if (isSupportedCore(I->getKey()))
544 I->second.Enabled = true;
545 }
546
547+ // This enum specifies how OpenCL versions map into values
548+ // for encoding. This is used when generating built-ins
549+ // from tablegen
550+ enum OpenCLVersionsEncodings : unsigned short {
551+ OPENCL_C_100_CODE = 0x1,
552+ OPENCL_C_110_CODE = 0x2,
553+ OPENCL_C_120_CODE = 0x4,
554+ OPENCL_C_200_CODE = 0x8,
555+ OPENCL_C_300_CODE = 0x10,
556+ OPENCL_C_ALL_CODE = 0x1f
557+ };
558+
559+ // Encode version into single integer
560+ static unsigned short EncodeVersion(unsigned OpenCLVersion) {
561+ switch (OpenCLVersion) {
562+ default:
563+ llvm_unreachable("Unknown OpenCL version");
564+ case 0:
565+ return OpenCLVersionsEncodings::OPENCL_C_ALL_CODE;
566+ case 100:
567+ return OpenCLVersionsEncodings::OPENCL_C_100_CODE;
568+ case 110:
569+ return OpenCLVersionsEncodings::OPENCL_C_110_CODE;
570+ case 120:
571+ return OpenCLVersionsEncodings::OPENCL_C_120_CODE;
572+ case 200:
573+ return OpenCLVersionsEncodings::OPENCL_C_200_CODE;
574+ case 300:
575+ return OpenCLVersionsEncodings::OPENCL_C_300_CODE;
576+ }
577+ }
578+
579 friend class ASTWriter;
580 friend class ASTReader;
581 };
582diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
583index 966cb907b7e2..62536f2470c2 100644
584--- a/clang/include/clang/Driver/Options.td
585+++ b/clang/include/clang/Driver/Options.td
586@@ -557,7 +557,7 @@ def cl_mad_enable : Flag<["-"], "cl-mad-enable">, Group<opencl_Group>, Flags<[CC
587 def cl_no_signed_zeros : Flag<["-"], "cl-no-signed-zeros">, Group<opencl_Group>, Flags<[CC1Option]>,
588 HelpText<"OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.">;
589 def cl_std_EQ : Joined<["-"], "cl-std=">, Group<opencl_Group>, Flags<[CC1Option]>,
590- HelpText<"OpenCL language standard to compile for.">, Values<"cl,CL,cl1.1,CL1.1,cl1.2,CL1.2,cl2.0,CL2.0,clc++,CLC++">;
591+ HelpText<"OpenCL language standard to compile for.">, Values<"cl,CL,cl1.1,CL1.1,cl1.2,CL1.2,cl2.0,CL2.0,cl3.0,CL3.0,clc++,CLC++">;
592 def cl_denorms_are_zero : Flag<["-"], "cl-denorms-are-zero">, Group<opencl_Group>,
593 HelpText<"OpenCL only. Allow denormals to be flushed to zero.">;
594 def cl_fp32_correctly_rounded_divide_sqrt : Flag<["-"], "cl-fp32-correctly-rounded-divide-sqrt">, Group<opencl_Group>, Flags<[CC1Option]>,
595diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
596index 16a7084f6b08..5920c27229d8 100644
597--- a/clang/include/clang/Sema/Sema.h
598+++ b/clang/include/clang/Sema/Sema.h
599@@ -9930,6 +9930,10 @@ public:
600 /// \return true if type is disabled.
601 bool checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E);
602
603+ bool checkOpenCLSubgroupExtForCallExpr(CallExpr *Call);
604+
605+ bool isSupportedOpenCLOMemoryOrdering(int64_t Ordering) const;
606+
607 //===--------------------------------------------------------------------===//
608 // OpenMP directives and clauses.
609 //
610@@ -11527,6 +11531,11 @@ public:
611 /// that the user intended an assignment used as condition.
612 void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE);
613
614+ template <typename DiagLocT, typename DiagInfoT>
615+ void DiagnoseOpenCLRequiresOption(llvm::StringRef OpenCLOptName,
616+ DiagLocT DiagLoc, DiagInfoT DiagInfo,
617+ unsigned Selector, SourceRange SrcRange);
618+
619 /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
620 ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr = false);
621
622diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
623index bf51d35d9693..a54ea8475d7d 100644
624--- a/clang/lib/AST/ASTContext.cpp
625+++ b/clang/lib/AST/ASTContext.cpp
626@@ -1433,7 +1433,8 @@ void ASTContext::InitBuiltinTypes(const TargetInfo &Target,
627 ObjCSuperType = QualType();
628
629 // void * type
630- if (LangOpts.OpenCLVersion >= 200) {
631+ if (Target.getSupportedOpenCLOpts().isEnabled(
632+ "__opencl_c_generic_address_space")) {
633 auto Q = VoidTy.getQualifiers();
634 Q.setAddressSpace(LangAS::opencl_generic);
635 VoidPtrTy = getPointerType(getCanonicalType(
636diff --git a/clang/lib/Basic/Builtins.cpp b/clang/lib/Basic/Builtins.cpp
637index 0cd89df41b67..7a3067345098 100644
638--- a/clang/lib/Basic/Builtins.cpp
639+++ b/clang/lib/Basic/Builtins.cpp
640@@ -23,6 +23,8 @@ static const Builtin::Info BuiltinInfo[] = {
641 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
642 #define LANGBUILTIN(ID, TYPE, ATTRS, LANGS) \
643 { #ID, TYPE, ATTRS, nullptr, LANGS, nullptr },
644+#define OPENCLBUILTIN(ID, TYPE, ATTRS, LANGS, FEATURE) \
645+ {#ID, TYPE, ATTRS, nullptr, LANGS, FEATURE},
646 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER, LANGS) \
647 { #ID, TYPE, ATTRS, HEADER, LANGS, nullptr },
648 #include "clang/Basic/Builtins.def"
649@@ -69,16 +71,17 @@ bool Builtin::Context::builtinIsSupported(const Builtin::Info &BuiltinInfo,
650 bool ObjCUnsupported = !LangOpts.ObjC && BuiltinInfo.Langs == OBJC_LANG;
651 bool OclC1Unsupported = (LangOpts.OpenCLVersion / 100) != 1 &&
652 (BuiltinInfo.Langs & ALL_OCLC_LANGUAGES ) == OCLC1X_LANG;
653- bool OclC2Unsupported =
654- (LangOpts.OpenCLVersion != 200 && !LangOpts.OpenCLCPlusPlus) &&
655- (BuiltinInfo.Langs & ALL_OCLC_LANGUAGES) == OCLC20_LANG;
656+ bool OclC2PUnsupported =
657+ (BuiltinInfo.Langs & ALL_OCLC_LANGUAGES) == OCLC2P_LANG &&
658+ ((LangOpts.OpenCLVersion < 200 && !LangOpts.OpenCLCPlusPlus) ||
659+ !OclBuiltinIsSupported(BuiltinInfo, LangOpts));
660 bool OclCUnsupported = !LangOpts.OpenCL &&
661 (BuiltinInfo.Langs & ALL_OCLC_LANGUAGES);
662 bool OpenMPUnsupported = !LangOpts.OpenMP && BuiltinInfo.Langs == OMP_LANG;
663 bool CPlusPlusUnsupported =
664 !LangOpts.CPlusPlus && BuiltinInfo.Langs == CXX_LANG;
665 return !BuiltinsUnsupported && !MathBuiltinsUnsupported && !OclCUnsupported &&
666- !OclC1Unsupported && !OclC2Unsupported && !OpenMPUnsupported &&
667+ !OclC1Unsupported && !OclC2PUnsupported && !OpenMPUnsupported &&
668 !GnuModeUnsupported && !MSModeUnsupported && !ObjCUnsupported &&
669 !CPlusPlusUnsupported;
670 }
671@@ -191,3 +194,20 @@ bool Builtin::Context::canBeRedeclared(unsigned ID) const {
672 (!hasReferenceArgsOrResult(ID) &&
673 !hasCustomTypechecking(ID));
674 }
675+
676+bool Builtin::Context::OclBuiltinIsSupported(
677+ const Builtin::Info &BuiltinInfo, const LangOptions &LangOpts) const {
678+ if (!requiresFeatures(BuiltinInfo))
679+ return true;
680+
681+ return llvm::StringSwitch<bool>(BuiltinInfo.Features)
682+ .Case("__opencl_c_device_enqueue", LangOpts.Blocks)
683+ .Case("__opencl_c_generic_address_space", LangOpts.OpenCLGenericKeyword)
684+ .Case("__opencl_c_pipes", LangOpts.OpenCLPipeKeyword)
685+ .Default(false);
686+}
687+
688+bool Builtin::Context::requiresFeatures(
689+ const Builtin::Info &BuiltinInfo) const {
690+ return BuiltinInfo.Features && llvm::StringRef(BuiltinInfo.Features) != "";
691+}
692diff --git a/clang/lib/Basic/TargetInfo.cpp b/clang/lib/Basic/TargetInfo.cpp
693index eccdc21d724a..6b4f524d5271 100644
694--- a/clang/lib/Basic/TargetInfo.cpp
695+++ b/clang/lib/Basic/TargetInfo.cpp
696@@ -387,6 +387,17 @@ void TargetInfo::adjust(LangOptions &Opts) {
697 HalfFormat = &llvm::APFloat::IEEEhalf();
698 FloatFormat = &llvm::APFloat::IEEEsingle();
699 LongDoubleFormat = &llvm::APFloat::IEEEquad();
700+
701+ auto &SupportedOCLOpts = getTargetOpts().SupportedOpenCLOptions;
702+
703+ SupportedOCLOpts.setOpenCLVersion(Opts);
704+ SupportedOCLOpts.adjustFeatures();
705+
706+ if (!Opts.OpenCLCPlusPlus && Opts.OpenCLVersion >= 200)
707+ Opts.Blocks = SupportedOCLOpts.isSupported("__opencl_c_device_enqueue");
708+ Opts.OpenCLGenericKeyword =
709+ SupportedOCLOpts.isSupported("__opencl_c_generic_address_space");
710+ Opts.OpenCLPipeKeyword = SupportedOCLOpts.isSupported("__opencl_c_pipes");
711 }
712
713 if (Opts.DoubleSize) {
714diff --git a/clang/lib/Basic/Targets.cpp b/clang/lib/Basic/Targets.cpp
715index 965f273892bd..046d7c15f835 100644
716--- a/clang/lib/Basic/Targets.cpp
717+++ b/clang/lib/Basic/Targets.cpp
718@@ -40,7 +40,6 @@
719 #include "clang/Basic/Diagnostic.h"
720 #include "llvm/ADT/StringExtras.h"
721 #include "llvm/ADT/Triple.h"
722-
723 using namespace clang;
724
725 namespace clang {
726diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp
727index 8ce488f35dd3..ca4cb0fbf018 100644
728--- a/clang/lib/CodeGen/CodeGenFunction.cpp
729+++ b/clang/lib/CodeGen/CodeGenFunction.cpp
730@@ -2306,11 +2306,11 @@ void CodeGenFunction::checkTargetFeatures(SourceLocation Loc,
731 std::string MissingFeature;
732 if (BuiltinID) {
733 SmallVector<StringRef, 1> ReqFeatures;
734- const char *FeatureList =
735- CGM.getContext().BuiltinInfo.getRequiredFeatures(BuiltinID);
736 // Return if the builtin doesn't have any required features.
737- if (!FeatureList || StringRef(FeatureList) == "")
738+ if (!CGM.getContext().BuiltinInfo.requiresFeatures(BuiltinID))
739 return;
740+ const char *FeatureList =
741+ CGM.getContext().BuiltinInfo.getRequiredFeatures(BuiltinID);
742 StringRef(FeatureList).split(ReqFeatures, ',');
743 if (!hasRequiredFeatures(ReqFeatures, CGM, FD, MissingFeature))
744 CGM.getDiags().Report(Loc, diag::err_builtin_needs_feature)
745diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp
746index 73114c6d76cb..bc54d231b97a 100644
747--- a/clang/lib/Frontend/CompilerInvocation.cpp
748+++ b/clang/lib/Frontend/CompilerInvocation.cpp
749@@ -2344,6 +2344,8 @@ void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK,
750 Opts.OpenCLVersion = 120;
751 else if (LangStd == LangStandard::lang_opencl20)
752 Opts.OpenCLVersion = 200;
753+ else if (LangStd == LangStandard::lang_opencl30)
754+ Opts.OpenCLVersion = 300;
755 else if (LangStd == LangStandard::lang_openclcpp)
756 Opts.OpenCLCPlusPlusVersion = 100;
757
758@@ -2544,14 +2546,15 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
759 // -cl-std only applies for OpenCL language standards.
760 // Override the -std option in this case.
761 if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
762- LangStandard::Kind OpenCLLangStd
763- = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
764- .Cases("cl", "CL", LangStandard::lang_opencl10)
765- .Cases("cl1.1", "CL1.1", LangStandard::lang_opencl11)
766- .Cases("cl1.2", "CL1.2", LangStandard::lang_opencl12)
767- .Cases("cl2.0", "CL2.0", LangStandard::lang_opencl20)
768- .Cases("clc++", "CLC++", LangStandard::lang_openclcpp)
769- .Default(LangStandard::lang_unspecified);
770+ LangStandard::Kind OpenCLLangStd =
771+ llvm::StringSwitch<LangStandard::Kind>(A->getValue())
772+ .Cases("cl", "CL", LangStandard::lang_opencl10)
773+ .Cases("cl1.1", "CL1.1", LangStandard::lang_opencl11)
774+ .Cases("cl1.2", "CL1.2", LangStandard::lang_opencl12)
775+ .Cases("cl2.0", "CL2.0", LangStandard::lang_opencl20)
776+ .Cases("cl3.0", "CL3.0", LangStandard::lang_opencl30)
777+ .Cases("clc++", "CLC++", LangStandard::lang_openclcpp)
778+ .Default(LangStandard::lang_unspecified);
779
780 if (OpenCLLangStd == LangStandard::lang_unspecified) {
781 Diags.Report(diag::err_drv_invalid_value)
782@@ -2852,8 +2855,7 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
783
784 Opts.RTTI = Opts.CPlusPlus && !Args.hasArg(OPT_fno_rtti);
785 Opts.RTTIData = Opts.RTTI && !Args.hasArg(OPT_fno_rtti_data);
786- Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
787- && Opts.OpenCLVersion == 200);
788+ Opts.Blocks = Args.hasArg(OPT_fblocks);
789 Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
790 Opts.Coroutines = Opts.CPlusPlus20 || Args.hasArg(OPT_fcoroutines_ts);
791
792diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp
793index 6eef1e2376f6..5bb489c11909 100644
794--- a/clang/lib/Frontend/InitPreprocessor.cpp
795+++ b/clang/lib/Frontend/InitPreprocessor.cpp
796@@ -445,6 +445,9 @@ static void InitializeStandardPredefinedMacros(const TargetInfo &TI,
797 case 200:
798 Builder.defineMacro("__OPENCL_C_VERSION__", "200");
799 break;
800+ case 300:
801+ Builder.defineMacro("__OPENCL_C_VERSION__", "300");
802+ break;
803 default:
804 llvm_unreachable("Unsupported OpenCL version");
805 }
806@@ -453,6 +456,7 @@ static void InitializeStandardPredefinedMacros(const TargetInfo &TI,
807 Builder.defineMacro("CL_VERSION_1_1", "110");
808 Builder.defineMacro("CL_VERSION_1_2", "120");
809 Builder.defineMacro("CL_VERSION_2_0", "200");
810+ Builder.defineMacro("CL_VERSION_3_0", "300");
811
812 if (TI.isLittleEndian())
813 Builder.defineMacro("__ENDIAN_LITTLE__");
814@@ -1108,7 +1112,7 @@ static void InitializePredefinedMacros(const TargetInfo &TI,
815 // OpenCL definitions.
816 if (LangOpts.OpenCL) {
817 #define OPENCLEXT(Ext) \
818- if (TI.getSupportedOpenCLOpts().isSupported(#Ext, LangOpts)) \
819+ if (TI.getSupportedOpenCLOpts().isSupported(#Ext)) \
820 Builder.defineMacro(#Ext);
821 #include "clang/Basic/OpenCLExtensions.def"
822
823diff --git a/clang/lib/Headers/opencl-c-base.h b/clang/lib/Headers/opencl-c-base.h
824index 430e07d36f62..afa900ab24d9 100644
825--- a/clang/lib/Headers/opencl-c-base.h
826+++ b/clang/lib/Headers/opencl-c-base.h
827@@ -9,6 +9,59 @@
828 #ifndef _OPENCL_BASE_H_
829 #define _OPENCL_BASE_H_
830
831+// Add predefined macros to build headers with standalone executable
832+#ifndef CL_VERSION_3_0
833+ #define CL_VERSION_3_0 300
834+#endif
835+
836+// Define features for 2.0 for header backward compatibility
837+#ifndef __opencl_c_int64
838+ #define __opencl_c_int64 1
839+#endif
840+#if __OPENCL_C_VERSION__ != CL_VERSION_3_0
841+ #ifndef __opencl_c_images
842+ #define __opencl_c_images 1
843+ #endif
844+#endif
845+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ == CL_VERSION_2_0)
846+#ifndef __opencl_c_pipes
847+ #define __opencl_c_pipes 1
848+#endif
849+#ifndef __opencl_c_generic_address_space
850+ #define __opencl_c_generic_address_space 1
851+#endif
852+#ifndef __opencl_c_work_group_collective_functions
853+ #define __opencl_c_work_group_collective_functions 1
854+#endif
855+#ifndef __opencl_c_atomic_order_acq_rel
856+ #define __opencl_c_atomic_order_acq_rel 1
857+#endif
858+#ifndef __opencl_c_atomic_order_seq_cst
859+ #define __opencl_c_atomic_order_seq_cst 1
860+#endif
861+#ifndef __opencl_c_atomic_scope_device
862+ #define __opencl_c_atomic_scope_device 1
863+#endif
864+#ifndef __opencl_c_atomic_scope_all_devices
865+ #define __opencl_c_atomic_scope_all_devices 1
866+#endif
867+#ifndef __opencl_c_subgroups
868+ #define __opencl_c_subgroups 1
869+#endif
870+#ifndef __opencl_c_3d_image_writes
871+ #define __opencl_c_3d_image_writes 1
872+#endif
873+#ifndef __opencl_c_device_enqueue
874+ #define __opencl_c_device_enqueue 1
875+#endif
876+#ifndef __opencl_c_read_write_images
877+ #define __opencl_c_read_write_images 1
878+#endif
879+#ifndef __opencl_c_program_scope_global_variables
880+ #define __opencl_c_program_scope_global_variables 1
881+#endif
882+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ == CL_VERSION_2_0)
883+
884 // built-in scalar data types:
885
886 /**
887@@ -115,7 +168,12 @@ typedef half half4 __attribute__((ext_vector_type(4)));
888 typedef half half8 __attribute__((ext_vector_type(8)));
889 typedef half half16 __attribute__((ext_vector_type(16)));
890 #endif
891-#ifdef cl_khr_fp64
892+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
893+
894+#ifndef __opencl_c_fp64
895+ #define __opencl_c_fp64 1
896+#endif
897+
898 #if __OPENCL_C_VERSION__ < CL_VERSION_1_2
899 #pragma OPENCL EXTENSION cl_khr_fp64 : enable
900 #endif
901@@ -281,9 +339,17 @@ typedef uint cl_mem_fence_flags;
902 typedef enum memory_scope {
903 memory_scope_work_item = __OPENCL_MEMORY_SCOPE_WORK_ITEM,
904 memory_scope_work_group = __OPENCL_MEMORY_SCOPE_WORK_GROUP,
905+#ifdef __opencl_c_atomic_scope_device
906 memory_scope_device = __OPENCL_MEMORY_SCOPE_DEVICE,
907+#endif
908+#ifdef __opencl_c_atomic_scope_all_devices
909+ #if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
910+ memory_scope_all_devices = __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES,
911+ #endif //(__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
912 memory_scope_all_svm_devices = __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES,
913-#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups)
914+#endif // __opencl_c_atomic_scope_all_devices
915+#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups) || \
916+ defined(__opencl_c_subgroups)
917 memory_scope_sub_group = __OPENCL_MEMORY_SCOPE_SUB_GROUP
918 #endif
919 } memory_scope;
920@@ -301,13 +367,14 @@ typedef enum memory_scope {
921 #define ATOMIC_FLAG_INIT 0
922
923 // enum values aligned with what clang uses in EmitAtomicExpr()
924-typedef enum memory_order
925-{
926+typedef enum memory_order {
927 memory_order_relaxed = __ATOMIC_RELAXED,
928 memory_order_acquire = __ATOMIC_ACQUIRE,
929 memory_order_release = __ATOMIC_RELEASE,
930 memory_order_acq_rel = __ATOMIC_ACQ_REL,
931+#ifdef __opencl_c_atomic_order_seq_cst
932 memory_order_seq_cst = __ATOMIC_SEQ_CST
933+#endif //__opencl_c_atomic_order_seq_cst
934 } memory_order;
935
936 #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
937diff --git a/clang/lib/Headers/opencl-c.h b/clang/lib/Headers/opencl-c.h
938index 66e18bdd47bb..67d900eb1c3d 100644
939--- a/clang/lib/Headers/opencl-c.h
940+++ b/clang/lib/Headers/opencl-c.h
941@@ -35,7 +35,6 @@
942 #define __purefn __attribute__((pure))
943 #define __cnfn __attribute__((const))
944
945-
946 // OpenCL v1.1/1.2/2.0 s6.2.3 - Explicit conversions
947
948 char __ovld __cnfn convert_char_rte(char);
949@@ -4632,7 +4631,7 @@ float16 __ovld __cnfn convert_float16(float16);
950
951 // Conversions with double data type parameters or return value.
952
953-#ifdef cl_khr_fp64
954+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
955 char __ovld __cnfn convert_char(double);
956 char __ovld __cnfn convert_char_rte(double);
957 char __ovld __cnfn convert_char_rtn(double);
958@@ -5452,7 +5451,7 @@ double16 __ovld __cnfn convert_double16_rtz(uchar16);
959 double16 __ovld __cnfn convert_double16_rtz(uint16);
960 double16 __ovld __cnfn convert_double16_rtz(ulong16);
961 double16 __ovld __cnfn convert_double16_rtz(ushort16);
962-#endif //cl_khr_fp64
963+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
964
965 #ifdef cl_khr_fp16
966 // Convert half types to non-double types.
967@@ -6270,7 +6269,7 @@ half16 __ovld __cnfn convert_half16_rtz(float16);
968 half16 __ovld __cnfn convert_half16_rtz(half16);
969
970 // Convert half types to double types.
971-#ifdef cl_khr_fp64
972+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
973 double __ovld __cnfn convert_double(half);
974 double __ovld __cnfn convert_double_rte(half);
975 double __ovld __cnfn convert_double_rtp(half);
976@@ -6333,7 +6332,7 @@ half16 __ovld __cnfn convert_half16_rte(double16);
977 half16 __ovld __cnfn convert_half16_rtp(double16);
978 half16 __ovld __cnfn convert_half16_rtn(double16);
979 half16 __ovld __cnfn convert_half16_rtz(double16);
980-#endif //cl_khr_fp64
981+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
982
983 #endif // cl_khr_fp16
984
985@@ -6404,14 +6403,14 @@ half16 __ovld __cnfn convert_half16_rtz(double16);
986 #define as_float8(x) __builtin_astype((x), float8)
987 #define as_float16(x) __builtin_astype((x), float16)
988
989-#ifdef cl_khr_fp64
990+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
991 #define as_double(x) __builtin_astype((x), double)
992 #define as_double2(x) __builtin_astype((x), double2)
993 #define as_double3(x) __builtin_astype((x), double3)
994 #define as_double4(x) __builtin_astype((x), double4)
995 #define as_double8(x) __builtin_astype((x), double8)
996 #define as_double16(x) __builtin_astype((x), double16)
997-#endif //cl_khr_fp64
998+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
999
1000 #ifdef cl_khr_fp16
1001 #define as_half(x) __builtin_astype((x), half)
1002@@ -6534,14 +6533,14 @@ float3 __ovld __cnfn acos(float3);
1003 float4 __ovld __cnfn acos(float4);
1004 float8 __ovld __cnfn acos(float8);
1005 float16 __ovld __cnfn acos(float16);
1006-#ifdef cl_khr_fp64
1007+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1008 double __ovld __cnfn acos(double);
1009 double2 __ovld __cnfn acos(double2);
1010 double3 __ovld __cnfn acos(double3);
1011 double4 __ovld __cnfn acos(double4);
1012 double8 __ovld __cnfn acos(double8);
1013 double16 __ovld __cnfn acos(double16);
1014-#endif //cl_khr_fp64
1015+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1016 #ifdef cl_khr_fp16
1017 half __ovld __cnfn acos(half);
1018 half2 __ovld __cnfn acos(half2);
1019@@ -6560,14 +6559,14 @@ float3 __ovld __cnfn acosh(float3);
1020 float4 __ovld __cnfn acosh(float4);
1021 float8 __ovld __cnfn acosh(float8);
1022 float16 __ovld __cnfn acosh(float16);
1023-#ifdef cl_khr_fp64
1024+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1025 double __ovld __cnfn acosh(double);
1026 double2 __ovld __cnfn acosh(double2);
1027 double3 __ovld __cnfn acosh(double3);
1028 double4 __ovld __cnfn acosh(double4);
1029 double8 __ovld __cnfn acosh(double8);
1030 double16 __ovld __cnfn acosh(double16);
1031-#endif //cl_khr_fp64
1032+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1033 #ifdef cl_khr_fp16
1034 half __ovld __cnfn acosh(half);
1035 half2 __ovld __cnfn acosh(half2);
1036@@ -6586,14 +6585,14 @@ float3 __ovld __cnfn acospi(float3 x);
1037 float4 __ovld __cnfn acospi(float4 x);
1038 float8 __ovld __cnfn acospi(float8 x);
1039 float16 __ovld __cnfn acospi(float16 x);
1040-#ifdef cl_khr_fp64
1041+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1042 double __ovld __cnfn acospi(double x);
1043 double2 __ovld __cnfn acospi(double2 x);
1044 double3 __ovld __cnfn acospi(double3 x);
1045 double4 __ovld __cnfn acospi(double4 x);
1046 double8 __ovld __cnfn acospi(double8 x);
1047 double16 __ovld __cnfn acospi(double16 x);
1048-#endif //cl_khr_fp64
1049+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1050 #ifdef cl_khr_fp16
1051 half __ovld __cnfn acospi(half x);
1052 half2 __ovld __cnfn acospi(half2 x);
1053@@ -6612,14 +6611,14 @@ float3 __ovld __cnfn asin(float3);
1054 float4 __ovld __cnfn asin(float4);
1055 float8 __ovld __cnfn asin(float8);
1056 float16 __ovld __cnfn asin(float16);
1057-#ifdef cl_khr_fp64
1058+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1059 double __ovld __cnfn asin(double);
1060 double2 __ovld __cnfn asin(double2);
1061 double3 __ovld __cnfn asin(double3);
1062 double4 __ovld __cnfn asin(double4);
1063 double8 __ovld __cnfn asin(double8);
1064 double16 __ovld __cnfn asin(double16);
1065-#endif //cl_khr_fp64
1066+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1067 #ifdef cl_khr_fp16
1068 half __ovld __cnfn asin(half);
1069 half2 __ovld __cnfn asin(half2);
1070@@ -6638,14 +6637,14 @@ float3 __ovld __cnfn asinh(float3);
1071 float4 __ovld __cnfn asinh(float4);
1072 float8 __ovld __cnfn asinh(float8);
1073 float16 __ovld __cnfn asinh(float16);
1074-#ifdef cl_khr_fp64
1075+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1076 double __ovld __cnfn asinh(double);
1077 double2 __ovld __cnfn asinh(double2);
1078 double3 __ovld __cnfn asinh(double3);
1079 double4 __ovld __cnfn asinh(double4);
1080 double8 __ovld __cnfn asinh(double8);
1081 double16 __ovld __cnfn asinh(double16);
1082-#endif //cl_khr_fp64
1083+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1084 #ifdef cl_khr_fp16
1085 half __ovld __cnfn asinh(half);
1086 half2 __ovld __cnfn asinh(half2);
1087@@ -6664,14 +6663,14 @@ float3 __ovld __cnfn asinpi(float3 x);
1088 float4 __ovld __cnfn asinpi(float4 x);
1089 float8 __ovld __cnfn asinpi(float8 x);
1090 float16 __ovld __cnfn asinpi(float16 x);
1091-#ifdef cl_khr_fp64
1092+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1093 double __ovld __cnfn asinpi(double x);
1094 double2 __ovld __cnfn asinpi(double2 x);
1095 double3 __ovld __cnfn asinpi(double3 x);
1096 double4 __ovld __cnfn asinpi(double4 x);
1097 double8 __ovld __cnfn asinpi(double8 x);
1098 double16 __ovld __cnfn asinpi(double16 x);
1099-#endif //cl_khr_fp64
1100+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1101 #ifdef cl_khr_fp16
1102 half __ovld __cnfn asinpi(half x);
1103 half2 __ovld __cnfn asinpi(half2 x);
1104@@ -6690,14 +6689,14 @@ float3 __ovld __cnfn atan(float3 y_over_x);
1105 float4 __ovld __cnfn atan(float4 y_over_x);
1106 float8 __ovld __cnfn atan(float8 y_over_x);
1107 float16 __ovld __cnfn atan(float16 y_over_x);
1108-#ifdef cl_khr_fp64
1109+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1110 double __ovld __cnfn atan(double y_over_x);
1111 double2 __ovld __cnfn atan(double2 y_over_x);
1112 double3 __ovld __cnfn atan(double3 y_over_x);
1113 double4 __ovld __cnfn atan(double4 y_over_x);
1114 double8 __ovld __cnfn atan(double8 y_over_x);
1115 double16 __ovld __cnfn atan(double16 y_over_x);
1116-#endif //cl_khr_fp64
1117+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1118 #ifdef cl_khr_fp16
1119 half __ovld __cnfn atan(half y_over_x);
1120 half2 __ovld __cnfn atan(half2 y_over_x);
1121@@ -6716,14 +6715,14 @@ float3 __ovld __cnfn atan2(float3 y, float3 x);
1122 float4 __ovld __cnfn atan2(float4 y, float4 x);
1123 float8 __ovld __cnfn atan2(float8 y, float8 x);
1124 float16 __ovld __cnfn atan2(float16 y, float16 x);
1125-#ifdef cl_khr_fp64
1126+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1127 double __ovld __cnfn atan2(double y, double x);
1128 double2 __ovld __cnfn atan2(double2 y, double2 x);
1129 double3 __ovld __cnfn atan2(double3 y, double3 x);
1130 double4 __ovld __cnfn atan2(double4 y, double4 x);
1131 double8 __ovld __cnfn atan2(double8 y, double8 x);
1132 double16 __ovld __cnfn atan2(double16 y, double16 x);
1133-#endif //cl_khr_fp64
1134+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1135 #ifdef cl_khr_fp16
1136 half __ovld __cnfn atan2(half y, half x);
1137 half2 __ovld __cnfn atan2(half2 y, half2 x);
1138@@ -6742,14 +6741,14 @@ float3 __ovld __cnfn atanh(float3);
1139 float4 __ovld __cnfn atanh(float4);
1140 float8 __ovld __cnfn atanh(float8);
1141 float16 __ovld __cnfn atanh(float16);
1142-#ifdef cl_khr_fp64
1143+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1144 double __ovld __cnfn atanh(double);
1145 double2 __ovld __cnfn atanh(double2);
1146 double3 __ovld __cnfn atanh(double3);
1147 double4 __ovld __cnfn atanh(double4);
1148 double8 __ovld __cnfn atanh(double8);
1149 double16 __ovld __cnfn atanh(double16);
1150-#endif //cl_khr_fp64
1151+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1152 #ifdef cl_khr_fp16
1153 half __ovld __cnfn atanh(half);
1154 half2 __ovld __cnfn atanh(half2);
1155@@ -6768,14 +6767,14 @@ float3 __ovld __cnfn atanpi(float3 x);
1156 float4 __ovld __cnfn atanpi(float4 x);
1157 float8 __ovld __cnfn atanpi(float8 x);
1158 float16 __ovld __cnfn atanpi(float16 x);
1159-#ifdef cl_khr_fp64
1160+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1161 double __ovld __cnfn atanpi(double x);
1162 double2 __ovld __cnfn atanpi(double2 x);
1163 double3 __ovld __cnfn atanpi(double3 x);
1164 double4 __ovld __cnfn atanpi(double4 x);
1165 double8 __ovld __cnfn atanpi(double8 x);
1166 double16 __ovld __cnfn atanpi(double16 x);
1167-#endif //cl_khr_fp64
1168+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1169 #ifdef cl_khr_fp16
1170 half __ovld __cnfn atanpi(half x);
1171 half2 __ovld __cnfn atanpi(half2 x);
1172@@ -6794,14 +6793,14 @@ float3 __ovld __cnfn atan2pi(float3 y, float3 x);
1173 float4 __ovld __cnfn atan2pi(float4 y, float4 x);
1174 float8 __ovld __cnfn atan2pi(float8 y, float8 x);
1175 float16 __ovld __cnfn atan2pi(float16 y, float16 x);
1176-#ifdef cl_khr_fp64
1177+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1178 double __ovld __cnfn atan2pi(double y, double x);
1179 double2 __ovld __cnfn atan2pi(double2 y, double2 x);
1180 double3 __ovld __cnfn atan2pi(double3 y, double3 x);
1181 double4 __ovld __cnfn atan2pi(double4 y, double4 x);
1182 double8 __ovld __cnfn atan2pi(double8 y, double8 x);
1183 double16 __ovld __cnfn atan2pi(double16 y, double16 x);
1184-#endif //cl_khr_fp64
1185+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1186 #ifdef cl_khr_fp16
1187 half __ovld __cnfn atan2pi(half y, half x);
1188 half2 __ovld __cnfn atan2pi(half2 y, half2 x);
1189@@ -6820,14 +6819,14 @@ float3 __ovld __cnfn cbrt(float3);
1190 float4 __ovld __cnfn cbrt(float4);
1191 float8 __ovld __cnfn cbrt(float8);
1192 float16 __ovld __cnfn cbrt(float16);
1193-#ifdef cl_khr_fp64
1194+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1195 double __ovld __cnfn cbrt(double);
1196 double2 __ovld __cnfn cbrt(double2);
1197 double3 __ovld __cnfn cbrt(double3);
1198 double4 __ovld __cnfn cbrt(double4);
1199 double8 __ovld __cnfn cbrt(double8);
1200 double16 __ovld __cnfn cbrt(double16);
1201-#endif //cl_khr_fp64
1202+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1203 #ifdef cl_khr_fp16
1204 half __ovld __cnfn cbrt(half);
1205 half2 __ovld __cnfn cbrt(half2);
1206@@ -6847,14 +6846,14 @@ float3 __ovld __cnfn ceil(float3);
1207 float4 __ovld __cnfn ceil(float4);
1208 float8 __ovld __cnfn ceil(float8);
1209 float16 __ovld __cnfn ceil(float16);
1210-#ifdef cl_khr_fp64
1211+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1212 double __ovld __cnfn ceil(double);
1213 double2 __ovld __cnfn ceil(double2);
1214 double3 __ovld __cnfn ceil(double3);
1215 double4 __ovld __cnfn ceil(double4);
1216 double8 __ovld __cnfn ceil(double8);
1217 double16 __ovld __cnfn ceil(double16);
1218-#endif //cl_khr_fp64
1219+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1220 #ifdef cl_khr_fp16
1221 half __ovld __cnfn ceil(half);
1222 half2 __ovld __cnfn ceil(half2);
1223@@ -6873,14 +6872,14 @@ float3 __ovld __cnfn copysign(float3 x, float3 y);
1224 float4 __ovld __cnfn copysign(float4 x, float4 y);
1225 float8 __ovld __cnfn copysign(float8 x, float8 y);
1226 float16 __ovld __cnfn copysign(float16 x, float16 y);
1227-#ifdef cl_khr_fp64
1228+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1229 double __ovld __cnfn copysign(double x, double y);
1230 double2 __ovld __cnfn copysign(double2 x, double2 y);
1231 double3 __ovld __cnfn copysign(double3 x, double3 y);
1232 double4 __ovld __cnfn copysign(double4 x, double4 y);
1233 double8 __ovld __cnfn copysign(double8 x, double8 y);
1234 double16 __ovld __cnfn copysign(double16 x, double16 y);
1235-#endif //cl_khr_fp64
1236+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1237 #ifdef cl_khr_fp16
1238 half __ovld __cnfn copysign(half x, half y);
1239 half2 __ovld __cnfn copysign(half2 x, half2 y);
1240@@ -6899,14 +6898,14 @@ float3 __ovld __cnfn cos(float3);
1241 float4 __ovld __cnfn cos(float4);
1242 float8 __ovld __cnfn cos(float8);
1243 float16 __ovld __cnfn cos(float16);
1244-#ifdef cl_khr_fp64
1245+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1246 double __ovld __cnfn cos(double);
1247 double2 __ovld __cnfn cos(double2);
1248 double3 __ovld __cnfn cos(double3);
1249 double4 __ovld __cnfn cos(double4);
1250 double8 __ovld __cnfn cos(double8);
1251 double16 __ovld __cnfn cos(double16);
1252-#endif //cl_khr_fp64
1253+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1254 #ifdef cl_khr_fp16
1255 half __ovld __cnfn cos(half);
1256 half2 __ovld __cnfn cos(half2);
1257@@ -6925,14 +6924,14 @@ float3 __ovld __cnfn cosh(float3);
1258 float4 __ovld __cnfn cosh(float4);
1259 float8 __ovld __cnfn cosh(float8);
1260 float16 __ovld __cnfn cosh(float16);
1261-#ifdef cl_khr_fp64
1262+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1263 double __ovld __cnfn cosh(double);
1264 double2 __ovld __cnfn cosh(double2);
1265 double3 __ovld __cnfn cosh(double3);
1266 double4 __ovld __cnfn cosh(double4);
1267 double8 __ovld __cnfn cosh(double8);
1268 double16 __ovld __cnfn cosh(double16);
1269-#endif //cl_khr_fp64
1270+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1271 #ifdef cl_khr_fp16
1272 half __ovld __cnfn cosh(half);
1273 half2 __ovld __cnfn cosh(half2);
1274@@ -6951,14 +6950,14 @@ float3 __ovld __cnfn cospi(float3 x);
1275 float4 __ovld __cnfn cospi(float4 x);
1276 float8 __ovld __cnfn cospi(float8 x);
1277 float16 __ovld __cnfn cospi(float16 x);
1278-#ifdef cl_khr_fp64
1279+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1280 double __ovld __cnfn cospi(double x);
1281 double2 __ovld __cnfn cospi(double2 x);
1282 double3 __ovld __cnfn cospi(double3 x);
1283 double4 __ovld __cnfn cospi(double4 x);
1284 double8 __ovld __cnfn cospi(double8 x);
1285 double16 __ovld __cnfn cospi(double16 x);
1286-#endif //cl_khr_fp64
1287+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1288 #ifdef cl_khr_fp16
1289 half __ovld __cnfn cospi(half x);
1290 half2 __ovld __cnfn cospi(half2 x);
1291@@ -6977,14 +6976,14 @@ float3 __ovld __cnfn erfc(float3);
1292 float4 __ovld __cnfn erfc(float4);
1293 float8 __ovld __cnfn erfc(float8);
1294 float16 __ovld __cnfn erfc(float16);
1295-#ifdef cl_khr_fp64
1296+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1297 double __ovld __cnfn erfc(double);
1298 double2 __ovld __cnfn erfc(double2);
1299 double3 __ovld __cnfn erfc(double3);
1300 double4 __ovld __cnfn erfc(double4);
1301 double8 __ovld __cnfn erfc(double8);
1302 double16 __ovld __cnfn erfc(double16);
1303-#endif //cl_khr_fp64
1304+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1305 #ifdef cl_khr_fp16
1306 half __ovld __cnfn erfc(half);
1307 half2 __ovld __cnfn erfc(half2);
1308@@ -7004,14 +7003,14 @@ float3 __ovld __cnfn erf(float3);
1309 float4 __ovld __cnfn erf(float4);
1310 float8 __ovld __cnfn erf(float8);
1311 float16 __ovld __cnfn erf(float16);
1312-#ifdef cl_khr_fp64
1313+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1314 double __ovld __cnfn erf(double);
1315 double2 __ovld __cnfn erf(double2);
1316 double3 __ovld __cnfn erf(double3);
1317 double4 __ovld __cnfn erf(double4);
1318 double8 __ovld __cnfn erf(double8);
1319 double16 __ovld __cnfn erf(double16);
1320-#endif //cl_khr_fp64
1321+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1322 #ifdef cl_khr_fp16
1323 half __ovld __cnfn erf(half);
1324 half2 __ovld __cnfn erf(half2);
1325@@ -7030,14 +7029,14 @@ float3 __ovld __cnfn exp(float3 x);
1326 float4 __ovld __cnfn exp(float4 x);
1327 float8 __ovld __cnfn exp(float8 x);
1328 float16 __ovld __cnfn exp(float16 x);
1329-#ifdef cl_khr_fp64
1330+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1331 double __ovld __cnfn exp(double x);
1332 double2 __ovld __cnfn exp(double2 x);
1333 double3 __ovld __cnfn exp(double3 x);
1334 double4 __ovld __cnfn exp(double4 x);
1335 double8 __ovld __cnfn exp(double8 x);
1336 double16 __ovld __cnfn exp(double16 x);
1337-#endif //cl_khr_fp64
1338+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1339 #ifdef cl_khr_fp16
1340 half __ovld __cnfn exp(half x);
1341 half2 __ovld __cnfn exp(half2 x);
1342@@ -7056,14 +7055,14 @@ float3 __ovld __cnfn exp2(float3);
1343 float4 __ovld __cnfn exp2(float4);
1344 float8 __ovld __cnfn exp2(float8);
1345 float16 __ovld __cnfn exp2(float16);
1346-#ifdef cl_khr_fp64
1347+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1348 double __ovld __cnfn exp2(double);
1349 double2 __ovld __cnfn exp2(double2);
1350 double3 __ovld __cnfn exp2(double3);
1351 double4 __ovld __cnfn exp2(double4);
1352 double8 __ovld __cnfn exp2(double8);
1353 double16 __ovld __cnfn exp2(double16);
1354-#endif //cl_khr_fp64
1355+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1356 #ifdef cl_khr_fp16
1357 half __ovld __cnfn exp2(half);
1358 half2 __ovld __cnfn exp2(half2);
1359@@ -7082,14 +7081,14 @@ float3 __ovld __cnfn exp10(float3);
1360 float4 __ovld __cnfn exp10(float4);
1361 float8 __ovld __cnfn exp10(float8);
1362 float16 __ovld __cnfn exp10(float16);
1363-#ifdef cl_khr_fp64
1364+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1365 double __ovld __cnfn exp10(double);
1366 double2 __ovld __cnfn exp10(double2);
1367 double3 __ovld __cnfn exp10(double3);
1368 double4 __ovld __cnfn exp10(double4);
1369 double8 __ovld __cnfn exp10(double8);
1370 double16 __ovld __cnfn exp10(double16);
1371-#endif //cl_khr_fp64
1372+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1373 #ifdef cl_khr_fp16
1374 half __ovld __cnfn exp10(half);
1375 half2 __ovld __cnfn exp10(half2);
1376@@ -7108,14 +7107,14 @@ float3 __ovld __cnfn expm1(float3 x);
1377 float4 __ovld __cnfn expm1(float4 x);
1378 float8 __ovld __cnfn expm1(float8 x);
1379 float16 __ovld __cnfn expm1(float16 x);
1380-#ifdef cl_khr_fp64
1381+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1382 double __ovld __cnfn expm1(double x);
1383 double2 __ovld __cnfn expm1(double2 x);
1384 double3 __ovld __cnfn expm1(double3 x);
1385 double4 __ovld __cnfn expm1(double4 x);
1386 double8 __ovld __cnfn expm1(double8 x);
1387 double16 __ovld __cnfn expm1(double16 x);
1388-#endif //cl_khr_fp64
1389+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1390 #ifdef cl_khr_fp16
1391 half __ovld __cnfn expm1(half x);
1392 half2 __ovld __cnfn expm1(half2 x);
1393@@ -7134,14 +7133,14 @@ float3 __ovld __cnfn fabs(float3);
1394 float4 __ovld __cnfn fabs(float4);
1395 float8 __ovld __cnfn fabs(float8);
1396 float16 __ovld __cnfn fabs(float16);
1397-#ifdef cl_khr_fp64
1398+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1399 double __ovld __cnfn fabs(double);
1400 double2 __ovld __cnfn fabs(double2);
1401 double3 __ovld __cnfn fabs(double3);
1402 double4 __ovld __cnfn fabs(double4);
1403 double8 __ovld __cnfn fabs(double8);
1404 double16 __ovld __cnfn fabs(double16);
1405-#endif //cl_khr_fp64
1406+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1407 #ifdef cl_khr_fp16
1408 half __ovld __cnfn fabs(half);
1409 half2 __ovld __cnfn fabs(half2);
1410@@ -7160,14 +7159,14 @@ float3 __ovld __cnfn fdim(float3 x, float3 y);
1411 float4 __ovld __cnfn fdim(float4 x, float4 y);
1412 float8 __ovld __cnfn fdim(float8 x, float8 y);
1413 float16 __ovld __cnfn fdim(float16 x, float16 y);
1414-#ifdef cl_khr_fp64
1415+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1416 double __ovld __cnfn fdim(double x, double y);
1417 double2 __ovld __cnfn fdim(double2 x, double2 y);
1418 double3 __ovld __cnfn fdim(double3 x, double3 y);
1419 double4 __ovld __cnfn fdim(double4 x, double4 y);
1420 double8 __ovld __cnfn fdim(double8 x, double8 y);
1421 double16 __ovld __cnfn fdim(double16 x, double16 y);
1422-#endif //cl_khr_fp64
1423+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1424 #ifdef cl_khr_fp16
1425 half __ovld __cnfn fdim(half x, half y);
1426 half2 __ovld __cnfn fdim(half2 x, half2 y);
1427@@ -7187,14 +7186,14 @@ float3 __ovld __cnfn floor(float3);
1428 float4 __ovld __cnfn floor(float4);
1429 float8 __ovld __cnfn floor(float8);
1430 float16 __ovld __cnfn floor(float16);
1431-#ifdef cl_khr_fp64
1432+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1433 double __ovld __cnfn floor(double);
1434 double2 __ovld __cnfn floor(double2);
1435 double3 __ovld __cnfn floor(double3);
1436 double4 __ovld __cnfn floor(double4);
1437 double8 __ovld __cnfn floor(double8);
1438 double16 __ovld __cnfn floor(double16);
1439-#endif //cl_khr_fp64
1440+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1441 #ifdef cl_khr_fp16
1442 half __ovld __cnfn floor(half);
1443 half2 __ovld __cnfn floor(half2);
1444@@ -7217,14 +7216,14 @@ float3 __ovld __cnfn fma(float3 a, float3 b, float3 c);
1445 float4 __ovld __cnfn fma(float4 a, float4 b, float4 c);
1446 float8 __ovld __cnfn fma(float8 a, float8 b, float8 c);
1447 float16 __ovld __cnfn fma(float16 a, float16 b, float16 c);
1448-#ifdef cl_khr_fp64
1449+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1450 double __ovld __cnfn fma(double a, double b, double c);
1451 double2 __ovld __cnfn fma(double2 a, double2 b, double2 c);
1452 double3 __ovld __cnfn fma(double3 a, double3 b, double3 c);
1453 double4 __ovld __cnfn fma(double4 a, double4 b, double4 c);
1454 double8 __ovld __cnfn fma(double8 a, double8 b, double8 c);
1455 double16 __ovld __cnfn fma(double16 a, double16 b, double16 c);
1456-#endif //cl_khr_fp64
1457+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1458 #ifdef cl_khr_fp16
1459 half __ovld __cnfn fma(half a, half b, half c);
1460 half2 __ovld __cnfn fma(half2 a, half2 b, half2 c);
1461@@ -7251,7 +7250,7 @@ float3 __ovld __cnfn fmax(float3 x, float y);
1462 float4 __ovld __cnfn fmax(float4 x, float y);
1463 float8 __ovld __cnfn fmax(float8 x, float y);
1464 float16 __ovld __cnfn fmax(float16 x, float y);
1465-#ifdef cl_khr_fp64
1466+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1467 double __ovld __cnfn fmax(double x, double y);
1468 double2 __ovld __cnfn fmax(double2 x, double2 y);
1469 double3 __ovld __cnfn fmax(double3 x, double3 y);
1470@@ -7263,7 +7262,7 @@ double3 __ovld __cnfn fmax(double3 x, double y);
1471 double4 __ovld __cnfn fmax(double4 x, double y);
1472 double8 __ovld __cnfn fmax(double8 x, double y);
1473 double16 __ovld __cnfn fmax(double16 x, double y);
1474-#endif //cl_khr_fp64
1475+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1476 #ifdef cl_khr_fp16
1477 half __ovld __cnfn fmax(half x, half y);
1478 half2 __ovld __cnfn fmax(half2 x, half2 y);
1479@@ -7295,7 +7294,7 @@ float3 __ovld __cnfn fmin(float3 x, float y);
1480 float4 __ovld __cnfn fmin(float4 x, float y);
1481 float8 __ovld __cnfn fmin(float8 x, float y);
1482 float16 __ovld __cnfn fmin(float16 x, float y);
1483-#ifdef cl_khr_fp64
1484+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1485 double __ovld __cnfn fmin(double x, double y);
1486 double2 __ovld __cnfn fmin(double2 x, double2 y);
1487 double3 __ovld __cnfn fmin(double3 x, double3 y);
1488@@ -7307,7 +7306,7 @@ double3 __ovld __cnfn fmin(double3 x, double y);
1489 double4 __ovld __cnfn fmin(double4 x, double y);
1490 double8 __ovld __cnfn fmin(double8 x, double y);
1491 double16 __ovld __cnfn fmin(double16 x, double y);
1492-#endif //cl_khr_fp64
1493+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1494 #ifdef cl_khr_fp16
1495 half __ovld __cnfn fmin(half x, half y);
1496 half2 __ovld __cnfn fmin(half2 x, half2 y);
1497@@ -7331,14 +7330,14 @@ float3 __ovld __cnfn fmod(float3 x, float3 y);
1498 float4 __ovld __cnfn fmod(float4 x, float4 y);
1499 float8 __ovld __cnfn fmod(float8 x, float8 y);
1500 float16 __ovld __cnfn fmod(float16 x, float16 y);
1501-#ifdef cl_khr_fp64
1502+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1503 double __ovld __cnfn fmod(double x, double y);
1504 double2 __ovld __cnfn fmod(double2 x, double2 y);
1505 double3 __ovld __cnfn fmod(double3 x, double3 y);
1506 double4 __ovld __cnfn fmod(double4 x, double4 y);
1507 double8 __ovld __cnfn fmod(double8 x, double8 y);
1508 double16 __ovld __cnfn fmod(double16 x, double16 y);
1509-#endif //cl_khr_fp64
1510+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1511 #ifdef cl_khr_fp16
1512 half __ovld __cnfn fmod(half x, half y);
1513 half2 __ovld __cnfn fmod(half2 x, half2 y);
1514@@ -7352,21 +7351,21 @@ half16 __ovld __cnfn fmod(half16 x, half16 y);
1515 * Returns fmin(x - floor (x), 0x1.fffffep-1f ).
1516 * floor(x) is returned in iptr.
1517 */
1518-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
1519+#ifdef __opencl_c_generic_address_space
1520 float __ovld fract(float x, float *iptr);
1521 float2 __ovld fract(float2 x, float2 *iptr);
1522 float3 __ovld fract(float3 x, float3 *iptr);
1523 float4 __ovld fract(float4 x, float4 *iptr);
1524 float8 __ovld fract(float8 x, float8 *iptr);
1525 float16 __ovld fract(float16 x, float16 *iptr);
1526-#ifdef cl_khr_fp64
1527+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1528 double __ovld fract(double x, double *iptr);
1529 double2 __ovld fract(double2 x, double2 *iptr);
1530 double3 __ovld fract(double3 x, double3 *iptr);
1531 double4 __ovld fract(double4 x, double4 *iptr);
1532 double8 __ovld fract(double8 x, double8 *iptr);
1533 double16 __ovld fract(double16 x, double16 *iptr);
1534-#endif //cl_khr_fp64
1535+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1536 #ifdef cl_khr_fp16
1537 half __ovld fract(half x, half *iptr);
1538 half2 __ovld fract(half2 x, half2 *iptr);
1539@@ -7375,7 +7374,9 @@ half4 __ovld fract(half4 x, half4 *iptr);
1540 half8 __ovld fract(half8 x, half8 *iptr);
1541 half16 __ovld fract(half16 x, half16 *iptr);
1542 #endif //cl_khr_fp16
1543-#else
1544+#endif //__opencl_c_generic_address_space
1545+
1546+#if !defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ != CL_VERSION_2_0)
1547 float __ovld fract(float x, __global float *iptr);
1548 float2 __ovld fract(float2 x, __global float2 *iptr);
1549 float3 __ovld fract(float3 x, __global float3 *iptr);
1550@@ -7394,7 +7395,7 @@ float3 __ovld fract(float3 x, __private float3 *iptr);
1551 float4 __ovld fract(float4 x, __private float4 *iptr);
1552 float8 __ovld fract(float8 x, __private float8 *iptr);
1553 float16 __ovld fract(float16 x, __private float16 *iptr);
1554-#ifdef cl_khr_fp64
1555+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1556 double __ovld fract(double x, __global double *iptr);
1557 double2 __ovld fract(double2 x, __global double2 *iptr);
1558 double3 __ovld fract(double3 x, __global double3 *iptr);
1559@@ -7413,7 +7414,7 @@ double3 __ovld fract(double3 x, __private double3 *iptr);
1560 double4 __ovld fract(double4 x, __private double4 *iptr);
1561 double8 __ovld fract(double8 x, __private double8 *iptr);
1562 double16 __ovld fract(double16 x, __private double16 *iptr);
1563-#endif //cl_khr_fp64
1564+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1565 #ifdef cl_khr_fp16
1566 half __ovld fract(half x, __global half *iptr);
1567 half2 __ovld fract(half2 x, __global half2 *iptr);
1568@@ -7434,29 +7435,29 @@ half4 __ovld fract(half4 x, __private half4 *iptr);
1569 half8 __ovld fract(half8 x, __private half8 *iptr);
1570 half16 __ovld fract(half16 x, __private half16 *iptr);
1571 #endif //cl_khr_fp16
1572-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
1573-
1574+#endif //! defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ !=
1575+ //! CL_VERSION_2_0)
1576 /**
1577 * Extract mantissa and exponent from x. For each
1578 * component the mantissa returned is a float with
1579 * magnitude in the interval [1/2, 1) or 0. Each
1580 * component of x equals mantissa returned * 2^exp.
1581 */
1582-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
1583+#ifdef __opencl_c_generic_address_space
1584 float __ovld frexp(float x, int *exp);
1585 float2 __ovld frexp(float2 x, int2 *exp);
1586 float3 __ovld frexp(float3 x, int3 *exp);
1587 float4 __ovld frexp(float4 x, int4 *exp);
1588 float8 __ovld frexp(float8 x, int8 *exp);
1589 float16 __ovld frexp(float16 x, int16 *exp);
1590-#ifdef cl_khr_fp64
1591+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1592 double __ovld frexp(double x, int *exp);
1593 double2 __ovld frexp(double2 x, int2 *exp);
1594 double3 __ovld frexp(double3 x, int3 *exp);
1595 double4 __ovld frexp(double4 x, int4 *exp);
1596 double8 __ovld frexp(double8 x, int8 *exp);
1597 double16 __ovld frexp(double16 x, int16 *exp);
1598-#endif //cl_khr_fp64
1599+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1600 #ifdef cl_khr_fp16
1601 half __ovld frexp(half x, int *exp);
1602 half2 __ovld frexp(half2 x, int2 *exp);
1603@@ -7465,7 +7466,9 @@ half4 __ovld frexp(half4 x, int4 *exp);
1604 half8 __ovld frexp(half8 x, int8 *exp);
1605 half16 __ovld frexp(half16 x, int16 *exp);
1606 #endif //cl_khr_fp16
1607-#else
1608+#endif //__opencl_c_generic_address_space
1609+
1610+#if !defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ != CL_VERSION_2_0)
1611 float __ovld frexp(float x, __global int *exp);
1612 float2 __ovld frexp(float2 x, __global int2 *exp);
1613 float3 __ovld frexp(float3 x, __global int3 *exp);
1614@@ -7484,7 +7487,7 @@ float3 __ovld frexp(float3 x, __private int3 *exp);
1615 float4 __ovld frexp(float4 x, __private int4 *exp);
1616 float8 __ovld frexp(float8 x, __private int8 *exp);
1617 float16 __ovld frexp(float16 x, __private int16 *exp);
1618-#ifdef cl_khr_fp64
1619+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1620 double __ovld frexp(double x, __global int *exp);
1621 double2 __ovld frexp(double2 x, __global int2 *exp);
1622 double3 __ovld frexp(double3 x, __global int3 *exp);
1623@@ -7503,7 +7506,7 @@ double3 __ovld frexp(double3 x, __private int3 *exp);
1624 double4 __ovld frexp(double4 x, __private int4 *exp);
1625 double8 __ovld frexp(double8 x, __private int8 *exp);
1626 double16 __ovld frexp(double16 x, __private int16 *exp);
1627-#endif //cl_khr_fp64
1628+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1629 #ifdef cl_khr_fp16
1630 half __ovld frexp(half x, __global int *exp);
1631 half2 __ovld frexp(half2 x, __global int2 *exp);
1632@@ -7524,7 +7527,8 @@ half4 __ovld frexp(half4 x, __private int4 *exp);
1633 half8 __ovld frexp(half8 x, __private int8 *exp);
1634 half16 __ovld frexp(half16 x, __private int16 *exp);
1635 #endif //cl_khr_fp16
1636-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
1637+#endif //! defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ !=
1638+ //! CL_VERSION_2_0)
1639
1640 /**
1641 * Compute the value of the square root of x^2 + y^2
1642@@ -7536,14 +7540,14 @@ float3 __ovld __cnfn hypot(float3 x, float3 y);
1643 float4 __ovld __cnfn hypot(float4 x, float4 y);
1644 float8 __ovld __cnfn hypot(float8 x, float8 y);
1645 float16 __ovld __cnfn hypot(float16 x, float16 y);
1646-#ifdef cl_khr_fp64
1647+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1648 double __ovld __cnfn hypot(double x, double y);
1649 double2 __ovld __cnfn hypot(double2 x, double2 y);
1650 double3 __ovld __cnfn hypot(double3 x, double3 y);
1651 double4 __ovld __cnfn hypot(double4 x, double4 y);
1652 double8 __ovld __cnfn hypot(double8 x, double8 y);
1653 double16 __ovld __cnfn hypot(double16 x, double16 y);
1654-#endif //cl_khr_fp64
1655+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1656 #ifdef cl_khr_fp16
1657 half __ovld __cnfn hypot(half x, half y);
1658 half2 __ovld __cnfn hypot(half2 x, half2 y);
1659@@ -7562,14 +7566,14 @@ int3 __ovld __cnfn ilogb(float3 x);
1660 int4 __ovld __cnfn ilogb(float4 x);
1661 int8 __ovld __cnfn ilogb(float8 x);
1662 int16 __ovld __cnfn ilogb(float16 x);
1663-#ifdef cl_khr_fp64
1664+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1665 int __ovld __cnfn ilogb(double x);
1666 int2 __ovld __cnfn ilogb(double2 x);
1667 int3 __ovld __cnfn ilogb(double3 x);
1668 int4 __ovld __cnfn ilogb(double4 x);
1669 int8 __ovld __cnfn ilogb(double8 x);
1670 int16 __ovld __cnfn ilogb(double16 x);
1671-#endif //cl_khr_fp64
1672+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1673 #ifdef cl_khr_fp16
1674 int __ovld __cnfn ilogb(half x);
1675 int2 __ovld __cnfn ilogb(half2 x);
1676@@ -7593,7 +7597,7 @@ float3 __ovld __cnfn ldexp(float3 x, int n);
1677 float4 __ovld __cnfn ldexp(float4 x, int n);
1678 float8 __ovld __cnfn ldexp(float8 x, int n);
1679 float16 __ovld __cnfn ldexp(float16 x, int n);
1680-#ifdef cl_khr_fp64
1681+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1682 double __ovld __cnfn ldexp(double x, int n);
1683 double2 __ovld __cnfn ldexp(double2 x, int2 n);
1684 double3 __ovld __cnfn ldexp(double3 x, int3 n);
1685@@ -7605,7 +7609,7 @@ double3 __ovld __cnfn ldexp(double3 x, int n);
1686 double4 __ovld __cnfn ldexp(double4 x, int n);
1687 double8 __ovld __cnfn ldexp(double8 x, int n);
1688 double16 __ovld __cnfn ldexp(double16 x, int n);
1689-#endif //cl_khr_fp64
1690+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1691 #ifdef cl_khr_fp16
1692 half __ovld __cnfn ldexp(half x, int n);
1693 half2 __ovld __cnfn ldexp(half2 x, int2 n);
1694@@ -7632,14 +7636,14 @@ float3 __ovld __cnfn lgamma(float3 x);
1695 float4 __ovld __cnfn lgamma(float4 x);
1696 float8 __ovld __cnfn lgamma(float8 x);
1697 float16 __ovld __cnfn lgamma(float16 x);
1698-#ifdef cl_khr_fp64
1699+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1700 double __ovld __cnfn lgamma(double x);
1701 double2 __ovld __cnfn lgamma(double2 x);
1702 double3 __ovld __cnfn lgamma(double3 x);
1703 double4 __ovld __cnfn lgamma(double4 x);
1704 double8 __ovld __cnfn lgamma(double8 x);
1705 double16 __ovld __cnfn lgamma(double16 x);
1706-#endif //cl_khr_fp64
1707+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1708 #ifdef cl_khr_fp16
1709 half __ovld __cnfn lgamma(half x);
1710 half2 __ovld __cnfn lgamma(half2 x);
1711@@ -7649,21 +7653,21 @@ half8 __ovld __cnfn lgamma(half8 x);
1712 half16 __ovld __cnfn lgamma(half16 x);
1713 #endif //cl_khr_fp16
1714
1715-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
1716+#ifdef __opencl_c_generic_address_space
1717 float __ovld lgamma_r(float x, int *signp);
1718 float2 __ovld lgamma_r(float2 x, int2 *signp);
1719 float3 __ovld lgamma_r(float3 x, int3 *signp);
1720 float4 __ovld lgamma_r(float4 x, int4 *signp);
1721 float8 __ovld lgamma_r(float8 x, int8 *signp);
1722 float16 __ovld lgamma_r(float16 x, int16 *signp);
1723-#ifdef cl_khr_fp64
1724+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1725 double __ovld lgamma_r(double x, int *signp);
1726 double2 __ovld lgamma_r(double2 x, int2 *signp);
1727 double3 __ovld lgamma_r(double3 x, int3 *signp);
1728 double4 __ovld lgamma_r(double4 x, int4 *signp);
1729 double8 __ovld lgamma_r(double8 x, int8 *signp);
1730 double16 __ovld lgamma_r(double16 x, int16 *signp);
1731-#endif //cl_khr_fp64
1732+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1733 #ifdef cl_khr_fp16
1734 half __ovld lgamma_r(half x, int *signp);
1735 half2 __ovld lgamma_r(half2 x, int2 *signp);
1736@@ -7672,7 +7676,9 @@ half4 __ovld lgamma_r(half4 x, int4 *signp);
1737 half8 __ovld lgamma_r(half8 x, int8 *signp);
1738 half16 __ovld lgamma_r(half16 x, int16 *signp);
1739 #endif //cl_khr_fp16
1740-#else
1741+#endif //__opencl_c_generic_address_space
1742+
1743+#if !defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ != CL_VERSION_2_0)
1744 float __ovld lgamma_r(float x, __global int *signp);
1745 float2 __ovld lgamma_r(float2 x, __global int2 *signp);
1746 float3 __ovld lgamma_r(float3 x, __global int3 *signp);
1747@@ -7691,7 +7697,7 @@ float3 __ovld lgamma_r(float3 x, __private int3 *signp);
1748 float4 __ovld lgamma_r(float4 x, __private int4 *signp);
1749 float8 __ovld lgamma_r(float8 x, __private int8 *signp);
1750 float16 __ovld lgamma_r(float16 x, __private int16 *signp);
1751-#ifdef cl_khr_fp64
1752+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1753 double __ovld lgamma_r(double x, __global int *signp);
1754 double2 __ovld lgamma_r(double2 x, __global int2 *signp);
1755 double3 __ovld lgamma_r(double3 x, __global int3 *signp);
1756@@ -7710,7 +7716,7 @@ double3 __ovld lgamma_r(double3 x, __private int3 *signp);
1757 double4 __ovld lgamma_r(double4 x, __private int4 *signp);
1758 double8 __ovld lgamma_r(double8 x, __private int8 *signp);
1759 double16 __ovld lgamma_r(double16 x, __private int16 *signp);
1760-#endif //cl_khr_fp64
1761+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1762 #ifdef cl_khr_fp16
1763 half __ovld lgamma_r(half x, __global int *signp);
1764 half2 __ovld lgamma_r(half2 x, __global int2 *signp);
1765@@ -7731,8 +7737,8 @@ half4 __ovld lgamma_r(half4 x, __private int4 *signp);
1766 half8 __ovld lgamma_r(half8 x, __private int8 *signp);
1767 half16 __ovld lgamma_r(half16 x, __private int16 *signp);
1768 #endif //cl_khr_fp16
1769-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
1770-
1771+#endif //! defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ !=
1772+ //! CL_VERSION_2_0)
1773 /**
1774 * Compute natural logarithm.
1775 */
1776@@ -7742,14 +7748,14 @@ float3 __ovld __cnfn log(float3);
1777 float4 __ovld __cnfn log(float4);
1778 float8 __ovld __cnfn log(float8);
1779 float16 __ovld __cnfn log(float16);
1780-#ifdef cl_khr_fp64
1781+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1782 double __ovld __cnfn log(double);
1783 double2 __ovld __cnfn log(double2);
1784 double3 __ovld __cnfn log(double3);
1785 double4 __ovld __cnfn log(double4);
1786 double8 __ovld __cnfn log(double8);
1787 double16 __ovld __cnfn log(double16);
1788-#endif //cl_khr_fp64
1789+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1790 #ifdef cl_khr_fp16
1791 half __ovld __cnfn log(half);
1792 half2 __ovld __cnfn log(half2);
1793@@ -7760,7 +7766,7 @@ half16 __ovld __cnfn log(half16);
1794 #endif //cl_khr_fp16
1795
1796 /**
1797- * Compute a base 2 logarithm.
1798+ * Compute a base 2 logarithm
1799 */
1800 float __ovld __cnfn log2(float);
1801 float2 __ovld __cnfn log2(float2);
1802@@ -7768,14 +7774,14 @@ float3 __ovld __cnfn log2(float3);
1803 float4 __ovld __cnfn log2(float4);
1804 float8 __ovld __cnfn log2(float8);
1805 float16 __ovld __cnfn log2(float16);
1806-#ifdef cl_khr_fp64
1807+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1808 double __ovld __cnfn log2(double);
1809 double2 __ovld __cnfn log2(double2);
1810 double3 __ovld __cnfn log2(double3);
1811 double4 __ovld __cnfn log2(double4);
1812 double8 __ovld __cnfn log2(double8);
1813 double16 __ovld __cnfn log2(double16);
1814-#endif //cl_khr_fp64
1815+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1816 #ifdef cl_khr_fp16
1817 half __ovld __cnfn log2(half);
1818 half2 __ovld __cnfn log2(half2);
1819@@ -7794,14 +7800,14 @@ float3 __ovld __cnfn log10(float3);
1820 float4 __ovld __cnfn log10(float4);
1821 float8 __ovld __cnfn log10(float8);
1822 float16 __ovld __cnfn log10(float16);
1823-#ifdef cl_khr_fp64
1824+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1825 double __ovld __cnfn log10(double);
1826 double2 __ovld __cnfn log10(double2);
1827 double3 __ovld __cnfn log10(double3);
1828 double4 __ovld __cnfn log10(double4);
1829 double8 __ovld __cnfn log10(double8);
1830 double16 __ovld __cnfn log10(double16);
1831-#endif //cl_khr_fp64
1832+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1833 #ifdef cl_khr_fp16
1834 half __ovld __cnfn log10(half);
1835 half2 __ovld __cnfn log10(half2);
1836@@ -7820,14 +7826,14 @@ float3 __ovld __cnfn log1p(float3 x);
1837 float4 __ovld __cnfn log1p(float4 x);
1838 float8 __ovld __cnfn log1p(float8 x);
1839 float16 __ovld __cnfn log1p(float16 x);
1840-#ifdef cl_khr_fp64
1841+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1842 double __ovld __cnfn log1p(double x);
1843 double2 __ovld __cnfn log1p(double2 x);
1844 double3 __ovld __cnfn log1p(double3 x);
1845 double4 __ovld __cnfn log1p(double4 x);
1846 double8 __ovld __cnfn log1p(double8 x);
1847 double16 __ovld __cnfn log1p(double16 x);
1848-#endif //cl_khr_fp64
1849+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1850 #ifdef cl_khr_fp16
1851 half __ovld __cnfn log1p(half x);
1852 half2 __ovld __cnfn log1p(half2 x);
1853@@ -7847,14 +7853,14 @@ float3 __ovld __cnfn logb(float3 x);
1854 float4 __ovld __cnfn logb(float4 x);
1855 float8 __ovld __cnfn logb(float8 x);
1856 float16 __ovld __cnfn logb(float16 x);
1857-#ifdef cl_khr_fp64
1858+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1859 double __ovld __cnfn logb(double x);
1860 double2 __ovld __cnfn logb(double2 x);
1861 double3 __ovld __cnfn logb(double3 x);
1862 double4 __ovld __cnfn logb(double4 x);
1863 double8 __ovld __cnfn logb(double8 x);
1864 double16 __ovld __cnfn logb(double16 x);
1865-#endif //cl_khr_fp64
1866+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1867 #ifdef cl_khr_fp16
1868 half __ovld __cnfn logb(half x);
1869 half2 __ovld __cnfn logb(half2 x);
1870@@ -7877,14 +7883,14 @@ float3 __ovld __cnfn mad(float3 a, float3 b, float3 c);
1871 float4 __ovld __cnfn mad(float4 a, float4 b, float4 c);
1872 float8 __ovld __cnfn mad(float8 a, float8 b, float8 c);
1873 float16 __ovld __cnfn mad(float16 a, float16 b, float16 c);
1874-#ifdef cl_khr_fp64
1875+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1876 double __ovld __cnfn mad(double a, double b, double c);
1877 double2 __ovld __cnfn mad(double2 a, double2 b, double2 c);
1878 double3 __ovld __cnfn mad(double3 a, double3 b, double3 c);
1879 double4 __ovld __cnfn mad(double4 a, double4 b, double4 c);
1880 double8 __ovld __cnfn mad(double8 a, double8 b, double8 c);
1881 double16 __ovld __cnfn mad(double16 a, double16 b, double16 c);
1882-#endif //cl_khr_fp64
1883+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1884 #ifdef cl_khr_fp16
1885 half __ovld __cnfn mad(half a, half b, half c);
1886 half2 __ovld __cnfn mad(half2 a, half2 b, half2 c);
1887@@ -7904,14 +7910,14 @@ float3 __ovld __cnfn maxmag(float3 x, float3 y);
1888 float4 __ovld __cnfn maxmag(float4 x, float4 y);
1889 float8 __ovld __cnfn maxmag(float8 x, float8 y);
1890 float16 __ovld __cnfn maxmag(float16 x, float16 y);
1891-#ifdef cl_khr_fp64
1892+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1893 double __ovld __cnfn maxmag(double x, double y);
1894 double2 __ovld __cnfn maxmag(double2 x, double2 y);
1895 double3 __ovld __cnfn maxmag(double3 x, double3 y);
1896 double4 __ovld __cnfn maxmag(double4 x, double4 y);
1897 double8 __ovld __cnfn maxmag(double8 x, double8 y);
1898 double16 __ovld __cnfn maxmag(double16 x, double16 y);
1899-#endif //cl_khr_fp64
1900+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1901 #ifdef cl_khr_fp16
1902 half __ovld __cnfn maxmag(half x, half y);
1903 half2 __ovld __cnfn maxmag(half2 x, half2 y);
1904@@ -7931,14 +7937,14 @@ float3 __ovld __cnfn minmag(float3 x, float3 y);
1905 float4 __ovld __cnfn minmag(float4 x, float4 y);
1906 float8 __ovld __cnfn minmag(float8 x, float8 y);
1907 float16 __ovld __cnfn minmag(float16 x, float16 y);
1908-#ifdef cl_khr_fp64
1909+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1910 double __ovld __cnfn minmag(double x, double y);
1911 double2 __ovld __cnfn minmag(double2 x, double2 y);
1912 double3 __ovld __cnfn minmag(double3 x, double3 y);
1913 double4 __ovld __cnfn minmag(double4 x, double4 y);
1914 double8 __ovld __cnfn minmag(double8 x, double8 y);
1915 double16 __ovld __cnfn minmag(double16 x, double16 y);
1916-#endif //cl_khr_fp64
1917+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1918 #ifdef cl_khr_fp16
1919 half __ovld __cnfn minmag(half x, half y);
1920 half2 __ovld __cnfn minmag(half2 x, half2 y);
1921@@ -7955,21 +7961,21 @@ half16 __ovld __cnfn minmag(half16 x, half16 y);
1922 * the argument. It stores the integral part in the object
1923 * pointed to by iptr.
1924 */
1925-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
1926+#ifdef __opencl_c_generic_address_space
1927 float __ovld modf(float x, float *iptr);
1928 float2 __ovld modf(float2 x, float2 *iptr);
1929 float3 __ovld modf(float3 x, float3 *iptr);
1930 float4 __ovld modf(float4 x, float4 *iptr);
1931 float8 __ovld modf(float8 x, float8 *iptr);
1932 float16 __ovld modf(float16 x, float16 *iptr);
1933-#ifdef cl_khr_fp64
1934+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1935 double __ovld modf(double x, double *iptr);
1936 double2 __ovld modf(double2 x, double2 *iptr);
1937 double3 __ovld modf(double3 x, double3 *iptr);
1938 double4 __ovld modf(double4 x, double4 *iptr);
1939 double8 __ovld modf(double8 x, double8 *iptr);
1940 double16 __ovld modf(double16 x, double16 *iptr);
1941-#endif //cl_khr_fp64
1942+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1943 #ifdef cl_khr_fp16
1944 half __ovld modf(half x, half *iptr);
1945 half2 __ovld modf(half2 x, half2 *iptr);
1946@@ -7978,7 +7984,9 @@ half4 __ovld modf(half4 x, half4 *iptr);
1947 half8 __ovld modf(half8 x, half8 *iptr);
1948 half16 __ovld modf(half16 x, half16 *iptr);
1949 #endif //cl_khr_fp16
1950-#else
1951+#endif //__opencl_c_generic_address_space
1952+
1953+#if !defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ != CL_VERSION_2_0)
1954 float __ovld modf(float x, __global float *iptr);
1955 float2 __ovld modf(float2 x, __global float2 *iptr);
1956 float3 __ovld modf(float3 x, __global float3 *iptr);
1957@@ -7997,7 +8005,7 @@ float3 __ovld modf(float3 x, __private float3 *iptr);
1958 float4 __ovld modf(float4 x, __private float4 *iptr);
1959 float8 __ovld modf(float8 x, __private float8 *iptr);
1960 float16 __ovld modf(float16 x, __private float16 *iptr);
1961-#ifdef cl_khr_fp64
1962+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1963 double __ovld modf(double x, __global double *iptr);
1964 double2 __ovld modf(double2 x, __global double2 *iptr);
1965 double3 __ovld modf(double3 x, __global double3 *iptr);
1966@@ -8016,7 +8024,7 @@ double3 __ovld modf(double3 x, __private double3 *iptr);
1967 double4 __ovld modf(double4 x, __private double4 *iptr);
1968 double8 __ovld modf(double8 x, __private double8 *iptr);
1969 double16 __ovld modf(double16 x, __private double16 *iptr);
1970-#endif //cl_khr_fp64
1971+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1972 #ifdef cl_khr_fp16
1973 half __ovld modf(half x, __global half *iptr);
1974 half2 __ovld modf(half2 x, __global half2 *iptr);
1975@@ -8037,7 +8045,8 @@ half4 __ovld modf(half4 x, __private half4 *iptr);
1976 half8 __ovld modf(half8 x, __private half8 *iptr);
1977 half16 __ovld modf(half16 x, __private half16 *iptr);
1978 #endif //cl_khr_fp16
1979-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
1980+#endif //! defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ !=
1981+ //! CL_VERSION_2_0)
1982
1983 /**
1984 * Returns a quiet NaN. The nancode may be placed
1985@@ -8049,14 +8058,14 @@ float3 __ovld __cnfn nan(uint3 nancode);
1986 float4 __ovld __cnfn nan(uint4 nancode);
1987 float8 __ovld __cnfn nan(uint8 nancode);
1988 float16 __ovld __cnfn nan(uint16 nancode);
1989-#ifdef cl_khr_fp64
1990+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1991 double __ovld __cnfn nan(ulong nancode);
1992 double2 __ovld __cnfn nan(ulong2 nancode);
1993 double3 __ovld __cnfn nan(ulong3 nancode);
1994 double4 __ovld __cnfn nan(ulong4 nancode);
1995 double8 __ovld __cnfn nan(ulong8 nancode);
1996 double16 __ovld __cnfn nan(ulong16 nancode);
1997-#endif //cl_khr_fp64
1998+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
1999 #ifdef cl_khr_fp16
2000 half __ovld __cnfn nan(ushort nancode);
2001 half2 __ovld __cnfn nan(ushort2 nancode);
2002@@ -8079,14 +8088,14 @@ float3 __ovld __cnfn nextafter(float3 x, float3 y);
2003 float4 __ovld __cnfn nextafter(float4 x, float4 y);
2004 float8 __ovld __cnfn nextafter(float8 x, float8 y);
2005 float16 __ovld __cnfn nextafter(float16 x, float16 y);
2006-#ifdef cl_khr_fp64
2007+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2008 double __ovld __cnfn nextafter(double x, double y);
2009 double2 __ovld __cnfn nextafter(double2 x, double2 y);
2010 double3 __ovld __cnfn nextafter(double3 x, double3 y);
2011 double4 __ovld __cnfn nextafter(double4 x, double4 y);
2012 double8 __ovld __cnfn nextafter(double8 x, double8 y);
2013 double16 __ovld __cnfn nextafter(double16 x, double16 y);
2014-#endif //cl_khr_fp64
2015+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2016 #ifdef cl_khr_fp16
2017 half __ovld __cnfn nextafter(half x, half y);
2018 half2 __ovld __cnfn nextafter(half2 x, half2 y);
2019@@ -8105,14 +8114,14 @@ float3 __ovld __cnfn pow(float3 x, float3 y);
2020 float4 __ovld __cnfn pow(float4 x, float4 y);
2021 float8 __ovld __cnfn pow(float8 x, float8 y);
2022 float16 __ovld __cnfn pow(float16 x, float16 y);
2023-#ifdef cl_khr_fp64
2024+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2025 double __ovld __cnfn pow(double x, double y);
2026 double2 __ovld __cnfn pow(double2 x, double2 y);
2027 double3 __ovld __cnfn pow(double3 x, double3 y);
2028 double4 __ovld __cnfn pow(double4 x, double4 y);
2029 double8 __ovld __cnfn pow(double8 x, double8 y);
2030 double16 __ovld __cnfn pow(double16 x, double16 y);
2031-#endif //cl_khr_fp64
2032+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2033 #ifdef cl_khr_fp16
2034 half __ovld __cnfn pow(half x, half y);
2035 half2 __ovld __cnfn pow(half2 x, half2 y);
2036@@ -8131,14 +8140,14 @@ float3 __ovld __cnfn pown(float3 x, int3 y);
2037 float4 __ovld __cnfn pown(float4 x, int4 y);
2038 float8 __ovld __cnfn pown(float8 x, int8 y);
2039 float16 __ovld __cnfn pown(float16 x, int16 y);
2040-#ifdef cl_khr_fp64
2041+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2042 double __ovld __cnfn pown(double x, int y);
2043 double2 __ovld __cnfn pown(double2 x, int2 y);
2044 double3 __ovld __cnfn pown(double3 x, int3 y);
2045 double4 __ovld __cnfn pown(double4 x, int4 y);
2046 double8 __ovld __cnfn pown(double8 x, int8 y);
2047 double16 __ovld __cnfn pown(double16 x, int16 y);
2048-#endif //cl_khr_fp64
2049+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2050 #ifdef cl_khr_fp16
2051 half __ovld __cnfn pown(half x, int y);
2052 half2 __ovld __cnfn pown(half2 x, int2 y);
2053@@ -8157,14 +8166,14 @@ float3 __ovld __cnfn powr(float3 x, float3 y);
2054 float4 __ovld __cnfn powr(float4 x, float4 y);
2055 float8 __ovld __cnfn powr(float8 x, float8 y);
2056 float16 __ovld __cnfn powr(float16 x, float16 y);
2057-#ifdef cl_khr_fp64
2058+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2059 double __ovld __cnfn powr(double x, double y);
2060 double2 __ovld __cnfn powr(double2 x, double2 y);
2061 double3 __ovld __cnfn powr(double3 x, double3 y);
2062 double4 __ovld __cnfn powr(double4 x, double4 y);
2063 double8 __ovld __cnfn powr(double8 x, double8 y);
2064 double16 __ovld __cnfn powr(double16 x, double16 y);
2065-#endif //cl_khr_fp64
2066+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2067 #ifdef cl_khr_fp16
2068 half __ovld __cnfn powr(half x, half y);
2069 half2 __ovld __cnfn powr(half2 x, half2 y);
2070@@ -8186,14 +8195,14 @@ float3 __ovld __cnfn remainder(float3 x, float3 y);
2071 float4 __ovld __cnfn remainder(float4 x, float4 y);
2072 float8 __ovld __cnfn remainder(float8 x, float8 y);
2073 float16 __ovld __cnfn remainder(float16 x, float16 y);
2074-#ifdef cl_khr_fp64
2075+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2076 double __ovld __cnfn remainder(double x, double y);
2077 double2 __ovld __cnfn remainder(double2 x, double2 y);
2078 double3 __ovld __cnfn remainder(double3 x, double3 y);
2079 double4 __ovld __cnfn remainder(double4 x, double4 y);
2080 double8 __ovld __cnfn remainder(double8 x, double8 y);
2081 double16 __ovld __cnfn remainder(double16 x, double16 y);
2082-#endif //cl_khr_fp64
2083+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2084 #ifdef cl_khr_fp16
2085 half __ovld __cnfn remainder(half x, half y);
2086 half2 __ovld __cnfn remainder(half2 x, half2 y);
2087@@ -8215,21 +8224,21 @@ half16 __ovld __cnfn remainder(half16 x, half16 y);
2088 * sign as x/y. It stores this signed value in the object
2089 * pointed to by quo.
2090 */
2091-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
2092+#ifdef __opencl_c_generic_address_space
2093 float __ovld remquo(float x, float y, int *quo);
2094 float2 __ovld remquo(float2 x, float2 y, int2 *quo);
2095 float3 __ovld remquo(float3 x, float3 y, int3 *quo);
2096 float4 __ovld remquo(float4 x, float4 y, int4 *quo);
2097 float8 __ovld remquo(float8 x, float8 y, int8 *quo);
2098 float16 __ovld remquo(float16 x, float16 y, int16 *quo);
2099-#ifdef cl_khr_fp64
2100+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2101 double __ovld remquo(double x, double y, int *quo);
2102 double2 __ovld remquo(double2 x, double2 y, int2 *quo);
2103 double3 __ovld remquo(double3 x, double3 y, int3 *quo);
2104 double4 __ovld remquo(double4 x, double4 y, int4 *quo);
2105 double8 __ovld remquo(double8 x, double8 y, int8 *quo);
2106 double16 __ovld remquo(double16 x, double16 y, int16 *quo);
2107-#endif //cl_khr_fp64
2108+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2109 #ifdef cl_khr_fp16
2110 half __ovld remquo(half x, half y, int *quo);
2111 half2 __ovld remquo(half2 x, half2 y, int2 *quo);
2112@@ -8237,9 +8246,10 @@ half3 __ovld remquo(half3 x, half3 y, int3 *quo);
2113 half4 __ovld remquo(half4 x, half4 y, int4 *quo);
2114 half8 __ovld remquo(half8 x, half8 y, int8 *quo);
2115 half16 __ovld remquo(half16 x, half16 y, int16 *quo);
2116-
2117 #endif //cl_khr_fp16
2118-#else
2119+#endif //__opencl_c_generic_address_space
2120+
2121+#if !defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ != CL_VERSION_2_0)
2122 float __ovld remquo(float x, float y, __global int *quo);
2123 float2 __ovld remquo(float2 x, float2 y, __global int2 *quo);
2124 float3 __ovld remquo(float3 x, float3 y, __global int3 *quo);
2125@@ -8258,7 +8268,7 @@ float3 __ovld remquo(float3 x, float3 y, __private int3 *quo);
2126 float4 __ovld remquo(float4 x, float4 y, __private int4 *quo);
2127 float8 __ovld remquo(float8 x, float8 y, __private int8 *quo);
2128 float16 __ovld remquo(float16 x, float16 y, __private int16 *quo);
2129-#ifdef cl_khr_fp64
2130+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2131 double __ovld remquo(double x, double y, __global int *quo);
2132 double2 __ovld remquo(double2 x, double2 y, __global int2 *quo);
2133 double3 __ovld remquo(double3 x, double3 y, __global int3 *quo);
2134@@ -8277,7 +8287,7 @@ double3 __ovld remquo(double3 x, double3 y, __private int3 *quo);
2135 double4 __ovld remquo(double4 x, double4 y, __private int4 *quo);
2136 double8 __ovld remquo(double8 x, double8 y, __private int8 *quo);
2137 double16 __ovld remquo(double16 x, double16 y, __private int16 *quo);
2138-#endif //cl_khr_fp64
2139+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2140 #ifdef cl_khr_fp16
2141 half __ovld remquo(half x, half y, __global int *quo);
2142 half2 __ovld remquo(half2 x, half2 y, __global int2 *quo);
2143@@ -8298,7 +8308,8 @@ half4 __ovld remquo(half4 x, half4 y, __private int4 *quo);
2144 half8 __ovld remquo(half8 x, half8 y, __private int8 *quo);
2145 half16 __ovld remquo(half16 x, half16 y, __private int16 *quo);
2146 #endif //cl_khr_fp16
2147-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
2148+#endif //! defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ !=
2149+ //! CL_VERSION_2_0)
2150 /**
2151 * Round to integral value (using round to nearest
2152 * even rounding mode) in floating-point format.
2153@@ -8311,14 +8322,14 @@ float3 __ovld __cnfn rint(float3);
2154 float4 __ovld __cnfn rint(float4);
2155 float8 __ovld __cnfn rint(float8);
2156 float16 __ovld __cnfn rint(float16);
2157-#ifdef cl_khr_fp64
2158+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2159 double __ovld __cnfn rint(double);
2160 double2 __ovld __cnfn rint(double2);
2161 double3 __ovld __cnfn rint(double3);
2162 double4 __ovld __cnfn rint(double4);
2163 double8 __ovld __cnfn rint(double8);
2164 double16 __ovld __cnfn rint(double16);
2165-#endif //cl_khr_fp64
2166+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2167 #ifdef cl_khr_fp16
2168 half __ovld __cnfn rint(half);
2169 half2 __ovld __cnfn rint(half2);
2170@@ -8337,14 +8348,14 @@ float3 __ovld __cnfn rootn(float3 x, int3 y);
2171 float4 __ovld __cnfn rootn(float4 x, int4 y);
2172 float8 __ovld __cnfn rootn(float8 x, int8 y);
2173 float16 __ovld __cnfn rootn(float16 x, int16 y);
2174-#ifdef cl_khr_fp64
2175+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2176 double __ovld __cnfn rootn(double x, int y);
2177 double2 __ovld __cnfn rootn(double2 x, int2 y);
2178 double3 __ovld __cnfn rootn(double3 x, int3 y);
2179 double4 __ovld __cnfn rootn(double4 x, int4 y);
2180 double8 __ovld __cnfn rootn(double8 x, int8 y);
2181 double16 __ovld __cnfn rootn(double16 x, int16 y);
2182-#endif //cl_khr_fp64
2183+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2184 #ifdef cl_khr_fp16
2185 half __ovld __cnfn rootn(half x, int y);
2186 half2 __ovld __cnfn rootn(half2 x, int2 y);
2187@@ -8365,14 +8376,14 @@ float3 __ovld __cnfn round(float3 x);
2188 float4 __ovld __cnfn round(float4 x);
2189 float8 __ovld __cnfn round(float8 x);
2190 float16 __ovld __cnfn round(float16 x);
2191-#ifdef cl_khr_fp64
2192+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2193 double __ovld __cnfn round(double x);
2194 double2 __ovld __cnfn round(double2 x);
2195 double3 __ovld __cnfn round(double3 x);
2196 double4 __ovld __cnfn round(double4 x);
2197 double8 __ovld __cnfn round(double8 x);
2198 double16 __ovld __cnfn round(double16 x);
2199-#endif //cl_khr_fp64
2200+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2201 #ifdef cl_khr_fp16
2202 half __ovld __cnfn round(half x);
2203 half2 __ovld __cnfn round(half2 x);
2204@@ -8391,14 +8402,14 @@ float3 __ovld __cnfn rsqrt(float3);
2205 float4 __ovld __cnfn rsqrt(float4);
2206 float8 __ovld __cnfn rsqrt(float8);
2207 float16 __ovld __cnfn rsqrt(float16);
2208-#ifdef cl_khr_fp64
2209+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2210 double __ovld __cnfn rsqrt(double);
2211 double2 __ovld __cnfn rsqrt(double2);
2212 double3 __ovld __cnfn rsqrt(double3);
2213 double4 __ovld __cnfn rsqrt(double4);
2214 double8 __ovld __cnfn rsqrt(double8);
2215 double16 __ovld __cnfn rsqrt(double16);
2216-#endif //cl_khr_fp64
2217+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2218 #ifdef cl_khr_fp16
2219 half __ovld __cnfn rsqrt(half);
2220 half2 __ovld __cnfn rsqrt(half2);
2221@@ -8417,14 +8428,14 @@ float3 __ovld __cnfn sin(float3);
2222 float4 __ovld __cnfn sin(float4);
2223 float8 __ovld __cnfn sin(float8);
2224 float16 __ovld __cnfn sin(float16);
2225-#ifdef cl_khr_fp64
2226+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2227 double __ovld __cnfn sin(double);
2228 double2 __ovld __cnfn sin(double2);
2229 double3 __ovld __cnfn sin(double3);
2230 double4 __ovld __cnfn sin(double4);
2231 double8 __ovld __cnfn sin(double8);
2232 double16 __ovld __cnfn sin(double16);
2233-#endif //cl_khr_fp64
2234+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2235 #ifdef cl_khr_fp16
2236 half __ovld __cnfn sin(half);
2237 half2 __ovld __cnfn sin(half2);
2238@@ -8439,21 +8450,21 @@ half16 __ovld __cnfn sin(half16);
2239 * is the return value and computed cosine is returned
2240 * in cosval.
2241 */
2242-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
2243+#ifdef __opencl_c_generic_address_space
2244 float __ovld sincos(float x, float *cosval);
2245 float2 __ovld sincos(float2 x, float2 *cosval);
2246 float3 __ovld sincos(float3 x, float3 *cosval);
2247 float4 __ovld sincos(float4 x, float4 *cosval);
2248 float8 __ovld sincos(float8 x, float8 *cosval);
2249 float16 __ovld sincos(float16 x, float16 *cosval);
2250-#ifdef cl_khr_fp64
2251+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2252 double __ovld sincos(double x, double *cosval);
2253 double2 __ovld sincos(double2 x, double2 *cosval);
2254 double3 __ovld sincos(double3 x, double3 *cosval);
2255 double4 __ovld sincos(double4 x, double4 *cosval);
2256 double8 __ovld sincos(double8 x, double8 *cosval);
2257 double16 __ovld sincos(double16 x, double16 *cosval);
2258-#endif //cl_khr_fp64
2259+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2260 #ifdef cl_khr_fp16
2261 half __ovld sincos(half x, half *cosval);
2262 half2 __ovld sincos(half2 x, half2 *cosval);
2263@@ -8462,7 +8473,9 @@ half4 __ovld sincos(half4 x, half4 *cosval);
2264 half8 __ovld sincos(half8 x, half8 *cosval);
2265 half16 __ovld sincos(half16 x, half16 *cosval);
2266 #endif //cl_khr_fp16
2267-#else
2268+#endif //__opencl_c_generic_address_space
2269+
2270+#if !defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ != CL_VERSION_2_0)
2271 float __ovld sincos(float x, __global float *cosval);
2272 float2 __ovld sincos(float2 x, __global float2 *cosval);
2273 float3 __ovld sincos(float3 x, __global float3 *cosval);
2274@@ -8481,7 +8494,7 @@ float3 __ovld sincos(float3 x, __private float3 *cosval);
2275 float4 __ovld sincos(float4 x, __private float4 *cosval);
2276 float8 __ovld sincos(float8 x, __private float8 *cosval);
2277 float16 __ovld sincos(float16 x, __private float16 *cosval);
2278-#ifdef cl_khr_fp64
2279+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2280 double __ovld sincos(double x, __global double *cosval);
2281 double2 __ovld sincos(double2 x, __global double2 *cosval);
2282 double3 __ovld sincos(double3 x, __global double3 *cosval);
2283@@ -8500,7 +8513,7 @@ double3 __ovld sincos(double3 x, __private double3 *cosval);
2284 double4 __ovld sincos(double4 x, __private double4 *cosval);
2285 double8 __ovld sincos(double8 x, __private double8 *cosval);
2286 double16 __ovld sincos(double16 x, __private double16 *cosval);
2287-#endif //cl_khr_fp64
2288+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2289 #ifdef cl_khr_fp16
2290 half __ovld sincos(half x, __global half *cosval);
2291 half2 __ovld sincos(half2 x, __global half2 *cosval);
2292@@ -8521,8 +8534,8 @@ half4 __ovld sincos(half4 x, __private half4 *cosval);
2293 half8 __ovld sincos(half8 x, __private half8 *cosval);
2294 half16 __ovld sincos(half16 x, __private half16 *cosval);
2295 #endif //cl_khr_fp16
2296-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
2297-
2298+#endif //! defined(__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ !=
2299+ //! CL_VERSION_2_0)
2300 /**
2301 * Compute hyperbolic sine.
2302 */
2303@@ -8532,14 +8545,14 @@ float3 __ovld __cnfn sinh(float3);
2304 float4 __ovld __cnfn sinh(float4);
2305 float8 __ovld __cnfn sinh(float8);
2306 float16 __ovld __cnfn sinh(float16);
2307-#ifdef cl_khr_fp64
2308+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2309 double __ovld __cnfn sinh(double);
2310 double2 __ovld __cnfn sinh(double2);
2311 double3 __ovld __cnfn sinh(double3);
2312 double4 __ovld __cnfn sinh(double4);
2313 double8 __ovld __cnfn sinh(double8);
2314 double16 __ovld __cnfn sinh(double16);
2315-#endif //cl_khr_fp64
2316+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2317 #ifdef cl_khr_fp16
2318 half __ovld __cnfn sinh(half);
2319 half2 __ovld __cnfn sinh(half2);
2320@@ -8558,14 +8571,14 @@ float3 __ovld __cnfn sinpi(float3 x);
2321 float4 __ovld __cnfn sinpi(float4 x);
2322 float8 __ovld __cnfn sinpi(float8 x);
2323 float16 __ovld __cnfn sinpi(float16 x);
2324-#ifdef cl_khr_fp64
2325+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2326 double __ovld __cnfn sinpi(double x);
2327 double2 __ovld __cnfn sinpi(double2 x);
2328 double3 __ovld __cnfn sinpi(double3 x);
2329 double4 __ovld __cnfn sinpi(double4 x);
2330 double8 __ovld __cnfn sinpi(double8 x);
2331 double16 __ovld __cnfn sinpi(double16 x);
2332-#endif //cl_khr_fp64
2333+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2334 #ifdef cl_khr_fp16
2335 half __ovld __cnfn sinpi(half x);
2336 half2 __ovld __cnfn sinpi(half2 x);
2337@@ -8584,14 +8597,14 @@ float3 __ovld __cnfn sqrt(float3);
2338 float4 __ovld __cnfn sqrt(float4);
2339 float8 __ovld __cnfn sqrt(float8);
2340 float16 __ovld __cnfn sqrt(float16);
2341-#ifdef cl_khr_fp64
2342+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2343 double __ovld __cnfn sqrt(double);
2344 double2 __ovld __cnfn sqrt(double2);
2345 double3 __ovld __cnfn sqrt(double3);
2346 double4 __ovld __cnfn sqrt(double4);
2347 double8 __ovld __cnfn sqrt(double8);
2348 double16 __ovld __cnfn sqrt(double16);
2349-#endif //cl_khr_fp64
2350+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2351 #ifdef cl_khr_fp16
2352 half __ovld __cnfn sqrt(half);
2353 half2 __ovld __cnfn sqrt(half2);
2354@@ -8610,14 +8623,14 @@ float3 __ovld __cnfn tan(float3);
2355 float4 __ovld __cnfn tan(float4);
2356 float8 __ovld __cnfn tan(float8);
2357 float16 __ovld __cnfn tan(float16);
2358-#ifdef cl_khr_fp64
2359+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2360 double __ovld __cnfn tan(double);
2361 double2 __ovld __cnfn tan(double2);
2362 double3 __ovld __cnfn tan(double3);
2363 double4 __ovld __cnfn tan(double4);
2364 double8 __ovld __cnfn tan(double8);
2365 double16 __ovld __cnfn tan(double16);
2366-#endif //cl_khr_fp64
2367+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2368 #ifdef cl_khr_fp16
2369 half __ovld __cnfn tan(half);
2370 half2 __ovld __cnfn tan(half2);
2371@@ -8636,14 +8649,14 @@ float3 __ovld __cnfn tanh(float3);
2372 float4 __ovld __cnfn tanh(float4);
2373 float8 __ovld __cnfn tanh(float8);
2374 float16 __ovld __cnfn tanh(float16);
2375-#ifdef cl_khr_fp64
2376+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2377 double __ovld __cnfn tanh(double);
2378 double2 __ovld __cnfn tanh(double2);
2379 double3 __ovld __cnfn tanh(double3);
2380 double4 __ovld __cnfn tanh(double4);
2381 double8 __ovld __cnfn tanh(double8);
2382 double16 __ovld __cnfn tanh(double16);
2383-#endif //cl_khr_fp64
2384+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2385 #ifdef cl_khr_fp16
2386 half __ovld __cnfn tanh(half);
2387 half2 __ovld __cnfn tanh(half2);
2388@@ -8662,14 +8675,14 @@ float3 __ovld __cnfn tanpi(float3 x);
2389 float4 __ovld __cnfn tanpi(float4 x);
2390 float8 __ovld __cnfn tanpi(float8 x);
2391 float16 __ovld __cnfn tanpi(float16 x);
2392-#ifdef cl_khr_fp64
2393+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2394 double __ovld __cnfn tanpi(double x);
2395 double2 __ovld __cnfn tanpi(double2 x);
2396 double3 __ovld __cnfn tanpi(double3 x);
2397 double4 __ovld __cnfn tanpi(double4 x);
2398 double8 __ovld __cnfn tanpi(double8 x);
2399 double16 __ovld __cnfn tanpi(double16 x);
2400-#endif //cl_khr_fp64
2401+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2402 #ifdef cl_khr_fp16
2403 half __ovld __cnfn tanpi(half x);
2404 half2 __ovld __cnfn tanpi(half2 x);
2405@@ -8688,14 +8701,14 @@ float3 __ovld __cnfn tgamma(float3);
2406 float4 __ovld __cnfn tgamma(float4);
2407 float8 __ovld __cnfn tgamma(float8);
2408 float16 __ovld __cnfn tgamma(float16);
2409-#ifdef cl_khr_fp64
2410+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2411 double __ovld __cnfn tgamma(double);
2412 double2 __ovld __cnfn tgamma(double2);
2413 double3 __ovld __cnfn tgamma(double3);
2414 double4 __ovld __cnfn tgamma(double4);
2415 double8 __ovld __cnfn tgamma(double8);
2416 double16 __ovld __cnfn tgamma(double16);
2417-#endif //cl_khr_fp64
2418+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2419 #ifdef cl_khr_fp16
2420 half __ovld __cnfn tgamma(half);
2421 half2 __ovld __cnfn tgamma(half2);
2422@@ -8715,14 +8728,14 @@ float3 __ovld __cnfn trunc(float3);
2423 float4 __ovld __cnfn trunc(float4);
2424 float8 __ovld __cnfn trunc(float8);
2425 float16 __ovld __cnfn trunc(float16);
2426-#ifdef cl_khr_fp64
2427+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2428 double __ovld __cnfn trunc(double);
2429 double2 __ovld __cnfn trunc(double2);
2430 double3 __ovld __cnfn trunc(double3);
2431 double4 __ovld __cnfn trunc(double4);
2432 double8 __ovld __cnfn trunc(double8);
2433 double16 __ovld __cnfn trunc(double16);
2434-#endif //cl_khr_fp64
2435+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2436 #ifdef cl_khr_fp16
2437 half __ovld __cnfn trunc(half);
2438 half2 __ovld __cnfn trunc(half2);
2439@@ -10108,7 +10121,7 @@ float3 __ovld __cnfn clamp(float3 x, float minval, float maxval);
2440 float4 __ovld __cnfn clamp(float4 x, float minval, float maxval);
2441 float8 __ovld __cnfn clamp(float8 x, float minval, float maxval);
2442 float16 __ovld __cnfn clamp(float16 x, float minval, float maxval);
2443-#ifdef cl_khr_fp64
2444+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2445 double __ovld __cnfn clamp(double x, double minval, double maxval);
2446 double2 __ovld __cnfn clamp(double2 x, double2 minval, double2 maxval);
2447 double3 __ovld __cnfn clamp(double3 x, double3 minval, double3 maxval);
2448@@ -10120,7 +10133,7 @@ double3 __ovld __cnfn clamp(double3 x, double minval, double maxval);
2449 double4 __ovld __cnfn clamp(double4 x, double minval, double maxval);
2450 double8 __ovld __cnfn clamp(double8 x, double minval, double maxval);
2451 double16 __ovld __cnfn clamp(double16 x, double minval, double maxval);
2452-#endif //cl_khr_fp64
2453+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2454 #ifdef cl_khr_fp16
2455 half __ovld __cnfn clamp(half x, half minval, half maxval);
2456 half2 __ovld __cnfn clamp(half2 x, half2 minval, half2 maxval);
2457@@ -10145,14 +10158,14 @@ float3 __ovld __cnfn degrees(float3 radians);
2458 float4 __ovld __cnfn degrees(float4 radians);
2459 float8 __ovld __cnfn degrees(float8 radians);
2460 float16 __ovld __cnfn degrees(float16 radians);
2461-#ifdef cl_khr_fp64
2462+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2463 double __ovld __cnfn degrees(double radians);
2464 double2 __ovld __cnfn degrees(double2 radians);
2465 double3 __ovld __cnfn degrees(double3 radians);
2466 double4 __ovld __cnfn degrees(double4 radians);
2467 double8 __ovld __cnfn degrees(double8 radians);
2468 double16 __ovld __cnfn degrees(double16 radians);
2469-#endif //cl_khr_fp64
2470+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2471 #ifdef cl_khr_fp16
2472 half __ovld __cnfn degrees(half radians);
2473 half2 __ovld __cnfn degrees(half2 radians);
2474@@ -10177,7 +10190,7 @@ float3 __ovld __cnfn max(float3 x, float y);
2475 float4 __ovld __cnfn max(float4 x, float y);
2476 float8 __ovld __cnfn max(float8 x, float y);
2477 float16 __ovld __cnfn max(float16 x, float y);
2478-#ifdef cl_khr_fp64
2479+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2480 double __ovld __cnfn max(double x, double y);
2481 double2 __ovld __cnfn max(double2 x, double2 y);
2482 double3 __ovld __cnfn max(double3 x, double3 y);
2483@@ -10189,7 +10202,7 @@ double3 __ovld __cnfn max(double3 x, double y);
2484 double4 __ovld __cnfn max(double4 x, double y);
2485 double8 __ovld __cnfn max(double8 x, double y);
2486 double16 __ovld __cnfn max(double16 x, double y);
2487-#endif //cl_khr_fp64
2488+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2489 #ifdef cl_khr_fp16
2490 half __ovld __cnfn max(half x, half y);
2491 half2 __ovld __cnfn max(half2 x, half2 y);
2492@@ -10219,7 +10232,7 @@ float3 __ovld __cnfn min(float3 x, float y);
2493 float4 __ovld __cnfn min(float4 x, float y);
2494 float8 __ovld __cnfn min(float8 x, float y);
2495 float16 __ovld __cnfn min(float16 x, float y);
2496-#ifdef cl_khr_fp64
2497+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2498 double __ovld __cnfn min(double x, double y);
2499 double2 __ovld __cnfn min(double2 x, double2 y);
2500 double3 __ovld __cnfn min(double3 x, double3 y);
2501@@ -10231,7 +10244,7 @@ double3 __ovld __cnfn min(double3 x, double y);
2502 double4 __ovld __cnfn min(double4 x, double y);
2503 double8 __ovld __cnfn min(double8 x, double y);
2504 double16 __ovld __cnfn min(double16 x, double y);
2505-#endif //cl_khr_fp64
2506+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2507 #ifdef cl_khr_fp16
2508 half __ovld __cnfn min(half x, half y);
2509 half2 __ovld __cnfn min(half2 x, half2 y);
2510@@ -10264,7 +10277,7 @@ float3 __ovld __cnfn mix(float3 x, float3 y, float a);
2511 float4 __ovld __cnfn mix(float4 x, float4 y, float a);
2512 float8 __ovld __cnfn mix(float8 x, float8 y, float a);
2513 float16 __ovld __cnfn mix(float16 x, float16 y, float a);
2514-#ifdef cl_khr_fp64
2515+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2516 double __ovld __cnfn mix(double x, double y, double a);
2517 double2 __ovld __cnfn mix(double2 x, double2 y, double2 a);
2518 double3 __ovld __cnfn mix(double3 x, double3 y, double3 a);
2519@@ -10276,7 +10289,7 @@ double3 __ovld __cnfn mix(double3 x, double3 y, double a);
2520 double4 __ovld __cnfn mix(double4 x, double4 y, double a);
2521 double8 __ovld __cnfn mix(double8 x, double8 y, double a);
2522 double16 __ovld __cnfn mix(double16 x, double16 y, double a);
2523-#endif //cl_khr_fp64
2524+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2525 #ifdef cl_khr_fp16
2526 half __ovld __cnfn mix(half x, half y, half a);
2527 half2 __ovld __cnfn mix(half2 x, half2 y, half2 a);
2528@@ -10301,14 +10314,14 @@ float3 __ovld __cnfn radians(float3 degrees);
2529 float4 __ovld __cnfn radians(float4 degrees);
2530 float8 __ovld __cnfn radians(float8 degrees);
2531 float16 __ovld __cnfn radians(float16 degrees);
2532-#ifdef cl_khr_fp64
2533+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2534 double __ovld __cnfn radians(double degrees);
2535 double2 __ovld __cnfn radians(double2 degrees);
2536 double3 __ovld __cnfn radians(double3 degrees);
2537 double4 __ovld __cnfn radians(double4 degrees);
2538 double8 __ovld __cnfn radians(double8 degrees);
2539 double16 __ovld __cnfn radians(double16 degrees);
2540-#endif //cl_khr_fp64
2541+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2542 #ifdef cl_khr_fp16
2543 half __ovld __cnfn radians(half degrees);
2544 half2 __ovld __cnfn radians(half2 degrees);
2545@@ -10332,7 +10345,7 @@ float3 __ovld __cnfn step(float edge, float3 x);
2546 float4 __ovld __cnfn step(float edge, float4 x);
2547 float8 __ovld __cnfn step(float edge, float8 x);
2548 float16 __ovld __cnfn step(float edge, float16 x);
2549-#ifdef cl_khr_fp64
2550+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2551 double __ovld __cnfn step(double edge, double x);
2552 double2 __ovld __cnfn step(double2 edge, double2 x);
2553 double3 __ovld __cnfn step(double3 edge, double3 x);
2554@@ -10344,7 +10357,7 @@ double3 __ovld __cnfn step(double edge, double3 x);
2555 double4 __ovld __cnfn step(double edge, double4 x);
2556 double8 __ovld __cnfn step(double edge, double8 x);
2557 double16 __ovld __cnfn step(double edge, double16 x);
2558-#endif //cl_khr_fp64
2559+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2560 #ifdef cl_khr_fp16
2561 half __ovld __cnfn step(half edge, half x);
2562 half2 __ovld __cnfn step(half2 edge, half2 x);
2563@@ -10383,7 +10396,7 @@ float3 __ovld __cnfn smoothstep(float edge0, float edge1, float3 x);
2564 float4 __ovld __cnfn smoothstep(float edge0, float edge1, float4 x);
2565 float8 __ovld __cnfn smoothstep(float edge0, float edge1, float8 x);
2566 float16 __ovld __cnfn smoothstep(float edge0, float edge1, float16 x);
2567-#ifdef cl_khr_fp64
2568+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2569 double __ovld __cnfn smoothstep(double edge0, double edge1, double x);
2570 double2 __ovld __cnfn smoothstep(double2 edge0, double2 edge1, double2 x);
2571 double3 __ovld __cnfn smoothstep(double3 edge0, double3 edge1, double3 x);
2572@@ -10395,7 +10408,7 @@ double3 __ovld __cnfn smoothstep(double edge0, double edge1, double3 x);
2573 double4 __ovld __cnfn smoothstep(double edge0, double edge1, double4 x);
2574 double8 __ovld __cnfn smoothstep(double edge0, double edge1, double8 x);
2575 double16 __ovld __cnfn smoothstep(double edge0, double edge1, double16 x);
2576-#endif //cl_khr_fp64
2577+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2578 #ifdef cl_khr_fp16
2579 half __ovld __cnfn smoothstep(half edge0, half edge1, half x);
2580 half2 __ovld __cnfn smoothstep(half2 edge0, half2 edge1, half2 x);
2581@@ -10420,14 +10433,14 @@ float3 __ovld __cnfn sign(float3 x);
2582 float4 __ovld __cnfn sign(float4 x);
2583 float8 __ovld __cnfn sign(float8 x);
2584 float16 __ovld __cnfn sign(float16 x);
2585-#ifdef cl_khr_fp64
2586+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2587 double __ovld __cnfn sign(double x);
2588 double2 __ovld __cnfn sign(double2 x);
2589 double3 __ovld __cnfn sign(double3 x);
2590 double4 __ovld __cnfn sign(double4 x);
2591 double8 __ovld __cnfn sign(double8 x);
2592 double16 __ovld __cnfn sign(double16 x);
2593-#endif //cl_khr_fp64
2594+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2595 #ifdef cl_khr_fp16
2596 half __ovld __cnfn sign(half x);
2597 half2 __ovld __cnfn sign(half2 x);
2598@@ -10445,10 +10458,10 @@ half16 __ovld __cnfn sign(half16 x);
2599 */
2600 float4 __ovld __cnfn cross(float4 p0, float4 p1);
2601 float3 __ovld __cnfn cross(float3 p0, float3 p1);
2602-#ifdef cl_khr_fp64
2603+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2604 double4 __ovld __cnfn cross(double4 p0, double4 p1);
2605 double3 __ovld __cnfn cross(double3 p0, double3 p1);
2606-#endif //cl_khr_fp64
2607+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2608 #ifdef cl_khr_fp16
2609 half4 __ovld __cnfn cross(half4 p0, half4 p1);
2610 half3 __ovld __cnfn cross(half3 p0, half3 p1);
2611@@ -10461,12 +10474,12 @@ float __ovld __cnfn dot(float p0, float p1);
2612 float __ovld __cnfn dot(float2 p0, float2 p1);
2613 float __ovld __cnfn dot(float3 p0, float3 p1);
2614 float __ovld __cnfn dot(float4 p0, float4 p1);
2615-#ifdef cl_khr_fp64
2616+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2617 double __ovld __cnfn dot(double p0, double p1);
2618 double __ovld __cnfn dot(double2 p0, double2 p1);
2619 double __ovld __cnfn dot(double3 p0, double3 p1);
2620 double __ovld __cnfn dot(double4 p0, double4 p1);
2621-#endif //cl_khr_fp64
2622+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2623 #ifdef cl_khr_fp16
2624 half __ovld __cnfn dot(half p0, half p1);
2625 half __ovld __cnfn dot(half2 p0, half2 p1);
2626@@ -10482,12 +10495,12 @@ float __ovld __cnfn distance(float p0, float p1);
2627 float __ovld __cnfn distance(float2 p0, float2 p1);
2628 float __ovld __cnfn distance(float3 p0, float3 p1);
2629 float __ovld __cnfn distance(float4 p0, float4 p1);
2630-#ifdef cl_khr_fp64
2631+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2632 double __ovld __cnfn distance(double p0, double p1);
2633 double __ovld __cnfn distance(double2 p0, double2 p1);
2634 double __ovld __cnfn distance(double3 p0, double3 p1);
2635 double __ovld __cnfn distance(double4 p0, double4 p1);
2636-#endif //cl_khr_fp64
2637+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2638 #ifdef cl_khr_fp16
2639 half __ovld __cnfn distance(half p0, half p1);
2640 half __ovld __cnfn distance(half2 p0, half2 p1);
2641@@ -10503,12 +10516,12 @@ float __ovld __cnfn length(float p);
2642 float __ovld __cnfn length(float2 p);
2643 float __ovld __cnfn length(float3 p);
2644 float __ovld __cnfn length(float4 p);
2645-#ifdef cl_khr_fp64
2646+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2647 double __ovld __cnfn length(double p);
2648 double __ovld __cnfn length(double2 p);
2649 double __ovld __cnfn length(double3 p);
2650 double __ovld __cnfn length(double4 p);
2651-#endif //cl_khr_fp64
2652+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2653 #ifdef cl_khr_fp16
2654 half __ovld __cnfn length(half p);
2655 half __ovld __cnfn length(half2 p);
2656@@ -10524,12 +10537,12 @@ float __ovld __cnfn normalize(float p);
2657 float2 __ovld __cnfn normalize(float2 p);
2658 float3 __ovld __cnfn normalize(float3 p);
2659 float4 __ovld __cnfn normalize(float4 p);
2660-#ifdef cl_khr_fp64
2661+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2662 double __ovld __cnfn normalize(double p);
2663 double2 __ovld __cnfn normalize(double2 p);
2664 double3 __ovld __cnfn normalize(double3 p);
2665 double4 __ovld __cnfn normalize(double4 p);
2666-#endif //cl_khr_fp64
2667+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2668 #ifdef cl_khr_fp16
2669 half __ovld __cnfn normalize(half p);
2670 half2 __ovld __cnfn normalize(half2 p);
2671@@ -10610,14 +10623,14 @@ int3 __ovld __cnfn isequal(float3 x, float3 y);
2672 int4 __ovld __cnfn isequal(float4 x, float4 y);
2673 int8 __ovld __cnfn isequal(float8 x, float8 y);
2674 int16 __ovld __cnfn isequal(float16 x, float16 y);
2675-#ifdef cl_khr_fp64
2676+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2677 int __ovld __cnfn isequal(double x, double y);
2678 long2 __ovld __cnfn isequal(double2 x, double2 y);
2679 long3 __ovld __cnfn isequal(double3 x, double3 y);
2680 long4 __ovld __cnfn isequal(double4 x, double4 y);
2681 long8 __ovld __cnfn isequal(double8 x, double8 y);
2682 long16 __ovld __cnfn isequal(double16 x, double16 y);
2683-#endif //cl_khr_fp64
2684+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2685 #ifdef cl_khr_fp16
2686 int __ovld __cnfn isequal(half x, half y);
2687 short2 __ovld __cnfn isequal(half2 x, half2 y);
2688@@ -10636,14 +10649,14 @@ int3 __ovld __cnfn isnotequal(float3 x, float3 y);
2689 int4 __ovld __cnfn isnotequal(float4 x, float4 y);
2690 int8 __ovld __cnfn isnotequal(float8 x, float8 y);
2691 int16 __ovld __cnfn isnotequal(float16 x, float16 y);
2692-#ifdef cl_khr_fp64
2693+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2694 int __ovld __cnfn isnotequal(double x, double y);
2695 long2 __ovld __cnfn isnotequal(double2 x, double2 y);
2696 long3 __ovld __cnfn isnotequal(double3 x, double3 y);
2697 long4 __ovld __cnfn isnotequal(double4 x, double4 y);
2698 long8 __ovld __cnfn isnotequal(double8 x, double8 y);
2699 long16 __ovld __cnfn isnotequal(double16 x, double16 y);
2700-#endif //cl_khr_fp64
2701+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2702 #ifdef cl_khr_fp16
2703 int __ovld __cnfn isnotequal(half x, half y);
2704 short2 __ovld __cnfn isnotequal(half2 x, half2 y);
2705@@ -10662,14 +10675,14 @@ int3 __ovld __cnfn isgreater(float3 x, float3 y);
2706 int4 __ovld __cnfn isgreater(float4 x, float4 y);
2707 int8 __ovld __cnfn isgreater(float8 x, float8 y);
2708 int16 __ovld __cnfn isgreater(float16 x, float16 y);
2709-#ifdef cl_khr_fp64
2710+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2711 int __ovld __cnfn isgreater(double x, double y);
2712 long2 __ovld __cnfn isgreater(double2 x, double2 y);
2713 long3 __ovld __cnfn isgreater(double3 x, double3 y);
2714 long4 __ovld __cnfn isgreater(double4 x, double4 y);
2715 long8 __ovld __cnfn isgreater(double8 x, double8 y);
2716 long16 __ovld __cnfn isgreater(double16 x, double16 y);
2717-#endif //cl_khr_fp64
2718+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2719 #ifdef cl_khr_fp16
2720 int __ovld __cnfn isgreater(half x, half y);
2721 short2 __ovld __cnfn isgreater(half2 x, half2 y);
2722@@ -10688,14 +10701,14 @@ int3 __ovld __cnfn isgreaterequal(float3 x, float3 y);
2723 int4 __ovld __cnfn isgreaterequal(float4 x, float4 y);
2724 int8 __ovld __cnfn isgreaterequal(float8 x, float8 y);
2725 int16 __ovld __cnfn isgreaterequal(float16 x, float16 y);
2726-#ifdef cl_khr_fp64
2727+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2728 int __ovld __cnfn isgreaterequal(double x, double y);
2729 long2 __ovld __cnfn isgreaterequal(double2 x, double2 y);
2730 long3 __ovld __cnfn isgreaterequal(double3 x, double3 y);
2731 long4 __ovld __cnfn isgreaterequal(double4 x, double4 y);
2732 long8 __ovld __cnfn isgreaterequal(double8 x, double8 y);
2733 long16 __ovld __cnfn isgreaterequal(double16 x, double16 y);
2734-#endif //cl_khr_fp64
2735+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2736 #ifdef cl_khr_fp16
2737 int __ovld __cnfn isgreaterequal(half x, half y);
2738 short2 __ovld __cnfn isgreaterequal(half2 x, half2 y);
2739@@ -10714,14 +10727,14 @@ int3 __ovld __cnfn isless(float3 x, float3 y);
2740 int4 __ovld __cnfn isless(float4 x, float4 y);
2741 int8 __ovld __cnfn isless(float8 x, float8 y);
2742 int16 __ovld __cnfn isless(float16 x, float16 y);
2743-#ifdef cl_khr_fp64
2744+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2745 int __ovld __cnfn isless(double x, double y);
2746 long2 __ovld __cnfn isless(double2 x, double2 y);
2747 long3 __ovld __cnfn isless(double3 x, double3 y);
2748 long4 __ovld __cnfn isless(double4 x, double4 y);
2749 long8 __ovld __cnfn isless(double8 x, double8 y);
2750 long16 __ovld __cnfn isless(double16 x, double16 y);
2751-#endif //cl_khr_fp64
2752+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2753 #ifdef cl_khr_fp16
2754 int __ovld __cnfn isless(half x, half y);
2755 short2 __ovld __cnfn isless(half2 x, half2 y);
2756@@ -10740,14 +10753,14 @@ int3 __ovld __cnfn islessequal(float3 x, float3 y);
2757 int4 __ovld __cnfn islessequal(float4 x, float4 y);
2758 int8 __ovld __cnfn islessequal(float8 x, float8 y);
2759 int16 __ovld __cnfn islessequal(float16 x, float16 y);
2760-#ifdef cl_khr_fp64
2761+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2762 int __ovld __cnfn islessequal(double x, double y);
2763 long2 __ovld __cnfn islessequal(double2 x, double2 y);
2764 long3 __ovld __cnfn islessequal(double3 x, double3 y);
2765 long4 __ovld __cnfn islessequal(double4 x, double4 y);
2766 long8 __ovld __cnfn islessequal(double8 x, double8 y);
2767 long16 __ovld __cnfn islessequal(double16 x, double16 y);
2768-#endif //cl_khr_fp64
2769+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2770 #ifdef cl_khr_fp16
2771 int __ovld __cnfn islessequal(half x, half y);
2772 short2 __ovld __cnfn islessequal(half2 x, half2 y);
2773@@ -10767,14 +10780,14 @@ int3 __ovld __cnfn islessgreater(float3 x, float3 y);
2774 int4 __ovld __cnfn islessgreater(float4 x, float4 y);
2775 int8 __ovld __cnfn islessgreater(float8 x, float8 y);
2776 int16 __ovld __cnfn islessgreater(float16 x, float16 y);
2777-#ifdef cl_khr_fp64
2778+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2779 int __ovld __cnfn islessgreater(double x, double y);
2780 long2 __ovld __cnfn islessgreater(double2 x, double2 y);
2781 long3 __ovld __cnfn islessgreater(double3 x, double3 y);
2782 long4 __ovld __cnfn islessgreater(double4 x, double4 y);
2783 long8 __ovld __cnfn islessgreater(double8 x, double8 y);
2784 long16 __ovld __cnfn islessgreater(double16 x, double16 y);
2785-#endif //cl_khr_fp64
2786+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2787 #ifdef cl_khr_fp16
2788 int __ovld __cnfn islessgreater(half x, half y);
2789 short2 __ovld __cnfn islessgreater(half2 x, half2 y);
2790@@ -10793,14 +10806,14 @@ int3 __ovld __cnfn isfinite(float3);
2791 int4 __ovld __cnfn isfinite(float4);
2792 int8 __ovld __cnfn isfinite(float8);
2793 int16 __ovld __cnfn isfinite(float16);
2794-#ifdef cl_khr_fp64
2795+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2796 int __ovld __cnfn isfinite(double);
2797 long2 __ovld __cnfn isfinite(double2);
2798 long3 __ovld __cnfn isfinite(double3);
2799 long4 __ovld __cnfn isfinite(double4);
2800 long8 __ovld __cnfn isfinite(double8);
2801 long16 __ovld __cnfn isfinite(double16);
2802-#endif //cl_khr_fp64
2803+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2804 #ifdef cl_khr_fp16
2805 int __ovld __cnfn isfinite(half);
2806 short2 __ovld __cnfn isfinite(half2);
2807@@ -10819,14 +10832,14 @@ int3 __ovld __cnfn isinf(float3);
2808 int4 __ovld __cnfn isinf(float4);
2809 int8 __ovld __cnfn isinf(float8);
2810 int16 __ovld __cnfn isinf(float16);
2811-#ifdef cl_khr_fp64
2812+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2813 int __ovld __cnfn isinf(double);
2814 long2 __ovld __cnfn isinf(double2);
2815 long3 __ovld __cnfn isinf(double3);
2816 long4 __ovld __cnfn isinf(double4);
2817 long8 __ovld __cnfn isinf(double8);
2818 long16 __ovld __cnfn isinf(double16);
2819-#endif //cl_khr_fp64
2820+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2821 #ifdef cl_khr_fp16
2822 int __ovld __cnfn isinf(half);
2823 short2 __ovld __cnfn isinf(half2);
2824@@ -10845,14 +10858,14 @@ int3 __ovld __cnfn isnan(float3);
2825 int4 __ovld __cnfn isnan(float4);
2826 int8 __ovld __cnfn isnan(float8);
2827 int16 __ovld __cnfn isnan(float16);
2828-#ifdef cl_khr_fp64
2829+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2830 int __ovld __cnfn isnan(double);
2831 long2 __ovld __cnfn isnan(double2);
2832 long3 __ovld __cnfn isnan(double3);
2833 long4 __ovld __cnfn isnan(double4);
2834 long8 __ovld __cnfn isnan(double8);
2835 long16 __ovld __cnfn isnan(double16);
2836-#endif //cl_khr_fp64
2837+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2838 #ifdef cl_khr_fp16
2839 int __ovld __cnfn isnan(half);
2840 short2 __ovld __cnfn isnan(half2);
2841@@ -10871,14 +10884,14 @@ int3 __ovld __cnfn isnormal(float3);
2842 int4 __ovld __cnfn isnormal(float4);
2843 int8 __ovld __cnfn isnormal(float8);
2844 int16 __ovld __cnfn isnormal(float16);
2845-#ifdef cl_khr_fp64
2846+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2847 int __ovld __cnfn isnormal(double);
2848 long2 __ovld __cnfn isnormal(double2);
2849 long3 __ovld __cnfn isnormal(double3);
2850 long4 __ovld __cnfn isnormal(double4);
2851 long8 __ovld __cnfn isnormal(double8);
2852 long16 __ovld __cnfn isnormal(double16);
2853-#endif //cl_khr_fp64
2854+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2855 #ifdef cl_khr_fp16
2856 int __ovld __cnfn isnormal(half);
2857 short2 __ovld __cnfn isnormal(half2);
2858@@ -10899,14 +10912,14 @@ int3 __ovld __cnfn isordered(float3 x, float3 y);
2859 int4 __ovld __cnfn isordered(float4 x, float4 y);
2860 int8 __ovld __cnfn isordered(float8 x, float8 y);
2861 int16 __ovld __cnfn isordered(float16 x, float16 y);
2862-#ifdef cl_khr_fp64
2863+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2864 int __ovld __cnfn isordered(double x, double y);
2865 long2 __ovld __cnfn isordered(double2 x, double2 y);
2866 long3 __ovld __cnfn isordered(double3 x, double3 y);
2867 long4 __ovld __cnfn isordered(double4 x, double4 y);
2868 long8 __ovld __cnfn isordered(double8 x, double8 y);
2869 long16 __ovld __cnfn isordered(double16 x, double16 y);
2870-#endif //cl_khr_fp64
2871+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2872 #ifdef cl_khr_fp16
2873 int __ovld __cnfn isordered(half x, half y);
2874 short2 __ovld __cnfn isordered(half2 x, half2 y);
2875@@ -10927,14 +10940,14 @@ int3 __ovld __cnfn isunordered(float3 x, float3 y);
2876 int4 __ovld __cnfn isunordered(float4 x, float4 y);
2877 int8 __ovld __cnfn isunordered(float8 x, float8 y);
2878 int16 __ovld __cnfn isunordered(float16 x, float16 y);
2879-#ifdef cl_khr_fp64
2880+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2881 int __ovld __cnfn isunordered(double x, double y);
2882 long2 __ovld __cnfn isunordered(double2 x, double2 y);
2883 long3 __ovld __cnfn isunordered(double3 x, double3 y);
2884 long4 __ovld __cnfn isunordered(double4 x, double4 y);
2885 long8 __ovld __cnfn isunordered(double8 x, double8 y);
2886 long16 __ovld __cnfn isunordered(double16 x, double16 y);
2887-#endif //cl_khr_fp64
2888+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2889 #ifdef cl_khr_fp16
2890 int __ovld __cnfn isunordered(half x, half y);
2891 short2 __ovld __cnfn isunordered(half2 x, half2 y);
2892@@ -10957,14 +10970,14 @@ int3 __ovld __cnfn signbit(float3);
2893 int4 __ovld __cnfn signbit(float4);
2894 int8 __ovld __cnfn signbit(float8);
2895 int16 __ovld __cnfn signbit(float16);
2896-#ifdef cl_khr_fp64
2897+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2898 int __ovld __cnfn signbit(double);
2899 long2 __ovld __cnfn signbit(double2);
2900 long3 __ovld __cnfn signbit(double3);
2901 long4 __ovld __cnfn signbit(double4);
2902 long8 __ovld __cnfn signbit(double8);
2903 long16 __ovld __cnfn signbit(double16);
2904-#endif //cl_khr_fp64
2905+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2906 #ifdef cl_khr_fp16
2907 int __ovld __cnfn signbit(half);
2908 short2 __ovld __cnfn signbit(half2);
2909@@ -11091,14 +11104,14 @@ float3 __ovld __cnfn bitselect(float3 a, float3 b, float3 c);
2910 float4 __ovld __cnfn bitselect(float4 a, float4 b, float4 c);
2911 float8 __ovld __cnfn bitselect(float8 a, float8 b, float8 c);
2912 float16 __ovld __cnfn bitselect(float16 a, float16 b, float16 c);
2913-#ifdef cl_khr_fp64
2914+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2915 double __ovld __cnfn bitselect(double a, double b, double c);
2916 double2 __ovld __cnfn bitselect(double2 a, double2 b, double2 c);
2917 double3 __ovld __cnfn bitselect(double3 a, double3 b, double3 c);
2918 double4 __ovld __cnfn bitselect(double4 a, double4 b, double4 c);
2919 double8 __ovld __cnfn bitselect(double8 a, double8 b, double8 c);
2920 double16 __ovld __cnfn bitselect(double16 a, double16 b, double16 c);
2921-#endif //cl_khr_fp64
2922+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2923 #ifdef cl_khr_fp16
2924 half __ovld __cnfn bitselect(half a, half b, half c);
2925 half2 __ovld __cnfn bitselect(half2 a, half2 b, half2 c);
2926@@ -11231,7 +11244,7 @@ ulong8 __ovld __cnfn select(ulong8 a, ulong8 b, ulong8 c);
2927 long16 __ovld __cnfn select(long16 a, long16 b, ulong16 c);
2928 ulong16 __ovld __cnfn select(ulong16 a, ulong16 b, ulong16 c);
2929
2930-#ifdef cl_khr_fp64
2931+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2932 double __ovld __cnfn select(double a, double b, long c);
2933 double2 __ovld __cnfn select(double2 a, double2 b, long2 c);
2934 double3 __ovld __cnfn select(double3 a, double3 b, long3 c);
2935@@ -11244,7 +11257,7 @@ double3 __ovld __cnfn select(double3 a, double3 b, ulong3 c);
2936 double4 __ovld __cnfn select(double4 a, double4 b, ulong4 c);
2937 double8 __ovld __cnfn select(double8 a, double8 b, ulong8 c);
2938 double16 __ovld __cnfn select(double16 a, double16 b, ulong16 c);
2939-#endif //cl_khr_fp64
2940+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2941 #ifdef cl_khr_fp16
2942 half __ovld __cnfn select(half a, half b, short c);
2943 half2 __ovld __cnfn select(half2 a, half2 b, short2 c);
2944@@ -11323,13 +11336,13 @@ uint16 __ovld vload16(size_t offset, const __constant uint *p);
2945 long16 __ovld vload16(size_t offset, const __constant long *p);
2946 ulong16 __ovld vload16(size_t offset, const __constant ulong *p);
2947 float16 __ovld vload16(size_t offset, const __constant float *p);
2948-#ifdef cl_khr_fp64
2949+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2950 double2 __ovld vload2(size_t offset, const __constant double *p);
2951 double3 __ovld vload3(size_t offset, const __constant double *p);
2952 double4 __ovld vload4(size_t offset, const __constant double *p);
2953 double8 __ovld vload8(size_t offset, const __constant double *p);
2954 double16 __ovld vload16(size_t offset, const __constant double *p);
2955-#endif //cl_khr_fp64
2956+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2957
2958 #ifdef cl_khr_fp16
2959 half __ovld vload(size_t offset, const __constant half *p);
2960@@ -11340,7 +11353,7 @@ half8 __ovld vload8(size_t offset, const __constant half *p);
2961 half16 __ovld vload16(size_t offset, const __constant half *p);
2962 #endif //cl_khr_fp16
2963
2964-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
2965+#ifdef __opencl_c_generic_address_space
2966 char2 __ovld vload2(size_t offset, const char *p);
2967 uchar2 __ovld vload2(size_t offset, const uchar *p);
2968 short2 __ovld vload2(size_t offset, const short *p);
2969@@ -11387,13 +11400,13 @@ long16 __ovld vload16(size_t offset, const long *p);
2970 ulong16 __ovld vload16(size_t offset, const ulong *p);
2971 float16 __ovld vload16(size_t offset, const float *p);
2972
2973-#ifdef cl_khr_fp64
2974+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2975 double2 __ovld vload2(size_t offset, const double *p);
2976 double3 __ovld vload3(size_t offset, const double *p);
2977 double4 __ovld vload4(size_t offset, const double *p);
2978 double8 __ovld vload8(size_t offset, const double *p);
2979 double16 __ovld vload16(size_t offset, const double *p);
2980-#endif //cl_khr_fp64
2981+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
2982
2983 #ifdef cl_khr_fp16
2984 half __ovld vload(size_t offset, const half *p);
2985@@ -11403,7 +11416,7 @@ half4 __ovld vload4(size_t offset, const half *p);
2986 half8 __ovld vload8(size_t offset, const half *p);
2987 half16 __ovld vload16(size_t offset, const half *p);
2988 #endif //cl_khr_fp16
2989-#else
2990+#endif //__opencl_c_generic_address_space
2991 char2 __ovld vload2(size_t offset, const __global char *p);
2992 uchar2 __ovld vload2(size_t offset, const __global uchar *p);
2993 short2 __ovld vload2(size_t offset, const __global short *p);
2994@@ -11540,7 +11553,7 @@ long16 __ovld vload16(size_t offset, const __private long *p);
2995 ulong16 __ovld vload16(size_t offset, const __private ulong *p);
2996 float16 __ovld vload16(size_t offset, const __private float *p);
2997
2998-#ifdef cl_khr_fp64
2999+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3000 double2 __ovld vload2(size_t offset, const __global double *p);
3001 double3 __ovld vload3(size_t offset, const __global double *p);
3002 double4 __ovld vload4(size_t offset, const __global double *p);
3003@@ -11556,7 +11569,7 @@ double3 __ovld vload3(size_t offset, const __private double *p);
3004 double4 __ovld vload4(size_t offset, const __private double *p);
3005 double8 __ovld vload8(size_t offset, const __private double *p);
3006 double16 __ovld vload16(size_t offset, const __private double *p);
3007-#endif //cl_khr_fp64
3008+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3009
3010 #ifdef cl_khr_fp16
3011 half __ovld vload(size_t offset, const __global half *p);
3012@@ -11578,9 +11591,8 @@ half4 __ovld vload4(size_t offset, const __private half *p);
3013 half8 __ovld vload8(size_t offset, const __private half *p);
3014 half16 __ovld vload16(size_t offset, const __private half *p);
3015 #endif //cl_khr_fp16
3016-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3017
3018-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3019+#ifdef __opencl_c_generic_address_space
3020 void __ovld vstore2(char2 data, size_t offset, char *p);
3021 void __ovld vstore2(uchar2 data, size_t offset, uchar *p);
3022 void __ovld vstore2(short2 data, size_t offset, short *p);
3023@@ -11626,13 +11638,13 @@ void __ovld vstore16(uint16 data, size_t offset, uint *p);
3024 void __ovld vstore16(long16 data, size_t offset, long *p);
3025 void __ovld vstore16(ulong16 data, size_t offset, ulong *p);
3026 void __ovld vstore16(float16 data, size_t offset, float *p);
3027-#ifdef cl_khr_fp64
3028+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3029 void __ovld vstore2(double2 data, size_t offset, double *p);
3030 void __ovld vstore3(double3 data, size_t offset, double *p);
3031 void __ovld vstore4(double4 data, size_t offset, double *p);
3032 void __ovld vstore8(double8 data, size_t offset, double *p);
3033 void __ovld vstore16(double16 data, size_t offset, double *p);
3034-#endif //cl_khr_fp64
3035+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3036 #ifdef cl_khr_fp16
3037 void __ovld vstore(half data, size_t offset, half *p);
3038 void __ovld vstore2(half2 data, size_t offset, half *p);
3039@@ -11641,7 +11653,7 @@ void __ovld vstore4(half4 data, size_t offset, half *p);
3040 void __ovld vstore8(half8 data, size_t offset, half *p);
3041 void __ovld vstore16(half16 data, size_t offset, half *p);
3042 #endif //cl_khr_fp16
3043-#else
3044+#endif //__opencl_c_generic_address_space
3045 void __ovld vstore2(char2 data, size_t offset, __global char *p);
3046 void __ovld vstore2(uchar2 data, size_t offset, __global uchar *p);
3047 void __ovld vstore2(short2 data, size_t offset, __global short *p);
3048@@ -11777,7 +11789,7 @@ void __ovld vstore16(uint16 data, size_t offset, __private uint *p);
3049 void __ovld vstore16(long16 data, size_t offset, __private long *p);
3050 void __ovld vstore16(ulong16 data, size_t offset, __private ulong *p);
3051 void __ovld vstore16(float16 data, size_t offset, __private float *p);
3052-#ifdef cl_khr_fp64
3053+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3054 void __ovld vstore2(double2 data, size_t offset, __global double *p);
3055 void __ovld vstore3(double3 data, size_t offset, __global double *p);
3056 void __ovld vstore4(double4 data, size_t offset, __global double *p);
3057@@ -11793,7 +11805,7 @@ void __ovld vstore3(double3 data, size_t offset, __private double *p);
3058 void __ovld vstore4(double4 data, size_t offset, __private double *p);
3059 void __ovld vstore8(double8 data, size_t offset, __private double *p);
3060 void __ovld vstore16(double16 data, size_t offset, __private double *p);
3061-#endif //cl_khr_fp64
3062+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3063 #ifdef cl_khr_fp16
3064 void __ovld vstore(half data, size_t offset, __global half *p);
3065 void __ovld vstore2(half2 data, size_t offset, __global half *p);
3066@@ -11814,7 +11826,6 @@ void __ovld vstore4(half4 data, size_t offset, __private half *p);
3067 void __ovld vstore8(half8 data, size_t offset, __private half *p);
3068 void __ovld vstore16(half16 data, size_t offset, __private half *p);
3069 #endif //cl_khr_fp16
3070-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3071
3072 /**
3073 * Read sizeof (half) bytes of data from address
3074@@ -11825,13 +11836,12 @@ void __ovld vstore16(half16 data, size_t offset, __private half *p);
3075 * must be 16-bit aligned.
3076 */
3077 float __ovld vload_half(size_t offset, const __constant half *p);
3078-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3079+#ifdef __opencl_c_generic_address_space
3080 float __ovld vload_half(size_t offset, const half *p);
3081-#else
3082+#endif //__opencl_c_generic_address_space
3083 float __ovld vload_half(size_t offset, const __global half *p);
3084 float __ovld vload_half(size_t offset, const __local half *p);
3085 float __ovld vload_half(size_t offset, const __private half *p);
3086-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3087
3088 /**
3089 * Read sizeof (halfn) bytes of data from address
3090@@ -11846,13 +11856,13 @@ float3 __ovld vload_half3(size_t offset, const __constant half *p);
3091 float4 __ovld vload_half4(size_t offset, const __constant half *p);
3092 float8 __ovld vload_half8(size_t offset, const __constant half *p);
3093 float16 __ovld vload_half16(size_t offset, const __constant half *p);
3094-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3095+#ifdef __opencl_c_generic_address_space
3096 float2 __ovld vload_half2(size_t offset, const half *p);
3097 float3 __ovld vload_half3(size_t offset, const half *p);
3098 float4 __ovld vload_half4(size_t offset, const half *p);
3099 float8 __ovld vload_half8(size_t offset, const half *p);
3100 float16 __ovld vload_half16(size_t offset, const half *p);
3101-#else
3102+#endif //__opencl_c_generic_address_space
3103 float2 __ovld vload_half2(size_t offset, const __global half *p);
3104 float3 __ovld vload_half3(size_t offset, const __global half *p);
3105 float4 __ovld vload_half4(size_t offset, const __global half *p);
3106@@ -11868,7 +11878,6 @@ float3 __ovld vload_half3(size_t offset, const __private half *p);
3107 float4 __ovld vload_half4(size_t offset, const __private half *p);
3108 float8 __ovld vload_half8(size_t offset, const __private half *p);
3109 float16 __ovld vload_half16(size_t offset, const __private half *p);
3110-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3111
3112 /**
3113 * The float value given by data is first
3114@@ -11881,20 +11890,20 @@ float16 __ovld vload_half16(size_t offset, const __private half *p);
3115 * The default current rounding mode is round to
3116 * nearest even.
3117 */
3118-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3119+#ifdef __opencl_c_generic_address_space
3120 void __ovld vstore_half(float data, size_t offset, half *p);
3121 void __ovld vstore_half_rte(float data, size_t offset, half *p);
3122 void __ovld vstore_half_rtz(float data, size_t offset, half *p);
3123 void __ovld vstore_half_rtp(float data, size_t offset, half *p);
3124 void __ovld vstore_half_rtn(float data, size_t offset, half *p);
3125-#ifdef cl_khr_fp64
3126+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3127 void __ovld vstore_half(double data, size_t offset, half *p);
3128 void __ovld vstore_half_rte(double data, size_t offset, half *p);
3129 void __ovld vstore_half_rtz(double data, size_t offset, half *p);
3130 void __ovld vstore_half_rtp(double data, size_t offset, half *p);
3131 void __ovld vstore_half_rtn(double data, size_t offset, half *p);
3132-#endif //cl_khr_fp64
3133-#else
3134+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3135+#endif //__opencl_c_generic_address_space
3136 void __ovld vstore_half(float data, size_t offset, __global half *p);
3137 void __ovld vstore_half_rte(float data, size_t offset, __global half *p);
3138 void __ovld vstore_half_rtz(float data, size_t offset, __global half *p);
3139@@ -11910,7 +11919,7 @@ void __ovld vstore_half_rte(float data, size_t offset, __private half *p);
3140 void __ovld vstore_half_rtz(float data, size_t offset, __private half *p);
3141 void __ovld vstore_half_rtp(float data, size_t offset, __private half *p);
3142 void __ovld vstore_half_rtn(float data, size_t offset, __private half *p);
3143-#ifdef cl_khr_fp64
3144+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3145 void __ovld vstore_half(double data, size_t offset, __global half *p);
3146 void __ovld vstore_half_rte(double data, size_t offset, __global half *p);
3147 void __ovld vstore_half_rtz(double data, size_t offset, __global half *p);
3148@@ -11926,8 +11935,7 @@ void __ovld vstore_half_rte(double data, size_t offset, __private half *p);
3149 void __ovld vstore_half_rtz(double data, size_t offset, __private half *p);
3150 void __ovld vstore_half_rtp(double data, size_t offset, __private half *p);
3151 void __ovld vstore_half_rtn(double data, size_t offset, __private half *p);
3152-#endif //cl_khr_fp64
3153-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3154+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3155
3156 /**
3157 * The floatn value given by data is converted to
3158@@ -11940,7 +11948,7 @@ void __ovld vstore_half_rtn(double data, size_t offset, __private half *p);
3159 * The default current rounding mode is round to
3160 * nearest even.
3161 */
3162-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3163+#ifdef __opencl_c_generic_address_space
3164 void __ovld vstore_half2(float2 data, size_t offset, half *p);
3165 void __ovld vstore_half3(float3 data, size_t offset, half *p);
3166 void __ovld vstore_half4(float4 data, size_t offset, half *p);
3167@@ -11966,7 +11974,7 @@ void __ovld vstore_half3_rtn(float3 data, size_t offset, half *p);
3168 void __ovld vstore_half4_rtn(float4 data, size_t offset, half *p);
3169 void __ovld vstore_half8_rtn(float8 data, size_t offset, half *p);
3170 void __ovld vstore_half16_rtn(float16 data, size_t offset, half *p);
3171-#ifdef cl_khr_fp64
3172+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3173 void __ovld vstore_half2(double2 data, size_t offset, half *p);
3174 void __ovld vstore_half3(double3 data, size_t offset, half *p);
3175 void __ovld vstore_half4(double4 data, size_t offset, half *p);
3176@@ -11992,8 +12000,8 @@ void __ovld vstore_half3_rtn(double3 data, size_t offset, half *p);
3177 void __ovld vstore_half4_rtn(double4 data, size_t offset, half *p);
3178 void __ovld vstore_half8_rtn(double8 data, size_t offset, half *p);
3179 void __ovld vstore_half16_rtn(double16 data, size_t offset, half *p);
3180-#endif //cl_khr_fp64
3181-#else
3182+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3183+#endif //__opencl_c_generic_address_space
3184 void __ovld vstore_half2(float2 data, size_t offset, __global half *p);
3185 void __ovld vstore_half3(float3 data, size_t offset, __global half *p);
3186 void __ovld vstore_half4(float4 data, size_t offset, __global half *p);
3187@@ -12069,7 +12077,7 @@ void __ovld vstore_half3_rtn(float3 data, size_t offset, __private half *p);
3188 void __ovld vstore_half4_rtn(float4 data, size_t offset, __private half *p);
3189 void __ovld vstore_half8_rtn(float8 data, size_t offset, __private half *p);
3190 void __ovld vstore_half16_rtn(float16 data, size_t offset, __private half *p);
3191-#ifdef cl_khr_fp64
3192+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3193 void __ovld vstore_half2(double2 data, size_t offset, __global half *p);
3194 void __ovld vstore_half3(double3 data, size_t offset, __global half *p);
3195 void __ovld vstore_half4(double4 data, size_t offset, __global half *p);
3196@@ -12145,8 +12153,7 @@ void __ovld vstore_half3_rtn(double3 data, size_t offset, __private half *p);
3197 void __ovld vstore_half4_rtn(double4 data, size_t offset, __private half *p);
3198 void __ovld vstore_half8_rtn(double8 data, size_t offset, __private half *p);
3199 void __ovld vstore_half16_rtn(double16 data, size_t offset, __private half *p);
3200-#endif //cl_khr_fp64
3201-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3202+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3203
3204 /**
3205 * For n = 1, 2, 4, 8 and 16 read sizeof (halfn)
3206@@ -12167,14 +12174,14 @@ float3 __ovld vloada_half3(size_t offset, const __constant half *p);
3207 float4 __ovld vloada_half4(size_t offset, const __constant half *p);
3208 float8 __ovld vloada_half8(size_t offset, const __constant half *p);
3209 float16 __ovld vloada_half16(size_t offset, const __constant half *p);
3210-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3211+#ifdef __opencl_c_generic_address_space
3212 float __ovld vloada_half(size_t offset, const half *p);
3213 float2 __ovld vloada_half2(size_t offset, const half *p);
3214 float3 __ovld vloada_half3(size_t offset, const half *p);
3215 float4 __ovld vloada_half4(size_t offset, const half *p);
3216 float8 __ovld vloada_half8(size_t offset, const half *p);
3217 float16 __ovld vloada_half16(size_t offset, const half *p);
3218-#else
3219+#endif //__opencl_c_generic_address_space
3220 float __ovld vloada_half(size_t offset, const __global half *p);
3221 float2 __ovld vloada_half2(size_t offset, const __global half *p);
3222 float3 __ovld vloada_half3(size_t offset, const __global half *p);
3223@@ -12193,7 +12200,6 @@ float3 __ovld vloada_half3(size_t offset, const __private half *p);
3224 float4 __ovld vloada_half4(size_t offset, const __private half *p);
3225 float8 __ovld vloada_half8(size_t offset, const __private half *p);
3226 float16 __ovld vloada_half16(size_t offset, const __private half *p);
3227-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3228
3229 /**
3230 * The floatn value given by data is converted to
3231@@ -12211,7 +12217,7 @@ float16 __ovld vloada_half16(size_t offset, const __private half *p);
3232 * mode. The default current rounding mode is
3233 * round to nearest even.
3234 */
3235-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3236+#ifdef __opencl_c_generic_address_space
3237 void __ovld vstorea_half(float data, size_t offset, half *p);
3238 void __ovld vstorea_half2(float2 data, size_t offset, half *p);
3239 void __ovld vstorea_half3(float3 data, size_t offset, half *p);
3240@@ -12247,7 +12253,7 @@ void __ovld vstorea_half4_rtn(float4 data, size_t offset, half *p);
3241 void __ovld vstorea_half8_rtn(float8 data, size_t offset, half *p);
3242 void __ovld vstorea_half16_rtn(float16 data, size_t offset, half *p);
3243
3244-#ifdef cl_khr_fp64
3245+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3246 void __ovld vstorea_half(double data, size_t offset, half *p);
3247 void __ovld vstorea_half2(double2 data, size_t offset, half *p);
3248 void __ovld vstorea_half3(double3 data, size_t offset, half *p);
3249@@ -12282,9 +12288,9 @@ void __ovld vstorea_half3_rtn(double3 data, size_t offset, half *p);
3250 void __ovld vstorea_half4_rtn(double4 data, size_t offset, half *p);
3251 void __ovld vstorea_half8_rtn(double8 data, size_t offset, half *p);
3252 void __ovld vstorea_half16_rtn(double16 data, size_t offset, half *p);
3253-#endif //cl_khr_fp64
3254+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3255+#endif //__opencl_c_generic_address_space
3256
3257-#else
3258 void __ovld vstorea_half(float data, size_t offset, __global half *p);
3259 void __ovld vstorea_half2(float2 data, size_t offset, __global half *p);
3260 void __ovld vstorea_half3(float3 data, size_t offset, __global half *p);
3261@@ -12390,7 +12396,7 @@ void __ovld vstorea_half4_rtn(float4 data, size_t offset, __private half *p);
3262 void __ovld vstorea_half8_rtn(float8 data, size_t offset, __private half *p);
3263 void __ovld vstorea_half16_rtn(float16 data, size_t offset, __private half *p);
3264
3265-#ifdef cl_khr_fp64
3266+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3267 void __ovld vstorea_half(double data, size_t offset, __global half *p);
3268 void __ovld vstorea_half2(double2 data, size_t offset, __global half *p);
3269 void __ovld vstorea_half3(double3 data, size_t offset, __global half *p);
3270@@ -12495,8 +12501,7 @@ void __ovld vstorea_half3_rtn(double3 data,size_t offset, __private half *p);
3271 void __ovld vstorea_half4_rtn(double4 data,size_t offset, __private half *p);
3272 void __ovld vstorea_half8_rtn(double8 data,size_t offset, __private half *p);
3273 void __ovld vstorea_half16_rtn(double16 data,size_t offset, __private half *p);
3274-#endif //cl_khr_fp64
3275-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3276+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3277
3278 // OpenCL v1.1 s6.11.8, v1.2 s6.12.8, v2.0 s6.13.8 - Synchronization Functions
3279
3280@@ -12580,7 +12585,7 @@ void __ovld write_mem_fence(cl_mem_fence_flags flags);
3281
3282 // OpenCL v2.0 s6.13.9 - Address Space Qualifier Functions
3283
3284-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3285+#ifdef __opencl_c_generic_address_space
3286 cl_mem_fence_flags __ovld get_fence(const void *ptr);
3287 cl_mem_fence_flags __ovld get_fence(void *ptr);
3288
3289@@ -12591,7 +12596,7 @@ cl_mem_fence_flags __ovld get_fence(void *ptr);
3290 * where gentype is builtin type or user defined type.
3291 */
3292
3293-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
3294+#endif //__opencl_c_generic_address_space
3295
3296 // OpenCL v1.1 s6.11.10, v1.2 s6.12.10, v2.0 s6.13.10 - Async Copies from Global to Local Memory, Local to Global Memory, and Prefetch
3297
3298@@ -12730,7 +12735,7 @@ event_t __ovld async_work_group_copy(__global uint16 *dst, const __local uint16
3299 event_t __ovld async_work_group_copy(__global long16 *dst, const __local long16 *src, size_t num_elements, event_t event);
3300 event_t __ovld async_work_group_copy(__global ulong16 *dst, const __local ulong16 *src, size_t num_elements, event_t event);
3301 event_t __ovld async_work_group_copy(__global float16 *dst, const __local float16 *src, size_t num_elements, event_t event);
3302-#ifdef cl_khr_fp64
3303+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3304 event_t __ovld async_work_group_copy(__local double *dst, const __global double *src, size_t num_elements, event_t event);
3305 event_t __ovld async_work_group_copy(__local double2 *dst, const __global double2 *src, size_t num_elements, event_t event);
3306 event_t __ovld async_work_group_copy(__local double3 *dst, const __global double3 *src, size_t num_elements, event_t event);
3307@@ -12743,7 +12748,7 @@ event_t __ovld async_work_group_copy(__global double3 *dst, const __local double
3308 event_t __ovld async_work_group_copy(__global double4 *dst, const __local double4 *src, size_t num_elements, event_t event);
3309 event_t __ovld async_work_group_copy(__global double8 *dst, const __local double8 *src, size_t num_elements, event_t event);
3310 event_t __ovld async_work_group_copy(__global double16 *dst, const __local double16 *src, size_t num_elements, event_t event);
3311-#endif //cl_khr_fp64
3312+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3313 #ifdef cl_khr_fp16
3314 event_t __ovld async_work_group_copy(__local half *dst, const __global half *src, size_t num_elements, event_t event);
3315 event_t __ovld async_work_group_copy(__local half2 *dst, const __global half2 *src, size_t num_elements, event_t event);
3316@@ -12893,7 +12898,7 @@ event_t __ovld async_work_group_strided_copy(__global uint16 *dst, const __local
3317 event_t __ovld async_work_group_strided_copy(__global long16 *dst, const __local long16 *src, size_t num_elements, size_t dst_stride, event_t event);
3318 event_t __ovld async_work_group_strided_copy(__global ulong16 *dst, const __local ulong16 *src, size_t num_elements, size_t dst_stride, event_t event);
3319 event_t __ovld async_work_group_strided_copy(__global float16 *dst, const __local float16 *src, size_t num_elements, size_t dst_stride, event_t event);
3320-#ifdef cl_khr_fp64
3321+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3322 event_t __ovld async_work_group_strided_copy(__local double *dst, const __global double *src, size_t num_elements, size_t src_stride, event_t event);
3323 event_t __ovld async_work_group_strided_copy(__local double2 *dst, const __global double2 *src, size_t num_elements, size_t src_stride, event_t event);
3324 event_t __ovld async_work_group_strided_copy(__local double3 *dst, const __global double3 *src, size_t num_elements, size_t src_stride, event_t event);
3325@@ -12906,7 +12911,7 @@ event_t __ovld async_work_group_strided_copy(__global double3 *dst, const __loca
3326 event_t __ovld async_work_group_strided_copy(__global double4 *dst, const __local double4 *src, size_t num_elements, size_t dst_stride, event_t event);
3327 event_t __ovld async_work_group_strided_copy(__global double8 *dst, const __local double8 *src, size_t num_elements, size_t dst_stride, event_t event);
3328 event_t __ovld async_work_group_strided_copy(__global double16 *dst, const __local double16 *src, size_t num_elements, size_t dst_stride, event_t event);
3329-#endif //cl_khr_fp64
3330+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3331 #ifdef cl_khr_fp16
3332 event_t __ovld async_work_group_strided_copy(__local half *dst, const __global half *src, size_t num_elements, size_t src_stride, event_t event);
3333 event_t __ovld async_work_group_strided_copy(__local half2 *dst, const __global half2 *src, size_t num_elements, size_t src_stride, event_t event);
3334@@ -12996,14 +13001,14 @@ void __ovld prefetch(const __global uint16 *p, size_t num_elements);
3335 void __ovld prefetch(const __global long16 *p, size_t num_elements);
3336 void __ovld prefetch(const __global ulong16 *p, size_t num_elements);
3337 void __ovld prefetch(const __global float16 *p, size_t num_elements);
3338-#ifdef cl_khr_fp64
3339+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3340 void __ovld prefetch(const __global double *p, size_t num_elements);
3341 void __ovld prefetch(const __global double2 *p, size_t num_elements);
3342 void __ovld prefetch(const __global double3 *p, size_t num_elements);
3343 void __ovld prefetch(const __global double4 *p, size_t num_elements);
3344 void __ovld prefetch(const __global double8 *p, size_t num_elements);
3345 void __ovld prefetch(const __global double16 *p, size_t num_elements);
3346-#endif //cl_khr_fp64
3347+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3348 #ifdef cl_khr_fp16
3349 void __ovld prefetch(const __global half *p, size_t num_elements);
3350 void __ovld prefetch(const __global half2 *p, size_t num_elements);
3351@@ -13026,9 +13031,11 @@ void __ovld prefetch(const __global half16 *p, size_t num_elements);
3352 * pointed by p. The function returns old.
3353 */
3354 int __ovld atomic_add(volatile __global int *p, int val);
3355-unsigned int __ovld atomic_add(volatile __global unsigned int *p, unsigned int val);
3356+unsigned int __ovld atomic_add(volatile __global unsigned int *p,
3357+ unsigned int val);
3358 int __ovld atomic_add(volatile __local int *p, int val);
3359-unsigned int __ovld atomic_add(volatile __local unsigned int *p, unsigned int val);
3360+unsigned int __ovld atomic_add(volatile __local unsigned int *p,
3361+ unsigned int val);
3362 #ifdef __OPENCL_CPP_VERSION__
3363 int __ovld atomic_add(volatile int *p, int val);
3364 unsigned int __ovld atomic_add(volatile unsigned int *p, unsigned int val);
3365@@ -13056,9 +13063,11 @@ unsigned long __ovld atom_add(volatile __local unsigned long *p, unsigned long v
3366 * returns old.
3367 */
3368 int __ovld atomic_sub(volatile __global int *p, int val);
3369-unsigned int __ovld atomic_sub(volatile __global unsigned int *p, unsigned int val);
3370+unsigned int __ovld atomic_sub(volatile __global unsigned int *p,
3371+ unsigned int val);
3372 int __ovld atomic_sub(volatile __local int *p, int val);
3373-unsigned int __ovld atomic_sub(volatile __local unsigned int *p, unsigned int val);
3374+unsigned int __ovld atomic_sub(volatile __local unsigned int *p,
3375+ unsigned int val);
3376 #ifdef __OPENCL_CPP_VERSION__
3377 int __ovld atomic_sub(volatile int *p, int val);
3378 unsigned int __ovld atomic_sub(volatile unsigned int *p, unsigned int val);
3379@@ -13086,9 +13095,11 @@ unsigned long __ovld atom_sub(volatile __local unsigned long *p, unsigned long v
3380 * value.
3381 */
3382 int __ovld atomic_xchg(volatile __global int *p, int val);
3383-unsigned int __ovld atomic_xchg(volatile __global unsigned int *p, unsigned int val);
3384+unsigned int __ovld atomic_xchg(volatile __global unsigned int *p,
3385+ unsigned int val);
3386 int __ovld atomic_xchg(volatile __local int *p, int val);
3387-unsigned int __ovld atomic_xchg(volatile __local unsigned int *p, unsigned int val);
3388+unsigned int __ovld atomic_xchg(volatile __local unsigned int *p,
3389+ unsigned int val);
3390 float __ovld atomic_xchg(volatile __global float *p, float val);
3391 float __ovld atomic_xchg(volatile __local float *p, float val);
3392 #ifdef __OPENCL_CPP_VERSION__
3393@@ -13183,12 +13194,15 @@ unsigned long __ovld atom_dec(volatile __local unsigned long *p);
3394 * returns old.
3395 */
3396 int __ovld atomic_cmpxchg(volatile __global int *p, int cmp, int val);
3397-unsigned int __ovld atomic_cmpxchg(volatile __global unsigned int *p, unsigned int cmp, unsigned int val);
3398+unsigned int __ovld atomic_cmpxchg(volatile __global unsigned int *p,
3399+ unsigned int cmp, unsigned int val);
3400 int __ovld atomic_cmpxchg(volatile __local int *p, int cmp, int val);
3401-unsigned int __ovld atomic_cmpxchg(volatile __local unsigned int *p, unsigned int cmp, unsigned int val);
3402+unsigned int __ovld atomic_cmpxchg(volatile __local unsigned int *p,
3403+ unsigned int cmp, unsigned int val);
3404 #ifdef __OPENCL_CPP_VERSION__
3405 int __ovld atomic_cmpxchg(volatile int *p, int cmp, int val);
3406-unsigned int __ovld atomic_cmpxchg(volatile unsigned int *p, unsigned int cmp, unsigned int val);
3407+unsigned int __ovld atomic_cmpxchg(volatile unsigned int *p, unsigned int cmp,
3408+ unsigned int val);
3409 #endif
3410
3411 #if defined(cl_khr_global_int32_base_atomics)
3412@@ -13215,9 +13229,11 @@ unsigned long __ovld atom_cmpxchg(volatile __local unsigned long *p, unsigned lo
3413 * returns old.
3414 */
3415 int __ovld atomic_min(volatile __global int *p, int val);
3416-unsigned int __ovld atomic_min(volatile __global unsigned int *p, unsigned int val);
3417+unsigned int __ovld atomic_min(volatile __global unsigned int *p,
3418+ unsigned int val);
3419 int __ovld atomic_min(volatile __local int *p, int val);
3420-unsigned int __ovld atomic_min(volatile __local unsigned int *p, unsigned int val);
3421+unsigned int __ovld atomic_min(volatile __local unsigned int *p,
3422+ unsigned int val);
3423 #ifdef __OPENCL_CPP_VERSION__
3424 int __ovld atomic_min(volatile int *p, int val);
3425 unsigned int __ovld atomic_min(volatile unsigned int *p, unsigned int val);
3426@@ -13247,9 +13263,11 @@ unsigned long __ovld atom_min(volatile __local unsigned long *p, unsigned long v
3427 * returns old.
3428 */
3429 int __ovld atomic_max(volatile __global int *p, int val);
3430-unsigned int __ovld atomic_max(volatile __global unsigned int *p, unsigned int val);
3431+unsigned int __ovld atomic_max(volatile __global unsigned int *p,
3432+ unsigned int val);
3433 int __ovld atomic_max(volatile __local int *p, int val);
3434-unsigned int __ovld atomic_max(volatile __local unsigned int *p, unsigned int val);
3435+unsigned int __ovld atomic_max(volatile __local unsigned int *p,
3436+ unsigned int val);
3437 #ifdef __OPENCL_CPP_VERSION__
3438 int __ovld atomic_max(volatile int *p, int val);
3439 unsigned int __ovld atomic_max(volatile unsigned int *p, unsigned int val);
3440@@ -13278,9 +13296,11 @@ unsigned long __ovld atom_max(volatile __local unsigned long *p, unsigned long v
3441 * pointed by p. The function returns old.
3442 */
3443 int __ovld atomic_and(volatile __global int *p, int val);
3444-unsigned int __ovld atomic_and(volatile __global unsigned int *p, unsigned int val);
3445+unsigned int __ovld atomic_and(volatile __global unsigned int *p,
3446+ unsigned int val);
3447 int __ovld atomic_and(volatile __local int *p, int val);
3448-unsigned int __ovld atomic_and(volatile __local unsigned int *p, unsigned int val);
3449+unsigned int __ovld atomic_and(volatile __local unsigned int *p,
3450+ unsigned int val);
3451 #ifdef __OPENCL_CPP_VERSION__
3452 int __ovld atomic_and(volatile int *p, int val);
3453 unsigned int __ovld atomic_and(volatile unsigned int *p, unsigned int val);
3454@@ -13309,9 +13329,11 @@ unsigned long __ovld atom_and(volatile __local unsigned long *p, unsigned long v
3455 * pointed by p. The function returns old.
3456 */
3457 int __ovld atomic_or(volatile __global int *p, int val);
3458-unsigned int __ovld atomic_or(volatile __global unsigned int *p, unsigned int val);
3459+unsigned int __ovld atomic_or(volatile __global unsigned int *p,
3460+ unsigned int val);
3461 int __ovld atomic_or(volatile __local int *p, int val);
3462-unsigned int __ovld atomic_or(volatile __local unsigned int *p, unsigned int val);
3463+unsigned int __ovld atomic_or(volatile __local unsigned int *p,
3464+ unsigned int val);
3465 #ifdef __OPENCL_CPP_VERSION__
3466 int __ovld atomic_or(volatile int *p, int val);
3467 unsigned int __ovld atomic_or(volatile unsigned int *p, unsigned int val);
3468@@ -13340,9 +13362,11 @@ unsigned long __ovld atom_or(volatile __local unsigned long *p, unsigned long va
3469 * pointed by p. The function returns old.
3470 */
3471 int __ovld atomic_xor(volatile __global int *p, int val);
3472-unsigned int __ovld atomic_xor(volatile __global unsigned int *p, unsigned int val);
3473+unsigned int __ovld atomic_xor(volatile __global unsigned int *p,
3474+ unsigned int val);
3475 int __ovld atomic_xor(volatile __local int *p, int val);
3476-unsigned int __ovld atomic_xor(volatile __local unsigned int *p, unsigned int val);
3477+unsigned int __ovld atomic_xor(volatile __local unsigned int *p,
3478+ unsigned int val);
3479 #ifdef __OPENCL_CPP_VERSION__
3480 int __ovld atomic_xor(volatile int *p, int val);
3481 unsigned int __ovld atomic_xor(volatile unsigned int *p, unsigned int val);
3482@@ -13380,108 +13404,78 @@ unsigned long __ovld atom_xor(volatile __local unsigned long *p, unsigned long v
3483 #endif
3484
3485 // atomic_init()
3486+#ifdef __opencl_c_generic_address_space
3487 void __ovld atomic_init(volatile atomic_int *object, int value);
3488 void __ovld atomic_init(volatile atomic_uint *object, uint value);
3489 void __ovld atomic_init(volatile atomic_float *object, float value);
3490 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
3491 void __ovld atomic_init(volatile atomic_long *object, long value);
3492 void __ovld atomic_init(volatile atomic_ulong *object, ulong value);
3493-#ifdef cl_khr_fp64
3494+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3495 void __ovld atomic_init(volatile atomic_double *object, double value);
3496-#endif //cl_khr_fp64
3497-#endif
3498+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3499+#endif // defined(cl_khr_int64_base_atomics) &&
3500+ // defined(cl_khr_int64_extended_atomics)
3501+#endif // __opencl_c_generic_address_space
3502+
3503+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
3504+void __ovld atomic_init(volatile atomic_int __global *object, int value);
3505+void __ovld atomic_init(volatile atomic_int __local *object, int value);
3506+void __ovld atomic_init(volatile atomic_uint __global *object, uint value);
3507+void __ovld atomic_init(volatile atomic_uint __local *object, uint value);
3508+void __ovld atomic_init(volatile atomic_float __global *object, float value);
3509+void __ovld atomic_init(volatile atomic_float __local *object, float value);
3510+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
3511+void __ovld atomic_init(volatile atomic_long __global *object, long value);
3512+void __ovld atomic_init(volatile atomic_long __local *object, long value);
3513+void __ovld atomic_init(volatile atomic_ulong __global *object, ulong value);
3514+void __ovld atomic_init(volatile atomic_ulong __local *object, ulong value);
3515+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
3516+void __ovld atomic_init(volatile atomic_double __global *object, double value);
3517+void __ovld atomic_init(volatile atomic_double __local *object, double value);
3518+#endif // cl_khr_fp64
3519+#endif // defined(cl_khr_int64_base_atomics) &&
3520+ // defined(cl_khr_int64_extended_atomics)
3521+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
3522
3523 // atomic_work_item_fence()
3524-void __ovld atomic_work_item_fence(cl_mem_fence_flags flags, memory_order order, memory_scope scope);
3525+void __ovld atomic_work_item_fence(cl_mem_fence_flags flags, memory_order order,
3526+ memory_scope scope);
3527
3528 // atomic_fetch()
3529-
3530+#if defined(__opencl_c_atomic_scope_device) && \
3531+ defined(__opencl_c_atomic_order_seq_cst)
3532+#ifdef __opencl_c_generic_address_space
3533 int __ovld atomic_fetch_add(volatile atomic_int *object, int operand);
3534-int __ovld atomic_fetch_add_explicit(volatile atomic_int *object, int operand, memory_order order);
3535-int __ovld atomic_fetch_add_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
3536 uint __ovld atomic_fetch_add(volatile atomic_uint *object, uint operand);
3537-uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *object, uint operand, memory_order order);
3538-uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
3539 int __ovld atomic_fetch_sub(volatile atomic_int *object, int operand);
3540-int __ovld atomic_fetch_sub_explicit(volatile atomic_int *object, int operand, memory_order order);
3541-int __ovld atomic_fetch_sub_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
3542 uint __ovld atomic_fetch_sub(volatile atomic_uint *object, uint operand);
3543-uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *object, uint operand, memory_order order);
3544-uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
3545 int __ovld atomic_fetch_or(volatile atomic_int *object, int operand);
3546-int __ovld atomic_fetch_or_explicit(volatile atomic_int *object, int operand, memory_order order);
3547-int __ovld atomic_fetch_or_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
3548 uint __ovld atomic_fetch_or(volatile atomic_uint *object, uint operand);
3549-uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *object, uint operand, memory_order order);
3550-uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
3551 int __ovld atomic_fetch_xor(volatile atomic_int *object, int operand);
3552-int __ovld atomic_fetch_xor_explicit(volatile atomic_int *object, int operand, memory_order order);
3553-int __ovld atomic_fetch_xor_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
3554 uint __ovld atomic_fetch_xor(volatile atomic_uint *object, uint operand);
3555-uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint *object, uint operand, memory_order order);
3556-uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
3557 int __ovld atomic_fetch_and(volatile atomic_int *object, int operand);
3558-int __ovld atomic_fetch_and_explicit(volatile atomic_int *object, int operand, memory_order order);
3559-int __ovld atomic_fetch_and_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
3560 uint __ovld atomic_fetch_and(volatile atomic_uint *object, uint operand);
3561-uint __ovld atomic_fetch_and_explicit(volatile atomic_uint *object, uint operand, memory_order order);
3562-uint __ovld atomic_fetch_and_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
3563 int __ovld atomic_fetch_min(volatile atomic_int *object, int operand);
3564-int __ovld atomic_fetch_min_explicit(volatile atomic_int *object, int operand, memory_order order);
3565-int __ovld atomic_fetch_min_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
3566 uint __ovld atomic_fetch_min(volatile atomic_uint *object, uint operand);
3567-uint __ovld atomic_fetch_min_explicit(volatile atomic_uint *object, uint operand, memory_order order);
3568-uint __ovld atomic_fetch_min_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
3569 int __ovld atomic_fetch_max(volatile atomic_int *object, int operand);
3570-int __ovld atomic_fetch_max_explicit(volatile atomic_int *object, int operand, memory_order order);
3571-int __ovld atomic_fetch_max_explicit(volatile atomic_int *object, int operand, memory_order order, memory_scope scope);
3572 uint __ovld atomic_fetch_max(volatile atomic_uint *object, uint operand);
3573-uint __ovld atomic_fetch_max_explicit(volatile atomic_uint *object, uint operand, memory_order order);
3574-uint __ovld atomic_fetch_max_explicit(volatile atomic_uint *object, uint operand, memory_order order, memory_scope scope);
3575
3576 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
3577 long __ovld atomic_fetch_add(volatile atomic_long *object, long operand);
3578-long __ovld atomic_fetch_add_explicit(volatile atomic_long *object, long operand, memory_order order);
3579-long __ovld atomic_fetch_add_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);
3580 ulong __ovld atomic_fetch_add(volatile atomic_ulong *object, ulong operand);
3581-ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
3582-ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);
3583 long __ovld atomic_fetch_sub(volatile atomic_long *object, long operand);
3584-long __ovld atomic_fetch_sub_explicit(volatile atomic_long *object, long operand, memory_order order);
3585-long __ovld atomic_fetch_sub_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);
3586 ulong __ovld atomic_fetch_sub(volatile atomic_ulong *object, ulong operand);
3587-ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
3588-ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);
3589 long __ovld atomic_fetch_or(volatile atomic_long *object, long operand);
3590-long __ovld atomic_fetch_or_explicit(volatile atomic_long *object, long operand, memory_order order);
3591-long __ovld atomic_fetch_or_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);
3592 ulong __ovld atomic_fetch_or(volatile atomic_ulong *object, ulong operand);
3593-ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
3594-ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);
3595 long __ovld atomic_fetch_xor(volatile atomic_long *object, long operand);
3596-long __ovld atomic_fetch_xor_explicit(volatile atomic_long *object, long operand, memory_order order);
3597-long __ovld atomic_fetch_xor_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);
3598 ulong __ovld atomic_fetch_xor(volatile atomic_ulong *object, ulong operand);
3599-ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
3600-ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);
3601 long __ovld atomic_fetch_and(volatile atomic_long *object, long operand);
3602-long __ovld atomic_fetch_and_explicit(volatile atomic_long *object, long operand, memory_order order);
3603-long __ovld atomic_fetch_and_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);
3604 ulong __ovld atomic_fetch_and(volatile atomic_ulong *object, ulong operand);
3605-ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
3606-ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);
3607 long __ovld atomic_fetch_min(volatile atomic_long *object, long operand);
3608-long __ovld atomic_fetch_min_explicit(volatile atomic_long *object, long operand, memory_order order);
3609-long __ovld atomic_fetch_min_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);
3610 ulong __ovld atomic_fetch_min(volatile atomic_ulong *object, ulong operand);
3611-ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
3612-ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);
3613 long __ovld atomic_fetch_max(volatile atomic_long *object, long operand);
3614-long __ovld atomic_fetch_max_explicit(volatile atomic_long *object, long operand, memory_order order);
3615-long __ovld atomic_fetch_max_explicit(volatile atomic_long *object, long operand, memory_order order, memory_scope scope);
3616 ulong __ovld atomic_fetch_max(volatile atomic_ulong *object, ulong operand);
3617-ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *object, ulong operand, memory_order order);
3618-ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *object, ulong operand, memory_order order, memory_scope scope);
3619 #endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
3620
3621 // OpenCL v2.0 s6.13.11.7.5:
3622@@ -13489,196 +13483,2239 @@ ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *object, ulong oper
3623 // or/xor/and/min/max: atomic type argument can be intptr_t/uintptr_t, value type argument can be intptr_t/uintptr_t.
3624
3625 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
3626-uintptr_t __ovld atomic_fetch_add(volatile atomic_uintptr_t *object, ptrdiff_t operand);
3627-uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order);
3628-uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order, memory_scope scope);
3629-uintptr_t __ovld atomic_fetch_sub(volatile atomic_uintptr_t *object, ptrdiff_t operand);
3630-uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order);
3631-uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *object, ptrdiff_t operand, memory_order order, memory_scope scope);
3632-
3633-uintptr_t __ovld atomic_fetch_or(volatile atomic_uintptr_t *object, intptr_t operand);
3634-uintptr_t __ovld atomic_fetch_or_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order);
3635-uintptr_t __ovld atomic_fetch_or_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order, memory_scope scope);
3636-uintptr_t __ovld atomic_fetch_xor(volatile atomic_uintptr_t *object, intptr_t operand);
3637-uintptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order);
3638-uintptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order, memory_scope scope);
3639-uintptr_t __ovld atomic_fetch_and(volatile atomic_uintptr_t *object, intptr_t operand);
3640-uintptr_t __ovld atomic_fetch_and_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order);
3641-uintptr_t __ovld atomic_fetch_and_explicit(volatile atomic_uintptr_t *object, intptr_t operand, memory_order order, memory_scope scope);
3642-uintptr_t __ovld atomic_fetch_min(volatile atomic_uintptr_t *object, intptr_t opermax);
3643-uintptr_t __ovld atomic_fetch_min_explicit(volatile atomic_uintptr_t *object, intptr_t opermax, memory_order minder);
3644-uintptr_t __ovld atomic_fetch_min_explicit(volatile atomic_uintptr_t *object, intptr_t opermax, memory_order minder, memory_scope scope);
3645-uintptr_t __ovld atomic_fetch_max(volatile atomic_uintptr_t *object, intptr_t opermax);
3646-uintptr_t __ovld atomic_fetch_max_explicit(volatile atomic_uintptr_t *object, intptr_t opermax, memory_order minder);
3647-uintptr_t __ovld atomic_fetch_max_explicit(volatile atomic_uintptr_t *object, intptr_t opermax, memory_order minder, memory_scope scope);
3648-
3649-intptr_t __ovld atomic_fetch_or(volatile atomic_intptr_t *object, uintptr_t operand);
3650-intptr_t __ovld atomic_fetch_or_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order);
3651-intptr_t __ovld atomic_fetch_or_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order, memory_scope scope);
3652-intptr_t __ovld atomic_fetch_xor(volatile atomic_intptr_t *object, uintptr_t operand);
3653-intptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order);
3654-intptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order, memory_scope scope);
3655-intptr_t __ovld atomic_fetch_and(volatile atomic_intptr_t *object, uintptr_t operand);
3656-intptr_t __ovld atomic_fetch_and_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order);
3657-intptr_t __ovld atomic_fetch_and_explicit(volatile atomic_intptr_t *object, uintptr_t operand, memory_order order, memory_scope scope);
3658-intptr_t __ovld atomic_fetch_min(volatile atomic_intptr_t *object, uintptr_t opermax);
3659-intptr_t __ovld atomic_fetch_min_explicit(volatile atomic_intptr_t *object, uintptr_t opermax, memory_order minder);
3660-intptr_t __ovld atomic_fetch_min_explicit(volatile atomic_intptr_t *object, uintptr_t opermax, memory_order minder, memory_scope scope);
3661-intptr_t __ovld atomic_fetch_max(volatile atomic_intptr_t *object, uintptr_t opermax);
3662-intptr_t __ovld atomic_fetch_max_explicit(volatile atomic_intptr_t *object, uintptr_t opermax, memory_order minder);
3663-intptr_t __ovld atomic_fetch_max_explicit(volatile atomic_intptr_t *object, uintptr_t opermax, memory_order minder, memory_scope scope);
3664+uintptr_t __ovld atomic_fetch_add(volatile atomic_uintptr_t *object,
3665+ ptrdiff_t operand);
3666+uintptr_t __ovld atomic_fetch_sub(volatile atomic_uintptr_t *object,
3667+ ptrdiff_t operand);
3668+
3669+uintptr_t __ovld atomic_fetch_or(volatile atomic_uintptr_t *object,
3670+ intptr_t operand);
3671+uintptr_t __ovld atomic_fetch_xor(volatile atomic_uintptr_t *object,
3672+ intptr_t operand);
3673+uintptr_t __ovld atomic_fetch_and(volatile atomic_uintptr_t *object,
3674+ intptr_t operand);
3675+uintptr_t __ovld atomic_fetch_min(volatile atomic_uintptr_t *object,
3676+ intptr_t opermax);
3677+uintptr_t __ovld atomic_fetch_max(volatile atomic_uintptr_t *object,
3678+ intptr_t opermax);
3679+
3680+intptr_t __ovld atomic_fetch_or(volatile atomic_intptr_t *object,
3681+ uintptr_t operand);
3682+intptr_t __ovld atomic_fetch_xor(volatile atomic_intptr_t *object,
3683+ uintptr_t operand);
3684+intptr_t __ovld atomic_fetch_and(volatile atomic_intptr_t *object,
3685+ uintptr_t operand);
3686+intptr_t __ovld atomic_fetch_min(volatile atomic_intptr_t *object,
3687+ uintptr_t opermax);
3688+intptr_t __ovld atomic_fetch_max(volatile atomic_intptr_t *object,
3689+ uintptr_t opermax);
3690+#endif // defined(cl_khr_int64_base_atomics) &&
3691+ // defined(cl_khr_int64_extended_atomics)
3692+#endif // __opencl_c_generic_address_space
3693+
3694+#if(__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
3695+int __ovld atomic_fetch_add(volatile atomic_int __global *object, int operand);
3696+uint __ovld atomic_fetch_add(volatile atomic_uint __local *object,
3697+ uint operand);
3698+int __ovld atomic_fetch_sub(volatile atomic_int __global *object, int operand);
3699+int __ovld atomic_fetch_sub(volatile atomic_int __local *object, int operand);
3700+uint __ovld atomic_fetch_sub(volatile atomic_uint __local *object,
3701+ uint operand);
3702+uint __ovld atomic_fetch_sub(volatile atomic_uint __global *object,
3703+ uint operand);
3704+int __ovld atomic_fetch_or(volatile atomic_int __global *object, int operand);
3705+uint __ovld atomic_fetch_sub(volatile atomic_uint __local *object,
3706+ uint operand);
3707+uint __ovld atomic_fetch_or(volatile atomic_uint __global *object,
3708+ uint operand);
3709+uint __ovld atomic_fetch_or(volatile atomic_uint __local *object, uint operand);
3710+int __ovld atomic_fetch_xor(volatile atomic_int __global *object, int operand);
3711+int __ovld atomic_fetch_xor(volatile atomic_int __local *object, int operand);
3712+uint __ovld atomic_fetch_xor(volatile atomic_uint __global *object,
3713+ uint operand);
3714+uint __ovld atomic_fetch_xor(volatile atomic_uint __local *object,
3715+ uint operand);
3716+int __ovld atomic_fetch_and(volatile atomic_int __global *object, int operand);
3717+int __ovld atomic_fetch_and(volatile atomic_int __local *object, int operand);
3718+uint __ovld atomic_fetch_and(volatile atomic_uint __global *object,
3719+ uint operand);
3720+uint __ovld atomic_fetch_and(volatile atomic_uint __local *object,
3721+ uint operand);
3722+int __ovld atomic_fetch_min(volatile atomic_int __global *object, int operand);
3723+int __ovld atomic_fetch_min(volatile atomic_int __local *object, int operand);
3724+uint __ovld atomic_fetch_min(volatile atomic_uint __global *object,
3725+ uint operand);
3726+uint __ovld atomic_fetch_min(volatile atomic_uint __local *object,
3727+ uint operand);
3728+int __ovld atomic_fetch_max(volatile atomic_int __global *object, int operand);
3729+int __ovld atomic_fetch_max(volatile atomic_int __local *object, int operand);
3730+uint __ovld atomic_fetch_max(volatile atomic_uint __global *object,
3731+ uint operand);
3732+uint __ovld atomic_fetch_max(volatile atomic_uint __local *object,
3733+ uint operand);
3734+
3735+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
3736+long __ovld atomic_fetch_add(volatile atomic_long __global *object,
3737+ long operand);
3738+long __ovld atomic_fetch_add(volatile atomic_long __local *object,
3739+ long operand);
3740+ulong __ovld atomic_fetch_add(volatile atomic_ulong __global *object,
3741+ ulong operand);
3742+ulong __ovld atomic_fetch_add(volatile atomic_ulong __local *object,
3743+ ulong operand);
3744+long __ovld atomic_fetch_sub(volatile atomic_long __global *object,
3745+ long operand);
3746+long __ovld atomic_fetch_sub(volatile atomic_long __local *object,
3747+ long operand);
3748+ulong __ovld atomic_fetch_sub(volatile atomic_ulong __global *object,
3749+ ulong operand);
3750+ulong __ovld atomic_fetch_sub(volatile atomic_ulong __local *object,
3751+ ulong operand);
3752+long __ovld atomic_fetch_or(volatile atomic_long __global *object,
3753+ long operand);
3754+long __ovld atomic_fetch_or(volatile atomic_long __local *object, long operand);
3755+ulong __ovld atomic_fetch_or(volatile atomic_ulong __global *object,
3756+ ulong operand);
3757+ulong __ovld atomic_fetch_or(volatile atomic_ulong __local *object,
3758+ ulong operand);
3759+long __ovld atomic_fetch_xor(volatile atomic_long __global *object,
3760+ long operand);
3761+long __ovld atomic_fetch_xor(volatile atomic_long __local *object,
3762+ long operand);
3763+ulong __ovld atomic_fetch_xor(volatile atomic_ulong __global *object,
3764+ ulong operand);
3765+ulong __ovld atomic_fetch_xor(volatile atomic_ulong __local *object,
3766+ ulong operand);
3767+long __ovld atomic_fetch_and(volatile atomic_long __global *object,
3768+ long operand);
3769+long __ovld atomic_fetch_and(volatile atomic_long __local *object,
3770+ long operand);
3771+ulong __ovld atomic_fetch_and(volatile atomic_ulong __global *object,
3772+ ulong operand);
3773+ulong __ovld atomic_fetch_and(volatile atomic_ulong __local *object,
3774+ ulong operand);
3775+long __ovld atomic_fetch_min(volatile atomic_long __global *object,
3776+ long operand);
3777+long __ovld atomic_fetch_min(volatile atomic_long __local *object,
3778+ long operand);
3779+ulong __ovld atomic_fetch_min(volatile atomic_ulong __global *object,
3780+ ulong operand);
3781+ulong __ovld atomic_fetch_min(volatile atomic_ulong __local *object,
3782+ ulong operand);
3783+long __ovld atomic_fetch_max(volatile atomic_long __global *object,
3784+ long operand);
3785+long __ovld atomic_fetch_max(volatile atomic_long __local *object,
3786+ long operand);
3787+ulong __ovld atomic_fetch_max(volatile atomic_ulong __global *object,
3788+ ulong operand);
3789+ulong __ovld atomic_fetch_max(volatile atomic_ulong __local *object,
3790+ ulong operand);
3791+#endif // defined(cl_khr_int64_base_atomics) &&
3792+ // defined(cl_khr_int64_extended_atomics)
3793+
3794+// OpenCL v2.0 s6.13.11.7.5:
3795+// add/sub: atomic type argument can be uintptr_t/intptr_t, value type argument
3796+// can be ptrdiff_t. or/xor/and/min/max: atomic type argument can be
3797+// intptr_t/uintptr_t, value type argument can be intptr_t/uintptr_t.
3798+
3799+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
3800+uintptr_t __ovld atomic_fetch_add(volatile atomic_uintptr_t __global *object,
3801+ ptrdiff_t operand);
3802+uintptr_t __ovld atomic_fetch_add(volatile atomic_uintptr_t __local *object,
3803+ ptrdiff_t operand);
3804+uintptr_t __ovld atomic_fetch_sub(volatile atomic_uintptr_t __global *object,
3805+ ptrdiff_t operand);
3806+uintptr_t __ovld atomic_fetch_sub(volatile atomic_uintptr_t __local *object,
3807+ ptrdiff_t operand);
3808+
3809+uintptr_t __ovld atomic_fetch_or(volatile atomic_uintptr_t __global *object,
3810+ intptr_t operand);
3811+uintptr_t __ovld atomic_fetch_or(volatile atomic_uintptr_t __local *object,
3812+ intptr_t operand);
3813+uintptr_t __ovld atomic_fetch_xor(volatile atomic_uintptr_t __global *object,
3814+ intptr_t operand);
3815+uintptr_t __ovld atomic_fetch_xor(volatile atomic_uintptr_t __local *object,
3816+ intptr_t operand);
3817+uintptr_t __ovld atomic_fetch_and(volatile atomic_uintptr_t __global *object,
3818+ intptr_t operand);
3819+uintptr_t __ovld atomic_fetch_and(volatile atomic_uintptr_t __local *object,
3820+ intptr_t operand);
3821+uintptr_t __ovld atomic_fetch_min(volatile atomic_uintptr_t __global *object,
3822+ intptr_t opermax);
3823+uintptr_t __ovld atomic_fetch_min(volatile atomic_uintptr_t __local *object,
3824+ intptr_t opermax);
3825+uintptr_t __ovld atomic_fetch_max(volatile atomic_uintptr_t __global *object,
3826+ intptr_t opermax);
3827+uintptr_t __ovld atomic_fetch_max(volatile atomic_uintptr_t __local *object,
3828+ intptr_t opermax);
3829+
3830+intptr_t __ovld atomic_fetch_or(volatile atomic_intptr_t __global *object,
3831+ uintptr_t operand);
3832+intptr_t __ovld atomic_fetch_or(volatile atomic_intptr_t __local *object,
3833+ uintptr_t operand);
3834+intptr_t __ovld atomic_fetch_xor(volatile atomic_intptr_t __global *object,
3835+ uintptr_t operand);
3836+intptr_t __ovld atomic_fetch_xor(volatile atomic_intptr_t __local *object,
3837+ uintptr_t operand);
3838+intptr_t __ovld atomic_fetch_and(volatile atomic_intptr_t __global *object,
3839+ uintptr_t operand);
3840+intptr_t __ovld atomic_fetch_and(volatile atomic_intptr_t __local *object,
3841+ uintptr_t operand);
3842+intptr_t __ovld atomic_fetch_min(volatile atomic_intptr_t __global *object,
3843+ uintptr_t opermax);
3844+intptr_t __ovld atomic_fetch_min(volatile atomic_intptr_t __local *object,
3845+ uintptr_t opermax);
3846+intptr_t __ovld atomic_fetch_max(volatile atomic_intptr_t __global *object,
3847+ uintptr_t opermax);
3848+intptr_t __ovld atomic_fetch_max(volatile atomic_intptr_t __local *object,
3849+ uintptr_t opermax);
3850+#endif // defined(cl_khr_int64_base_atomics) &&
3851+ // defined(cl_khr_int64_extended_atomics)
3852+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
3853+
3854+#endif // defined(__opencl_c_atomic_scope_device) &&
3855+ // defined(__opencl_c_atomic_order_seq_cst)
3856+
3857+#ifdef __opencl_c_generic_address_space
3858+#ifdef __opencl_c_atomic_scope_device
3859+int __ovld atomic_fetch_add_explicit(volatile atomic_int *object, int operand,
3860+ memory_order order);
3861+uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *object,
3862+ uint operand, memory_order order);
3863+int __ovld atomic_fetch_sub_explicit(volatile atomic_int *object, int operand,
3864+ memory_order order);
3865+uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *object,
3866+ uint operand, memory_order order);
3867+int __ovld atomic_fetch_or_explicit(volatile atomic_int *object, int operand,
3868+ memory_order order);
3869+uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *object, uint operand,
3870+ memory_order order);
3871+int __ovld atomic_fetch_xor_explicit(volatile atomic_int *object, int operand,
3872+ memory_order order);
3873+uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint *object,
3874+ uint operand, memory_order order);
3875+int __ovld atomic_fetch_and_explicit(volatile atomic_int *object, int operand,
3876+ memory_order order);
3877+uint __ovld atomic_fetch_and_explicit(volatile atomic_uint *object,
3878+ uint operand, memory_order order);
3879+int __ovld atomic_fetch_min_explicit(volatile atomic_int *object, int operand,
3880+ memory_order order);
3881+uint __ovld atomic_fetch_min_explicit(volatile atomic_uint *object,
3882+ uint operand, memory_order order);
3883+int __ovld atomic_fetch_max_explicit(volatile atomic_int *object, int operand,
3884+ memory_order order);
3885+uint __ovld atomic_fetch_max_explicit(volatile atomic_uint *object,
3886+ uint operand, memory_order order);
3887+#endif // __opencl_c_atomic_scope_device
3888+int __ovld atomic_fetch_add_explicit(volatile atomic_int *object, int operand,
3889+ memory_order order, memory_scope scope);
3890+uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *object,
3891+ uint operand, memory_order order,
3892+ memory_scope scope);
3893+int __ovld atomic_fetch_sub_explicit(volatile atomic_int *object, int operand,
3894+ memory_order order, memory_scope scope);
3895+uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *object,
3896+ uint operand, memory_order order,
3897+ memory_scope scope);
3898+int __ovld atomic_fetch_or_explicit(volatile atomic_int *object, int operand,
3899+ memory_order order, memory_scope scope);
3900+uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *object, uint operand,
3901+ memory_order order, memory_scope scope);
3902+int __ovld atomic_fetch_xor_explicit(volatile atomic_int *object, int operand,
3903+ memory_order order, memory_scope scope);
3904+uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint *object,
3905+ uint operand, memory_order order,
3906+ memory_scope scope);
3907+int __ovld atomic_fetch_and_explicit(volatile atomic_int *object, int operand,
3908+ memory_order order, memory_scope scope);
3909+uint __ovld atomic_fetch_and_explicit(volatile atomic_uint *object,
3910+ uint operand, memory_order order,
3911+ memory_scope scope);
3912+int __ovld atomic_fetch_min_explicit(volatile atomic_int *object, int operand,
3913+ memory_order order, memory_scope scope);
3914+uint __ovld atomic_fetch_min_explicit(volatile atomic_uint *object,
3915+ uint operand, memory_order order,
3916+ memory_scope scope);
3917+int __ovld atomic_fetch_max_explicit(volatile atomic_int *object, int operand,
3918+ memory_order order, memory_scope scope);
3919+uint __ovld atomic_fetch_max_explicit(volatile atomic_uint *object,
3920+ uint operand, memory_order order,
3921+ memory_scope scope);
3922+
3923+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
3924+#ifdef __opencl_c_atomic_scope_device
3925+long __ovld atomic_fetch_add_explicit(volatile atomic_long *object,
3926+ long operand, memory_order order);
3927+ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong *object,
3928+ ulong operand, memory_order order);
3929+long __ovld atomic_fetch_sub_explicit(volatile atomic_long *object,
3930+ long operand, memory_order order);
3931+ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong *object,
3932+ ulong operand, memory_order order);
3933+long __ovld atomic_fetch_or_explicit(volatile atomic_long *object, long operand,
3934+ memory_order order);
3935+ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong *object,
3936+ ulong operand, memory_order order);
3937+long __ovld atomic_fetch_xor_explicit(volatile atomic_long *object,
3938+ long operand, memory_order order);
3939+ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong *object,
3940+ ulong operand, memory_order order);
3941+long __ovld atomic_fetch_and_explicit(volatile atomic_long *object,
3942+ long operand, memory_order order);
3943+ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong *object,
3944+ ulong operand, memory_order order);
3945+long __ovld atomic_fetch_min_explicit(volatile atomic_long *object,
3946+ long operand, memory_order order);
3947+ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *object,
3948+ ulong operand, memory_order order);
3949+long __ovld atomic_fetch_max_explicit(volatile atomic_long *object,
3950+ long operand, memory_order order);
3951+ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *object,
3952+ ulong operand, memory_order order);
3953+#endif // __opencl_c_atomic_scope_device
3954+long __ovld atomic_fetch_add_explicit(volatile atomic_long *object,
3955+ long operand, memory_order order,
3956+ memory_scope scope);
3957+ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong *object,
3958+ ulong operand, memory_order order,
3959+ memory_scope scope);
3960+long __ovld atomic_fetch_sub_explicit(volatile atomic_long *object,
3961+ long operand, memory_order order,
3962+ memory_scope scope);
3963+ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong *object,
3964+ ulong operand, memory_order order,
3965+ memory_scope scope);
3966+long __ovld atomic_fetch_or_explicit(volatile atomic_long *object, long operand,
3967+ memory_order order, memory_scope scope);
3968+ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong *object,
3969+ ulong operand, memory_order order,
3970+ memory_scope scope);
3971+long __ovld atomic_fetch_xor_explicit(volatile atomic_long *object,
3972+ long operand, memory_order order,
3973+ memory_scope scope);
3974+ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong *object,
3975+ ulong operand, memory_order order,
3976+ memory_scope scope);
3977+long __ovld atomic_fetch_and_explicit(volatile atomic_long *object,
3978+ long operand, memory_order order,
3979+ memory_scope scope);
3980+ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong *object,
3981+ ulong operand, memory_order order,
3982+ memory_scope scope);
3983+long __ovld atomic_fetch_min_explicit(volatile atomic_long *object,
3984+ long operand, memory_order order,
3985+ memory_scope scope);
3986+ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *object,
3987+ ulong operand, memory_order order,
3988+ memory_scope scope);
3989+long __ovld atomic_fetch_max_explicit(volatile atomic_long *object,
3990+ long operand, memory_order order,
3991+ memory_scope scope);
3992+ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *object,
3993+ ulong operand, memory_order order,
3994+ memory_scope scope);
3995+#endif // defined(cl_khr_int64_base_atomics) &&
3996+ // defined(cl_khr_int64_extended_atomics)
3997+
3998+// OpenCL v2.0 s6.13.11.7.5:
3999+// add/sub: atomic type argument can be uintptr_t/intptr_t, value type argument
4000+// can be ptrdiff_t. or/xor/and/min/max: atomic type argument can be
4001+// intptr_t/uintptr_t, value type argument can be intptr_t/uintptr_t.
4002+
4003+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4004+#ifdef __opencl_c_atomic_scope_device
4005+uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *object,
4006+ ptrdiff_t operand,
4007+ memory_order order);
4008+uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *object,
4009+ ptrdiff_t operand,
4010+ memory_order order);
4011+uintptr_t __ovld atomic_fetch_or_explicit(volatile atomic_uintptr_t *object,
4012+ intptr_t operand, memory_order order);
4013+uintptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_uintptr_t *object,
4014+ intptr_t operand,
4015+ memory_order order);
4016+uintptr_t __ovld atomic_fetch_and_explicit(volatile atomic_uintptr_t *object,
4017+ intptr_t operand,
4018+ memory_order order);
4019+uintptr_t __ovld atomic_fetch_min_explicit(volatile atomic_uintptr_t *object,
4020+ intptr_t opermax,
4021+ memory_order minder);
4022+uintptr_t __ovld atomic_fetch_max_explicit(volatile atomic_uintptr_t *object,
4023+ intptr_t opermax,
4024+ memory_order minder);
4025+intptr_t __ovld atomic_fetch_or_explicit(volatile atomic_intptr_t *object,
4026+ uintptr_t operand, memory_order order);
4027+intptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_intptr_t *object,
4028+ uintptr_t operand,
4029+ memory_order order);
4030+intptr_t __ovld atomic_fetch_and_explicit(volatile atomic_intptr_t *object,
4031+ uintptr_t operand,
4032+ memory_order order);
4033+intptr_t __ovld atomic_fetch_min_explicit(volatile atomic_intptr_t *object,
4034+ uintptr_t opermax,
4035+ memory_order minder);
4036+intptr_t __ovld atomic_fetch_max_explicit(volatile atomic_intptr_t *object,
4037+ uintptr_t opermax,
4038+ memory_order minder);
4039+#endif // __opencl_c_atomic_scope_device
4040+uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *object,
4041+ ptrdiff_t operand,
4042+ memory_order order,
4043+ memory_scope scope);
4044+uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *object,
4045+ ptrdiff_t operand,
4046+ memory_order order,
4047+ memory_scope scope);
4048+
4049+uintptr_t __ovld atomic_fetch_or_explicit(volatile atomic_uintptr_t *object,
4050+ intptr_t operand, memory_order order,
4051+ memory_scope scope);
4052+uintptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_uintptr_t *object,
4053+ intptr_t operand, memory_order order,
4054+ memory_scope scope);
4055+uintptr_t __ovld atomic_fetch_and_explicit(volatile atomic_uintptr_t *object,
4056+ intptr_t operand, memory_order order,
4057+ memory_scope scope);
4058+uintptr_t __ovld atomic_fetch_min_explicit(volatile atomic_uintptr_t *object,
4059+ intptr_t opermax,
4060+ memory_order minder,
4061+ memory_scope scope);
4062+uintptr_t __ovld atomic_fetch_max_explicit(volatile atomic_uintptr_t *object,
4063+ intptr_t opermax,
4064+ memory_order minder,
4065+ memory_scope scope);
4066+
4067+intptr_t __ovld atomic_fetch_or_explicit(volatile atomic_intptr_t *object,
4068+ uintptr_t operand, memory_order order,
4069+ memory_scope scope);
4070+intptr_t __ovld atomic_fetch_xor_explicit(volatile atomic_intptr_t *object,
4071+ uintptr_t operand, memory_order order,
4072+ memory_scope scope);
4073+intptr_t __ovld atomic_fetch_and_explicit(volatile atomic_intptr_t *object,
4074+ uintptr_t operand, memory_order order,
4075+ memory_scope scope);
4076+intptr_t __ovld atomic_fetch_min_explicit(volatile atomic_intptr_t *object,
4077+ uintptr_t opermax,
4078+ memory_order minder,
4079+ memory_scope scope);
4080+intptr_t __ovld atomic_fetch_max_explicit(volatile atomic_intptr_t *object,
4081+ uintptr_t opermax,
4082+ memory_order minder,
4083+ memory_scope scope);
4084 #endif
4085+#endif // __opencl_c_generic_address_space
4086+
4087+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4088+#ifdef __opencl_c_atomic_scope_device
4089+int __ovld atomic_fetch_add_explicit(volatile atomic_int __global *object,
4090+ int operand, memory_order order);
4091+int __ovld atomic_fetch_add_explicit(volatile atomic_int __local *object,
4092+ int operand, memory_order order);
4093+uint __ovld atomic_fetch_add_explicit(volatile atomic_uint __global *object,
4094+ uint operand, memory_order order);
4095+uint __ovld atomic_fetch_add_explicit(volatile atomic_uint __local *object,
4096+ uint operand, memory_order order);
4097+int __ovld atomic_fetch_sub_explicit(volatile atomic_int __global *object,
4098+ int operand, memory_order order);
4099+int __ovld atomic_fetch_sub_explicit(volatile atomic_int __local *object,
4100+ int operand, memory_order order);
4101+uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint __global *object,
4102+ uint operand, memory_order order);
4103+uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint __local *object,
4104+ uint operand, memory_order order);
4105+int __ovld atomic_fetch_or_explicit(volatile atomic_int __global *object,
4106+ int operand, memory_order order);
4107+int __ovld atomic_fetch_or_explicit(volatile atomic_int __local *object,
4108+ int operand, memory_order order);
4109+uint __ovld atomic_fetch_or_explicit(volatile atomic_uint __global *object,
4110+ uint operand, memory_order order);
4111+uint __ovld atomic_fetch_or_explicit(volatile atomic_uint __local *object,
4112+ uint operand, memory_order order);
4113+int __ovld atomic_fetch_xor_explicit(volatile atomic_int __global *object,
4114+ int operand, memory_order order);
4115+int __ovld atomic_fetch_xor_explicit(volatile atomic_int __local *object,
4116+ int operand, memory_order order);
4117+uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint __global *object,
4118+ uint operand, memory_order order);
4119+uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint __local *object,
4120+ uint operand, memory_order order);
4121+int __ovld atomic_fetch_and_explicit(volatile atomic_int __global *object,
4122+ int operand, memory_order order);
4123+int __ovld atomic_fetch_and_explicit(volatile atomic_int __local *object,
4124+ int operand, memory_order order);
4125+uint __ovld atomic_fetch_and_explicit(volatile atomic_uint __global *object,
4126+ uint operand, memory_order order);
4127+uint __ovld atomic_fetch_and_explicit(volatile atomic_uint __local *object,
4128+ uint operand, memory_order order);
4129+int __ovld atomic_fetch_min_explicit(volatile atomic_int __global *object,
4130+ int operand, memory_order order);
4131+int __ovld atomic_fetch_min_explicit(volatile atomic_int __local *object,
4132+ int operand, memory_order order);
4133+uint __ovld atomic_fetch_min_explicit(volatile atomic_uint __global *object,
4134+ uint operand, memory_order order);
4135+uint __ovld atomic_fetch_min_explicit(volatile atomic_uint __local *object,
4136+ uint operand, memory_order order);
4137+int __ovld atomic_fetch_max_explicit(volatile atomic_int __global *object,
4138+ int operand, memory_order order);
4139+int __ovld atomic_fetch_max_explicit(volatile atomic_int __local *object,
4140+ int operand, memory_order order);
4141+uint __ovld atomic_fetch_max_explicit(volatile atomic_uint __global *object,
4142+ uint operand, memory_order order);
4143+uint __ovld atomic_fetch_max_explicit(volatile atomic_uint __local *object,
4144+ uint operand, memory_order order);
4145+#endif // __opencl_c_atomic_scope_device
4146+int __ovld atomic_fetch_add_explicit(volatile atomic_int __global *object,
4147+ int operand, memory_order order,
4148+ memory_scope scope);
4149+int __ovld atomic_fetch_add_explicit(volatile atomic_int __local *object,
4150+ int operand, memory_order order,
4151+ memory_scope scope);
4152+uint __ovld atomic_fetch_add_explicit(volatile atomic_uint __global *object,
4153+ uint operand, memory_order order,
4154+ memory_scope scope);
4155+uint __ovld atomic_fetch_add_explicit(volatile atomic_uint __local *object,
4156+ uint operand, memory_order order,
4157+ memory_scope scope);
4158+int __ovld atomic_fetch_sub_explicit(volatile atomic_int __global *object,
4159+ int operand, memory_order order,
4160+ memory_scope scope);
4161+int __ovld atomic_fetch_sub_explicit(volatile atomic_int __local *object,
4162+ int operand, memory_order order,
4163+ memory_scope scope);
4164+uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint __global *object,
4165+ uint operand, memory_order order,
4166+ memory_scope scope);
4167+uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint __local *object,
4168+ uint operand, memory_order order,
4169+ memory_scope scope);
4170+int __ovld atomic_fetch_or_explicit(volatile atomic_int __global *object,
4171+ int operand, memory_order order,
4172+ memory_scope scope);
4173+int __ovld atomic_fetch_or_explicit(volatile atomic_int __local *object,
4174+ int operand, memory_order order,
4175+ memory_scope scope);
4176+uint __ovld atomic_fetch_or_explicit(volatile atomic_uint __global *object,
4177+ uint operand, memory_order order,
4178+ memory_scope scope);
4179+uint __ovld atomic_fetch_or_explicit(volatile atomic_uint __local *object,
4180+ uint operand, memory_order order,
4181+ memory_scope scope);
4182+int __ovld atomic_fetch_xor_explicit(volatile atomic_int __global *object,
4183+ int operand, memory_order order,
4184+ memory_scope scope);
4185+int __ovld atomic_fetch_xor_explicit(volatile atomic_int __local *object,
4186+ int operand, memory_order order,
4187+ memory_scope scope);
4188+uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint __global *object,
4189+ uint operand, memory_order order,
4190+ memory_scope scope);
4191+uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint __local *object,
4192+ uint operand, memory_order order,
4193+ memory_scope scope);
4194+int __ovld atomic_fetch_and_explicit(volatile atomic_int __global *object,
4195+ int operand, memory_order order,
4196+ memory_scope scope);
4197+int __ovld atomic_fetch_and_explicit(volatile atomic_int __local *object,
4198+ int operand, memory_order order,
4199+ memory_scope scope);
4200+uint __ovld atomic_fetch_and_explicit(volatile atomic_uint __global *object,
4201+ uint operand, memory_order order,
4202+ memory_scope scope);
4203+uint __ovld atomic_fetch_and_explicit(volatile atomic_uint __local *object,
4204+ uint operand, memory_order order,
4205+ memory_scope scope);
4206+int __ovld atomic_fetch_min_explicit(volatile atomic_int __global *object,
4207+ int operand, memory_order order,
4208+ memory_scope scope);
4209+int __ovld atomic_fetch_min_explicit(volatile atomic_int __local *object,
4210+ int operand, memory_order order,
4211+ memory_scope scope);
4212+uint __ovld atomic_fetch_min_explicit(volatile atomic_uint __global *object,
4213+ uint operand, memory_order order,
4214+ memory_scope scope);
4215+uint __ovld atomic_fetch_min_explicit(volatile atomic_uint __local *object,
4216+ uint operand, memory_order order,
4217+ memory_scope scope);
4218+int __ovld atomic_fetch_max_explicit(volatile atomic_int __global *object,
4219+ int operand, memory_order order,
4220+ memory_scope scope);
4221+int __ovld atomic_fetch_max_explicit(volatile atomic_int __local *object,
4222+ int operand, memory_order order,
4223+ memory_scope scope);
4224+uint __ovld atomic_fetch_max_explicit(volatile atomic_uint __global *object,
4225+ uint operand, memory_order order,
4226+ memory_scope scope);
4227+uint __ovld atomic_fetch_max_explicit(volatile atomic_uint __local *object,
4228+ uint operand, memory_order order,
4229+ memory_scope scope);
4230+
4231+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4232+#ifdef __opencl_c_atomic_scope_device
4233+long __ovld atomic_fetch_add_explicit(volatile atomic_long __global *object,
4234+ long operand, memory_order order);
4235+long __ovld atomic_fetch_add_explicit(volatile atomic_long __local *object,
4236+ long operand, memory_order order);
4237+ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong __global *object,
4238+ ulong operand, memory_order order);
4239+ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong __local *object,
4240+ ulong operand, memory_order order);
4241+long __ovld atomic_fetch_sub_explicit(volatile atomic_long __global *object,
4242+ long operand, memory_order order);
4243+long __ovld atomic_fetch_sub_explicit(volatile atomic_long __local *object,
4244+ long operand, memory_order order);
4245+ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong __global *object,
4246+ ulong operand, memory_order order);
4247+ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong __local *object,
4248+ ulong operand, memory_order order);
4249+long __ovld atomic_fetch_or_explicit(volatile atomic_long __global *object,
4250+ long operand, memory_order order);
4251+long __ovld atomic_fetch_or_explicit(volatile atomic_long __local *object,
4252+ long operand, memory_order order);
4253+ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong __global *object,
4254+ ulong operand, memory_order order);
4255+ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong __local *object,
4256+ ulong operand, memory_order order);
4257+long __ovld atomic_fetch_xor_explicit(volatile atomic_long __global *object,
4258+ long operand, memory_order order);
4259+long __ovld atomic_fetch_xor_explicit(volatile atomic_long __local *object,
4260+ long operand, memory_order order);
4261+ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong __global *object,
4262+ ulong operand, memory_order order);
4263+ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong __local *object,
4264+ ulong operand, memory_order order);
4265+long __ovld atomic_fetch_and_explicit(volatile atomic_long __global *object,
4266+ long operand, memory_order order);
4267+long __ovld atomic_fetch_and_explicit(volatile atomic_long __local *object,
4268+ long operand, memory_order order);
4269+ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong __global *object,
4270+ ulong operand, memory_order order);
4271+ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong __local *object,
4272+ ulong operand, memory_order order);
4273+long __ovld atomic_fetch_min_explicit(volatile atomic_long __global *object,
4274+ long operand, memory_order order);
4275+long __ovld atomic_fetch_min_explicit(volatile atomic_long __local *object,
4276+ long operand, memory_order order);
4277+ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong __global *object,
4278+ ulong operand, memory_order order);
4279+ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong __local *object,
4280+ ulong operand, memory_order order);
4281+long __ovld atomic_fetch_max_explicit(volatile atomic_long __global *object,
4282+ long operand, memory_order order);
4283+long __ovld atomic_fetch_max_explicit(volatile atomic_long __local *object,
4284+ long operand, memory_order order);
4285+ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong __global *object,
4286+ ulong operand, memory_order order);
4287+ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong __local *object,
4288+ ulong operand, memory_order order);
4289+#endif // __opencl_c_atomic_scope_device
4290+long __ovld atomic_fetch_add_explicit(volatile atomic_long __global *object,
4291+ long operand, memory_order order,
4292+ memory_scope scope);
4293+long __ovld atomic_fetch_add_explicit(volatile atomic_long __local *object,
4294+ long operand, memory_order order,
4295+ memory_scope scope);
4296+ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong __global *object,
4297+ ulong operand, memory_order order,
4298+ memory_scope scope);
4299+ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong __local *object,
4300+ ulong operand, memory_order order,
4301+ memory_scope scope);
4302+long __ovld atomic_fetch_sub_explicit(volatile atomic_long __global *object,
4303+ long operand, memory_order order,
4304+ memory_scope scope);
4305+long __ovld atomic_fetch_sub_explicit(volatile atomic_long __local *object,
4306+ long operand, memory_order order,
4307+ memory_scope scope);
4308+ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong __global *object,
4309+ ulong operand, memory_order order,
4310+ memory_scope scope);
4311+ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong __local *object,
4312+ ulong operand, memory_order order,
4313+ memory_scope scope);
4314+long __ovld atomic_fetch_or_explicit(volatile atomic_long __global *object,
4315+ long operand, memory_order order,
4316+ memory_scope scope);
4317+long __ovld atomic_fetch_or_explicit(volatile atomic_long __local *object,
4318+ long operand, memory_order order,
4319+ memory_scope scope);
4320+ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong __global *object,
4321+ ulong operand, memory_order order,
4322+ memory_scope scope);
4323+ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong __local *object,
4324+ ulong operand, memory_order order,
4325+ memory_scope scope);
4326+long __ovld atomic_fetch_xor_explicit(volatile atomic_long __global *object,
4327+ long operand, memory_order order,
4328+ memory_scope scope);
4329+long __ovld atomic_fetch_xor_explicit(volatile atomic_long __local *object,
4330+ long operand, memory_order order,
4331+ memory_scope scope);
4332+ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong __global *object,
4333+ ulong operand, memory_order order,
4334+ memory_scope scope);
4335+ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong __local *object,
4336+ ulong operand, memory_order order,
4337+ memory_scope scope);
4338+long __ovld atomic_fetch_and_explicit(volatile atomic_long __global *object,
4339+ long operand, memory_order order,
4340+ memory_scope scope);
4341+long __ovld atomic_fetch_and_explicit(volatile atomic_long __local *object,
4342+ long operand, memory_order order,
4343+ memory_scope scope);
4344+ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong __global *object,
4345+ ulong operand, memory_order order,
4346+ memory_scope scope);
4347+ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong __local *object,
4348+ ulong operand, memory_order order,
4349+ memory_scope scope);
4350+long __ovld atomic_fetch_min_explicit(volatile atomic_long __global *object,
4351+ long operand, memory_order order,
4352+ memory_scope scope);
4353+long __ovld atomic_fetch_min_explicit(volatile atomic_long __local *object,
4354+ long operand, memory_order order,
4355+ memory_scope scope);
4356+ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong __global *object,
4357+ ulong operand, memory_order order,
4358+ memory_scope scope);
4359+ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong __local *object,
4360+ ulong operand, memory_order order,
4361+ memory_scope scope);
4362+long __ovld atomic_fetch_max_explicit(volatile atomic_long __global *object,
4363+ long operand, memory_order order,
4364+ memory_scope scope);
4365+long __ovld atomic_fetch_max_explicit(volatile atomic_long __local *object,
4366+ long operand, memory_order order,
4367+ memory_scope scope);
4368+ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong __global *object,
4369+ ulong operand, memory_order order,
4370+ memory_scope scope);
4371+ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong __local *object,
4372+ ulong operand, memory_order order,
4373+ memory_scope scope);
4374+#endif // defined(cl_khr_int64_base_atomics) &&
4375+ // defined(cl_khr_int64_extended_atomics)
4376+
4377+// OpenCL v2.0 s6.13.11.7.5:
4378+// add/sub: atomic type argument can be uintptr_t/intptr_t, value type argument
4379+// can be ptrdiff_t. or/xor/and/min/max: atomic type argument can be
4380+// intptr_t/uintptr_t, value type argument can be intptr_t/uintptr_t.
4381+
4382+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4383+#ifdef __opencl_c_atomic_scope_device
4384+uintptr_t __ovld
4385+atomic_fetch_add_explicit(volatile atomic_uintptr_t __global *object,
4386+ ptrdiff_t operand, memory_order order);
4387+uintptr_t __ovld
4388+atomic_fetch_add_explicit(volatile atomic_uintptr_t __local *object,
4389+ ptrdiff_t operand, memory_order order);
4390+uintptr_t __ovld
4391+atomic_fetch_sub_explicit(volatile atomic_uintptr_t __global *object,
4392+ ptrdiff_t operand, memory_order order);
4393+uintptr_t __ovld
4394+atomic_fetch_sub_explicit(volatile atomic_uintptr_t __local *object,
4395+ ptrdiff_t operand, memory_order order);
4396+uintptr_t __ovld
4397+atomic_fetch_or_explicit(volatile atomic_uintptr_t __global *object,
4398+ intptr_t operand, memory_order order);
4399+uintptr_t __ovld
4400+atomic_fetch_or_explicit(volatile atomic_uintptr_t __local *object,
4401+ intptr_t operand, memory_order order);
4402+uintptr_t __ovld
4403+atomic_fetch_xor_explicit(volatile atomic_uintptr_t __global *object,
4404+ intptr_t operand, memory_order order);
4405+uintptr_t __ovld
4406+atomic_fetch_xor_explicit(volatile atomic_uintptr_t __local *object,
4407+ intptr_t operand, memory_order order);
4408+uintptr_t __ovld
4409+atomic_fetch_and_explicit(volatile atomic_uintptr_t __global *object,
4410+ intptr_t operand, memory_order order);
4411+uintptr_t __ovld
4412+atomic_fetch_and_explicit(volatile atomic_uintptr_t __local *object,
4413+ intptr_t operand, memory_order order);
4414+uintptr_t __ovld
4415+atomic_fetch_min_explicit(volatile atomic_uintptr_t __global *object,
4416+ intptr_t opermax, memory_order minder);
4417+uintptr_t __ovld
4418+atomic_fetch_min_explicit(volatile atomic_uintptr_t __local *object,
4419+ intptr_t opermax, memory_order minder);
4420+uintptr_t __ovld
4421+atomic_fetch_max_explicit(volatile atomic_uintptr_t __global *object,
4422+ intptr_t opermax, memory_order minder);
4423+uintptr_t __ovld
4424+atomic_fetch_max_explicit(volatile atomic_uintptr_t __local *object,
4425+ intptr_t opermax, memory_order minder);
4426+intptr_t __ovld
4427+atomic_fetch_or_explicit(volatile atomic_intptr_t __global *object,
4428+ uintptr_t operand, memory_order order);
4429+intptr_t __ovld
4430+atomic_fetch_or_explicit(volatile atomic_intptr_t __local *object,
4431+ uintptr_t operand, memory_order order);
4432+intptr_t __ovld
4433+atomic_fetch_xor_explicit(volatile atomic_intptr_t __global *object,
4434+ uintptr_t operand, memory_order order);
4435+intptr_t __ovld
4436+atomic_fetch_xor_explicit(volatile atomic_intptr_t __local *object,
4437+ uintptr_t operand, memory_order order);
4438+intptr_t __ovld
4439+atomic_fetch_and_explicit(volatile atomic_intptr_t __global *object,
4440+ uintptr_t operand, memory_order order);
4441+intptr_t __ovld
4442+atomic_fetch_and_explicit(volatile atomic_intptr_t __local *object,
4443+ uintptr_t operand, memory_order order);
4444+intptr_t __ovld
4445+atomic_fetch_min_explicit(volatile atomic_intptr_t __global *object,
4446+ uintptr_t opermax, memory_order minder);
4447+intptr_t __ovld
4448+atomic_fetch_min_explicit(volatile atomic_intptr_t __local *object,
4449+ uintptr_t opermax, memory_order minder);
4450+intptr_t __ovld
4451+atomic_fetch_max_explicit(volatile atomic_intptr_t __global *object,
4452+ uintptr_t opermax, memory_order minder);
4453+intptr_t __ovld
4454+atomic_fetch_max_explicit(volatile atomic_intptr_t __local *object,
4455+ uintptr_t opermax, memory_order minder);
4456+#endif // __opencl_c_atomic_scope_device
4457+uintptr_t __ovld atomic_fetch_add_explicit(
4458+ volatile atomic_uintptr_t __global *object, ptrdiff_t operand,
4459+ memory_order order, memory_scope scope);
4460+uintptr_t __ovld atomic_fetch_add_explicit(
4461+ volatile atomic_uintptr_t __local *object, ptrdiff_t operand,
4462+ memory_order order, memory_scope scope);
4463+uintptr_t __ovld atomic_fetch_sub_explicit(
4464+ volatile atomic_uintptr_t __global *object, ptrdiff_t operand,
4465+ memory_order order, memory_scope scope);
4466+uintptr_t __ovld atomic_fetch_sub_explicit(
4467+ volatile atomic_uintptr_t __local *object, ptrdiff_t operand,
4468+ memory_order order, memory_scope scope);
4469+
4470+uintptr_t __ovld atomic_fetch_or_explicit(
4471+ volatile atomic_uintptr_t __global *object, intptr_t operand,
4472+ memory_order order, memory_scope scope);
4473+uintptr_t __ovld atomic_fetch_or_explicit(
4474+ volatile atomic_uintptr_t __local *object, intptr_t operand,
4475+ memory_order order, memory_scope scope);
4476+uintptr_t __ovld atomic_fetch_xor_explicit(
4477+ volatile atomic_uintptr_t __global *object, intptr_t operand,
4478+ memory_order order, memory_scope scope);
4479+uintptr_t __ovld atomic_fetch_xor_explicit(
4480+ volatile atomic_uintptr_t __local *object, intptr_t operand,
4481+ memory_order order, memory_scope scope);
4482+uintptr_t __ovld atomic_fetch_and_explicit(
4483+ volatile atomic_uintptr_t __global *object, intptr_t operand,
4484+ memory_order order, memory_scope scope);
4485+uintptr_t __ovld atomic_fetch_and_explicit(
4486+ volatile atomic_uintptr_t __local *object, intptr_t operand,
4487+ memory_order order, memory_scope scope);
4488+uintptr_t __ovld atomic_fetch_min_explicit(
4489+ volatile atomic_uintptr_t __global *object, intptr_t opermax,
4490+ memory_order minder, memory_scope scope);
4491+uintptr_t __ovld atomic_fetch_min_explicit(
4492+ volatile atomic_uintptr_t __local *object, intptr_t opermax,
4493+ memory_order minder, memory_scope scope);
4494+uintptr_t __ovld atomic_fetch_max_explicit(
4495+ volatile atomic_uintptr_t __global *object, intptr_t opermax,
4496+ memory_order minder, memory_scope scope);
4497+uintptr_t __ovld atomic_fetch_max_explicit(
4498+ volatile atomic_uintptr_t __local *object, intptr_t opermax,
4499+ memory_order minder, memory_scope scope);
4500+
4501+intptr_t __ovld atomic_fetch_or_explicit(
4502+ volatile atomic_intptr_t __global *object, uintptr_t operand,
4503+ memory_order order, memory_scope scope);
4504+intptr_t __ovld atomic_fetch_or_explicit(
4505+ volatile atomic_intptr_t __local *object, uintptr_t operand,
4506+ memory_order order, memory_scope scope);
4507+intptr_t __ovld atomic_fetch_xor_explicit(
4508+ volatile atomic_intptr_t __global *object, uintptr_t operand,
4509+ memory_order order, memory_scope scope);
4510+intptr_t __ovld atomic_fetch_xor_explicit(
4511+ volatile atomic_intptr_t __local *object, uintptr_t operand,
4512+ memory_order order, memory_scope scope);
4513+intptr_t __ovld atomic_fetch_and_explicit(
4514+ volatile atomic_intptr_t __global *object, uintptr_t operand,
4515+ memory_order order, memory_scope scope);
4516+intptr_t __ovld atomic_fetch_and_explicit(
4517+ volatile atomic_intptr_t __local *object, uintptr_t operand,
4518+ memory_order order, memory_scope scope);
4519+intptr_t __ovld atomic_fetch_min_explicit(
4520+ volatile atomic_intptr_t __global *object, uintptr_t opermax,
4521+ memory_order minder, memory_scope scope);
4522+intptr_t __ovld atomic_fetch_min_explicit(
4523+ volatile atomic_intptr_t __local *object, uintptr_t opermax,
4524+ memory_order minder, memory_scope scope);
4525+intptr_t __ovld atomic_fetch_max_explicit(
4526+ volatile atomic_intptr_t __global *object, uintptr_t opermax,
4527+ memory_order minder, memory_scope scope);
4528+intptr_t __ovld atomic_fetch_max_explicit(
4529+ volatile atomic_intptr_t __local *object, uintptr_t opermax,
4530+ memory_order minder, memory_scope scope);
4531+#endif // defined(cl_khr_int64_base_atomics) &&
4532+ // defined(cl_khr_int64_extended_atomics)
4533+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4534
4535 // atomic_store()
4536
4537+#if defined(__opencl_c_atomic_scope_device) && \
4538+ defined(__opencl_c_atomic_order_seq_cst)
4539+
4540+#ifdef __opencl_c_generic_address_space
4541 void __ovld atomic_store(volatile atomic_int *object, int desired);
4542-void __ovld atomic_store_explicit(volatile atomic_int *object, int desired, memory_order order);
4543-void __ovld atomic_store_explicit(volatile atomic_int *object, int desired, memory_order order, memory_scope scope);
4544 void __ovld atomic_store(volatile atomic_uint *object, uint desired);
4545-void __ovld atomic_store_explicit(volatile atomic_uint *object, uint desired, memory_order order);
4546-void __ovld atomic_store_explicit(volatile atomic_uint *object, uint desired, memory_order order, memory_scope scope);
4547 void __ovld atomic_store(volatile atomic_float *object, float desired);
4548-void __ovld atomic_store_explicit(volatile atomic_float *object, float desired, memory_order order);
4549-void __ovld atomic_store_explicit(volatile atomic_float *object, float desired, memory_order order, memory_scope scope);
4550 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4551-#ifdef cl_khr_fp64
4552+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4553 void __ovld atomic_store(volatile atomic_double *object, double desired);
4554-void __ovld atomic_store_explicit(volatile atomic_double *object, double desired, memory_order order);
4555-void __ovld atomic_store_explicit(volatile atomic_double *object, double desired, memory_order order, memory_scope scope);
4556-#endif //cl_khr_fp64
4557+#endif
4558 void __ovld atomic_store(volatile atomic_long *object, long desired);
4559-void __ovld atomic_store_explicit(volatile atomic_long *object, long desired, memory_order order);
4560-void __ovld atomic_store_explicit(volatile atomic_long *object, long desired, memory_order order, memory_scope scope);
4561 void __ovld atomic_store(volatile atomic_ulong *object, ulong desired);
4562-void __ovld atomic_store_explicit(volatile atomic_ulong *object, ulong desired, memory_order order);
4563-void __ovld atomic_store_explicit(volatile atomic_ulong *object, ulong desired, memory_order order, memory_scope scope);
4564+#endif // defined(cl_khr_int64_base_atomics) &&
4565+ // defined(cl_khr_int64_extended_atomics)
4566+#endif // __opencl_c_generic_address_space
4567+
4568+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4569+void __ovld atomic_store(volatile atomic_int __global *object, int desired);
4570+void __ovld atomic_store(volatile atomic_int __local *object, int desired);
4571+void __ovld atomic_store(volatile atomic_uint __global *object, uint desired);
4572+void __ovld atomic_store(volatile atomic_uint __local *object, uint desired);
4573+void __ovld atomic_store(volatile atomic_float __global *object, float desired);
4574+void __ovld atomic_store(volatile atomic_float __local *object, float desired);
4575+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4576+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4577+void __ovld atomic_store(volatile atomic_double __global *object,
4578+ double desired);
4579+void __ovld atomic_store(volatile atomic_double __local *object,
4580+ double desired);
4581 #endif
4582+void __ovld atomic_store(volatile atomic_long __global *object, long desired);
4583+void __ovld atomic_store(volatile atomic_long __local *object, long desired);
4584+void __ovld atomic_store(volatile atomic_ulong __global *object, ulong desired);
4585+void __ovld atomic_store(volatile atomic_ulong __local *object, ulong desired);
4586+#endif // defined(cl_khr_int64_base_atomics) &&
4587+ // defined(cl_khr_int64_extended_atomics)
4588+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4589+
4590+#endif // defined(__opencl_c_atomic_scope_device) &&
4591+ // defined(__opencl_c_atomic_order_seq_cst)
4592+
4593+#ifdef __opencl_c_generic_address_space
4594+#ifdef __opencl_c_atomic_scope_device
4595+void __ovld atomic_store_explicit(volatile atomic_int *object, int desired,
4596+ memory_order order);
4597+void __ovld atomic_store_explicit(volatile atomic_uint *object, uint desired,
4598+ memory_order order);
4599+void __ovld atomic_store_explicit(volatile atomic_float *object, float desired,
4600+ memory_order order);
4601+#endif // __opencl_c_atomic_scope_device
4602+void __ovld atomic_store_explicit(volatile atomic_int *object, int desired,
4603+ memory_order order, memory_scope scope);
4604+void __ovld atomic_store_explicit(volatile atomic_uint *object, uint desired,
4605+ memory_order order, memory_scope scope);
4606+void __ovld atomic_store_explicit(volatile atomic_float *object, float desired,
4607+ memory_order order, memory_scope scope);
4608+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4609+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4610+#ifdef __opencl_c_atomic_scope_device
4611+void __ovld atomic_store_explicit(volatile atomic_double *object,
4612+ double desired, memory_order order);
4613+#endif //__opencl_c_atomic_scope_device
4614+void __ovld atomic_store_explicit(volatile atomic_double *object,
4615+ double desired, memory_order order,
4616+ memory_scope scope);
4617+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4618+#ifdef __opencl_c_atomic_scope_device
4619+void __ovld atomic_store_explicit(volatile atomic_long *object, long desired,
4620+ memory_order order);
4621+void __ovld atomic_store_explicit(volatile atomic_ulong *object, ulong desired,
4622+ memory_order order);
4623+#endif //__opencl_c_atomic_scope_device
4624+void __ovld atomic_store_explicit(volatile atomic_long *object, long desired,
4625+ memory_order order, memory_scope scope);
4626+void __ovld atomic_store_explicit(volatile atomic_ulong *object, ulong desired,
4627+ memory_order order, memory_scope scope);
4628+#endif // defined(cl_khr_int64_base_atomics) &&
4629+ // defined(cl_khr_int64_extended_atomics)
4630+#endif // __opencl_c_generic_address_space
4631+
4632+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4633+#ifdef __opencl_c_atomic_scope_device
4634+void __ovld atomic_store_explicit(volatile atomic_int __global *object,
4635+ int desired, memory_order order);
4636+void __ovld atomic_store_explicit(volatile atomic_int __local *object,
4637+ int desired, memory_order order);
4638+void __ovld atomic_store_explicit(volatile atomic_uint __global *object,
4639+ uint desired, memory_order order);
4640+void __ovld atomic_store_explicit(volatile atomic_uint __local *object,
4641+ uint desired, memory_order order);
4642+void __ovld atomic_store_explicit(volatile atomic_float __global *object,
4643+ float desired, memory_order order);
4644+void __ovld atomic_store_explicit(volatile atomic_float __local *object,
4645+ float desired, memory_order order);
4646+#endif // __opencl_c_atomic_scope_device
4647+void __ovld atomic_store_explicit(volatile atomic_int __global *object,
4648+ int desired, memory_order order,
4649+ memory_scope scope);
4650+void __ovld atomic_store_explicit(volatile atomic_int __local *object,
4651+ int desired, memory_order order,
4652+ memory_scope scope);
4653+void __ovld atomic_store_explicit(volatile atomic_uint __global *object,
4654+ uint desired, memory_order order,
4655+ memory_scope scope);
4656+void __ovld atomic_store_explicit(volatile atomic_uint __local *object,
4657+ uint desired, memory_order order,
4658+ memory_scope scope);
4659+void __ovld atomic_store_explicit(volatile atomic_float __global *object,
4660+ float desired, memory_order order,
4661+ memory_scope scope);
4662+void __ovld atomic_store_explicit(volatile atomic_float __local *object,
4663+ float desired, memory_order order,
4664+ memory_scope scope);
4665+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4666+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4667+#ifdef __opencl_c_atomic_scope_device
4668+void __ovld atomic_store_explicit(volatile atomic_double __global *object,
4669+ double desired, memory_order order);
4670+void __ovld atomic_store_explicit(volatile atomic_double __local *object,
4671+ double desired, memory_order order);
4672+#endif //__opencl_c_atomic_scope_device
4673+void __ovld atomic_store_explicit(volatile atomic_double __global *object,
4674+ double desired, memory_order order,
4675+ memory_scope scope);
4676+void __ovld atomic_store_explicit(volatile atomic_double __local *object,
4677+ double desired, memory_order order,
4678+ memory_scope scope);
4679+#endif // cl_khr_fp64
4680+#ifdef __opencl_c_atomic_scope_device
4681+void __ovld atomic_store_explicit(volatile atomic_long __global *object,
4682+ long desired, memory_order order);
4683+void __ovld atomic_store_explicit(volatile atomic_long __local *object,
4684+ long desired, memory_order order);
4685+void __ovld atomic_store_explicit(volatile atomic_ulong __global *object,
4686+ ulong desired, memory_order order);
4687+void __ovld atomic_store_explicit(volatile atomic_ulong __local *object,
4688+ ulong desired, memory_order order);
4689+#endif // __opencl_c_atomic_scope_device
4690+void __ovld atomic_store_explicit(volatile atomic_long __global *object,
4691+ long desired, memory_order order,
4692+ memory_scope scope);
4693+void __ovld atomic_store_explicit(volatile atomic_long __local *object,
4694+ long desired, memory_order order,
4695+ memory_scope scope);
4696+void __ovld atomic_store_explicit(volatile atomic_ulong __global *object,
4697+ ulong desired, memory_order order,
4698+ memory_scope scope);
4699+void __ovld atomic_store_explicit(volatile atomic_ulong __local *object,
4700+ ulong desired, memory_order order,
4701+ memory_scope scope);
4702+#endif // defined(cl_khr_int64_base_atomics) &&
4703+ // defined(cl_khr_int64_extended_atomics)
4704+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4705
4706 // atomic_load()
4707-
4708+#ifdef __opencl_c_generic_address_space
4709+#if defined(__opencl_c_atomic_scope_device) && \
4710+ defined(__opencl_c_atomic_order_seq_cst)
4711 int __ovld atomic_load(volatile atomic_int *object);
4712-int __ovld atomic_load_explicit(volatile atomic_int *object, memory_order order);
4713-int __ovld atomic_load_explicit(volatile atomic_int *object, memory_order order, memory_scope scope);
4714 uint __ovld atomic_load(volatile atomic_uint *object);
4715-uint __ovld atomic_load_explicit(volatile atomic_uint *object, memory_order order);
4716-uint __ovld atomic_load_explicit(volatile atomic_uint *object, memory_order order, memory_scope scope);
4717 float __ovld atomic_load(volatile atomic_float *object);
4718-float __ovld atomic_load_explicit(volatile atomic_float *object, memory_order order);
4719-float __ovld atomic_load_explicit(volatile atomic_float *object, memory_order order, memory_scope scope);
4720 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4721-#ifdef cl_khr_fp64
4722+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4723 double __ovld atomic_load(volatile atomic_double *object);
4724-double __ovld atomic_load_explicit(volatile atomic_double *object, memory_order order);
4725-double __ovld atomic_load_explicit(volatile atomic_double *object, memory_order order, memory_scope scope);
4726-#endif //cl_khr_fp64
4727+#endif // cl_khr_fp64
4728 long __ovld atomic_load(volatile atomic_long *object);
4729-long __ovld atomic_load_explicit(volatile atomic_long *object, memory_order order);
4730-long __ovld atomic_load_explicit(volatile atomic_long *object, memory_order order, memory_scope scope);
4731 ulong __ovld atomic_load(volatile atomic_ulong *object);
4732-ulong __ovld atomic_load_explicit(volatile atomic_ulong *object, memory_order order);
4733-ulong __ovld atomic_load_explicit(volatile atomic_ulong *object, memory_order order, memory_scope scope);
4734-#endif
4735+#endif // defined(cl_khr_int64_base_atomics) &&
4736+ // defined(cl_khr_int64_extended_atomics)
4737+#endif // defined(__opencl_c_atomic_scope_device) &&
4738+ // defined(__opencl_c_atomic_order_seq_cst)
4739+#endif //__opencl_c_generic_address_space
4740+
4741+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4742+#if defined(__opencl_c_atomic_scope_device) && \
4743+ defined(__opencl_c_atomic_order_seq_cst)
4744+int __ovld atomic_load(volatile atomic_int __global *object);
4745+int __ovld atomic_load(volatile atomic_int __local *object);
4746+uint __ovld atomic_load(volatile atomic_uint __global *object);
4747+uint __ovld atomic_load(volatile atomic_uint __local *object);
4748+float __ovld atomic_load(volatile atomic_float __global *object);
4749+float __ovld atomic_load(volatile atomic_float __local *object);
4750+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4751+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4752+double __ovld atomic_load(volatile atomic_double __global *object);
4753+double __ovld atomic_load(volatile atomic_double __local *object);
4754+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4755+long __ovld atomic_load(volatile atomic_long __global *object);
4756+long __ovld atomic_load(volatile atomic_long __local *object);
4757+ulong __ovld atomic_load(volatile atomic_ulong __global *object);
4758+ulong __ovld atomic_load(volatile atomic_ulong __local *object);
4759+#endif // defined(cl_khr_int64_base_atomics) &&
4760+ // defined(cl_khr_int64_extended_atomics)
4761+#endif // defined(__opencl_c_atomic_scope_device) &&
4762+ // defined(__opencl_c_atomic_order_seq_cst)
4763+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4764+
4765+#ifdef __opencl_c_generic_address_space
4766+#ifdef __opencl_c_atomic_scope_device
4767+int __ovld atomic_load_explicit(volatile atomic_int *object,
4768+ memory_order order);
4769+uint __ovld atomic_load_explicit(volatile atomic_uint *object,
4770+ memory_order order);
4771+float __ovld atomic_load_explicit(volatile atomic_float *object,
4772+ memory_order order);
4773+#endif // __opencl_c_atomic_scope_device
4774+int __ovld atomic_load_explicit(volatile atomic_int *object, memory_order order,
4775+ memory_scope scope);
4776+uint __ovld atomic_load_explicit(volatile atomic_uint *object,
4777+ memory_order order, memory_scope scope);
4778+float __ovld atomic_load_explicit(volatile atomic_float *object,
4779+ memory_order order, memory_scope scope);
4780+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4781+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4782+#ifdef __opencl_c_atomic_scope_device
4783+double __ovld atomic_load_explicit(volatile atomic_double *object,
4784+ memory_order order);
4785+#endif // __opencl_c_atomic_scope_device
4786+double __ovld atomic_load_explicit(volatile atomic_double *object,
4787+ memory_order order, memory_scope scope);
4788+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4789+#ifdef __opencl_c_atomic_scope_device
4790+long __ovld atomic_load_explicit(volatile atomic_long *object,
4791+ memory_order order);
4792+ulong __ovld atomic_load_explicit(volatile atomic_ulong *object,
4793+ memory_order order);
4794+#endif //__opencl_c_atomic_scope_device
4795+long __ovld atomic_load_explicit(volatile atomic_long *object,
4796+ memory_order order, memory_scope scope);
4797+ulong __ovld atomic_load_explicit(volatile atomic_ulong *object,
4798+ memory_order order, memory_scope scope);
4799+#endif // defined(cl_khr_int64_base_atomics) &&
4800+ // defined(cl_khr_int64_extended_atomics)
4801+#endif // __opencl_c_generic_address_space
4802+
4803+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4804+#ifdef __opencl_c_atomic_scope_device
4805+int __ovld atomic_load_explicit(volatile atomic_int __global *object,
4806+ memory_order order);
4807+int __ovld atomic_load_explicit(volatile atomic_int __local *object,
4808+ memory_order order);
4809+uint __ovld atomic_load_explicit(volatile atomic_uint __global *object,
4810+ memory_order order);
4811+uint __ovld atomic_load_explicit(volatile atomic_uint __local *object,
4812+ memory_order order);
4813+float __ovld atomic_load_explicit(volatile atomic_float __global *object,
4814+ memory_order order);
4815+float __ovld atomic_load_explicit(volatile atomic_float __local *object,
4816+ memory_order order);
4817+#endif // __opencl_c_atomic_scope_device
4818+int __ovld atomic_load_explicit(volatile atomic_int __global *object,
4819+ memory_order order, memory_scope scope);
4820+int __ovld atomic_load_explicit(volatile atomic_int __local *object,
4821+ memory_order order, memory_scope scope);
4822+uint __ovld atomic_load_explicit(volatile atomic_uint __global *object,
4823+ memory_order order, memory_scope scope);
4824+uint __ovld atomic_load_explicit(volatile atomic_uint __local *object,
4825+ memory_order order, memory_scope scope);
4826+float __ovld atomic_load_explicit(volatile atomic_float __global *object,
4827+ memory_order order, memory_scope scope);
4828+float __ovld atomic_load_explicit(volatile atomic_float __local *object,
4829+ memory_order order, memory_scope scope);
4830+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4831+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4832+#ifdef __opencl_c_atomic_scope_device
4833+double __ovld atomic_load_explicit(volatile atomic_double __global *object,
4834+ memory_order order);
4835+double __ovld atomic_load_explicit(volatile atomic_double __local *object,
4836+ memory_order order);
4837+#endif // __opencl_c_atomic_scope_device
4838+double __ovld atomic_load_explicit(volatile atomic_double __global *object,
4839+ memory_order order, memory_scope scope);
4840+double __ovld atomic_load_explicit(volatile atomic_double __local *object,
4841+ memory_order order, memory_scope scope);
4842+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4843+#ifdef __opencl_c_atomic_scope_device
4844+long __ovld atomic_load_explicit(volatile atomic_long __global *object,
4845+ memory_order order);
4846+long __ovld atomic_load_explicit(volatile atomic_long __local *object,
4847+ memory_order order);
4848+ulong __ovld atomic_load_explicit(volatile atomic_ulong __global *object,
4849+ memory_order order);
4850+ulong __ovld atomic_load_explicit(volatile atomic_ulong __local *object,
4851+ memory_order order);
4852+#endif // __opencl_c_atomic_scope_device
4853+long __ovld atomic_load_explicit(volatile atomic_long __global *object,
4854+ memory_order order, memory_scope scope);
4855+long __ovld atomic_load_explicit(volatile atomic_long __local *object,
4856+ memory_order order, memory_scope scope);
4857+ulong __ovld atomic_load_explicit(volatile atomic_ulong __global *object,
4858+ memory_order order, memory_scope scope);
4859+ulong __ovld atomic_load_explicit(volatile atomic_ulong __local *object,
4860+ memory_order order, memory_scope scope);
4861+#endif // defined(cl_khr_int64_base_atomics) &&
4862+ // defined(cl_khr_int64_extended_atomics)
4863+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4864
4865 // atomic_exchange()
4866-
4867+#ifdef __opencl_c_generic_address_space
4868+#if defined(__opencl_c_atomic_scope_device) && \
4869+ defined(__opencl_c_atomic_order_seq_cst)
4870 int __ovld atomic_exchange(volatile atomic_int *object, int desired);
4871-int __ovld atomic_exchange_explicit(volatile atomic_int *object, int desired, memory_order order);
4872-int __ovld atomic_exchange_explicit(volatile atomic_int *object, int desired, memory_order order, memory_scope scope);
4873 uint __ovld atomic_exchange(volatile atomic_uint *object, uint desired);
4874-uint __ovld atomic_exchange_explicit(volatile atomic_uint *object, uint desired, memory_order order);
4875-uint __ovld atomic_exchange_explicit(volatile atomic_uint *object, uint desired, memory_order order, memory_scope scope);
4876 float __ovld atomic_exchange(volatile atomic_float *object, float desired);
4877-float __ovld atomic_exchange_explicit(volatile atomic_float *object, float desired, memory_order order);
4878-float __ovld atomic_exchange_explicit(volatile atomic_float *object, float desired, memory_order order, memory_scope scope);
4879 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4880-#ifdef cl_khr_fp64
4881+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4882 double __ovld atomic_exchange(volatile atomic_double *object, double desired);
4883-double __ovld atomic_exchange_explicit(volatile atomic_double *object, double desired, memory_order order);
4884-double __ovld atomic_exchange_explicit(volatile atomic_double *object, double desired, memory_order order, memory_scope scope);
4885-#endif //cl_khr_fp64
4886+#endif
4887 long __ovld atomic_exchange(volatile atomic_long *object, long desired);
4888-long __ovld atomic_exchange_explicit(volatile atomic_long *object, long desired, memory_order order);
4889-long __ovld atomic_exchange_explicit(volatile atomic_long *object, long desired, memory_order order, memory_scope scope);
4890 ulong __ovld atomic_exchange(volatile atomic_ulong *object, ulong desired);
4891-ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *object, ulong desired, memory_order order);
4892-ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *object, ulong desired, memory_order order, memory_scope scope);
4893+#endif // defined(cl_khr_int64_base_atomics) &&
4894+ // defined(cl_khr_int64_extended_atomics)
4895+#endif // defined(__opencl_c_atomic_scope_device) &&
4896+ // defined(__opencl_c_atomic_order_seq_cst)
4897+#endif // __opencl_c_generic_address_space
4898+
4899+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4900+#if defined(__opencl_c_atomic_scope_device) && \
4901+ defined(__opencl_c_atomic_order_seq_cst)
4902+int __ovld atomic_exchange(volatile atomic_int __global *object, int desired);
4903+int __ovld atomic_exchange(volatile atomic_int __local *object, int desired);
4904+uint __ovld atomic_exchange(volatile atomic_uint __global *object,
4905+ uint desired);
4906+uint __ovld atomic_exchange(volatile atomic_uint __local *object, uint desired);
4907+float __ovld atomic_exchange(volatile atomic_float __global *object,
4908+ float desired);
4909+float __ovld atomic_exchange(volatile atomic_float __local *object,
4910+ float desired);
4911+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4912+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4913+double __ovld atomic_exchange(volatile atomic_double __global *object,
4914+ double desired);
4915+double __ovld atomic_exchange(volatile atomic_double __local *object,
4916+ double desired);
4917 #endif
4918+long __ovld atomic_exchange(volatile atomic_long __global *object,
4919+ long desired);
4920+long __ovld atomic_exchange(volatile atomic_long __local *object, long desired);
4921+ulong __ovld atomic_exchange(volatile atomic_ulong __global *object,
4922+ ulong desired);
4923+ulong __ovld atomic_exchange(volatile atomic_ulong __local *object,
4924+ ulong desired);
4925+#endif // defined(cl_khr_int64_base_atomics) &&
4926+ // defined(cl_khr_int64_extended_atomics)
4927+#endif // defined(__opencl_c_atomic_scope_device) &&
4928+ // defined(__opencl_c_atomic_order_seq_cst)
4929+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4930+
4931+#ifdef __opencl_c_generic_address_space
4932+#ifdef __opencl_c_atomic_scope_device
4933+int __ovld atomic_exchange_explicit(volatile atomic_int *object, int desired,
4934+ memory_order order);
4935+uint __ovld atomic_exchange_explicit(volatile atomic_uint *object, uint desired,
4936+ memory_order order);
4937+float __ovld atomic_exchange_explicit(volatile atomic_float *object,
4938+ float desired, memory_order order);
4939+#endif // __opencl_c_atomic_scope_device
4940+int __ovld atomic_exchange_explicit(volatile atomic_int *object, int desired,
4941+ memory_order order, memory_scope scope);
4942+uint __ovld atomic_exchange_explicit(volatile atomic_uint *object, uint desired,
4943+ memory_order order, memory_scope scope);
4944+float __ovld atomic_exchange_explicit(volatile atomic_float *object,
4945+ float desired, memory_order order,
4946+ memory_scope scope);
4947+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
4948+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4949+#ifdef __opencl_c_atomic_scope_device
4950+double __ovld atomic_exchange_explicit(volatile atomic_double *object,
4951+ double desired, memory_order order);
4952+#endif // __opencl_c_atomic_scope_device
4953+double __ovld atomic_exchange_explicit(volatile atomic_double *object,
4954+ double desired, memory_order order,
4955+ memory_scope scope);
4956+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
4957+#ifdef __opencl_c_atomic_scope_device
4958+long __ovld atomic_exchange_explicit(volatile atomic_long *object, long desired,
4959+ memory_order order);
4960+ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *object,
4961+ ulong desired, memory_order order);
4962+#endif // __opencl_c_atomic_scope_device
4963+long __ovld atomic_exchange_explicit(volatile atomic_long *object, long desired,
4964+ memory_order order, memory_scope scope);
4965+ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *object,
4966+ ulong desired, memory_order order,
4967+ memory_scope scope);
4968+#endif // defined(cl_khr_int64_base_atomics) &&
4969+ // defined(cl_khr_int64_extended_atomics)
4970+#endif // __opencl_c_generic_address_space
4971+
4972+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
4973+#ifdef __opencl_c_atomic_scope_device
4974+int __ovld atomic_exchange_explicit(volatile atomic_int __global *object,
4975+ int desired, memory_order order);
4976+int __ovld atomic_exchange_explicit(volatile atomic_int __local *object,
4977+ int desired, memory_order order);
4978+uint __ovld atomic_exchange_explicit(volatile atomic_uint __global *object,
4979+ uint desired, memory_order order);
4980+uint __ovld atomic_exchange_explicit(volatile atomic_uint __local *object,
4981+ uint desired, memory_order order);
4982+float __ovld atomic_exchange_explicit(volatile atomic_float __global *object,
4983+ float desired, memory_order order);
4984+float __ovld atomic_exchange_explicit(volatile atomic_float __local *object,
4985+ float desired, memory_order order);
4986+#endif // __opencl_c_atomic_scope_device
4987+int __ovld atomic_exchange_explicit(volatile atomic_int __global *object,
4988+ int desired, memory_order order,
4989+ memory_scope scope);
4990+int __ovld atomic_exchange_explicit(volatile atomic_int __local *object,
4991+ int desired, memory_order order,
4992+ memory_scope scope);
4993+uint __ovld atomic_exchange_explicit(volatile atomic_uint __global *object,
4994+ uint desired, memory_order order,
4995+ memory_scope scope);
4996+uint __ovld atomic_exchange_explicit(volatile atomic_uint __local *object,
4997+ uint desired, memory_order order,
4998+ memory_scope scope);
4999+float __ovld atomic_exchange_explicit(volatile atomic_float __global *object,
5000+ float desired, memory_order order,
5001+ memory_scope scope);
5002+float __ovld atomic_exchange_explicit(volatile atomic_float __local *object,
5003+ float desired, memory_order order,
5004+ memory_scope scope);
5005+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
5006+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
5007+#ifdef __opencl_c_atomic_scope_device
5008+double __ovld atomic_exchange_explicit(volatile atomic_double __global *object,
5009+ double desired, memory_order order);
5010+double __ovld atomic_exchange_explicit(volatile atomic_double __local *object,
5011+ double desired, memory_order order);
5012+#endif // __opencl_c_atomic_scope_device
5013+double __ovld atomic_exchange_explicit(volatile atomic_double __global *object,
5014+ double desired, memory_order order,
5015+ memory_scope scope);
5016+double __ovld atomic_exchange_explicit(volatile atomic_double __local *object,
5017+ double desired, memory_order order,
5018+ memory_scope scope);
5019+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
5020+#ifdef __opencl_c_atomic_scope_device
5021+long __ovld atomic_exchange_explicit(volatile atomic_long __global *object,
5022+ long desired, memory_order order);
5023+long __ovld atomic_exchange_explicit(volatile atomic_long __local *object,
5024+ long desired, memory_order order);
5025+ulong __ovld atomic_exchange_explicit(volatile atomic_ulong __global *object,
5026+ ulong desired, memory_order order);
5027+ulong __ovld atomic_exchange_explicit(volatile atomic_ulong __local *object,
5028+ ulong desired, memory_order order);
5029+#endif // __opencl_c_atomic_scope_device
5030+long __ovld atomic_exchange_explicit(volatile atomic_long __global *object,
5031+ long desired, memory_order order,
5032+ memory_scope scope);
5033+long __ovld atomic_exchange_explicit(volatile atomic_long __local *object,
5034+ long desired, memory_order order,
5035+ memory_scope scope);
5036+ulong __ovld atomic_exchange_explicit(volatile atomic_ulong __global *object,
5037+ ulong desired, memory_order order,
5038+ memory_scope scope);
5039+ulong __ovld atomic_exchange_explicit(volatile atomic_ulong __local *object,
5040+ ulong desired, memory_order order,
5041+ memory_scope scope);
5042+#endif // defined(cl_khr_int64_base_atomics) &&
5043+ // defined(cl_khr_int64_extended_atomics)
5044+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
5045
5046 // atomic_compare_exchange_strong() and atomic_compare_exchange_weak()
5047-
5048-bool __ovld atomic_compare_exchange_strong(volatile atomic_int *object, int *expected, int desired);
5049-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_int *object, int *expected,
5050- int desired, memory_order success, memory_order failure);
5051-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_int *object, int *expected,
5052- int desired, memory_order success, memory_order failure, memory_scope scope);
5053-bool __ovld atomic_compare_exchange_strong(volatile atomic_uint *object, uint *expected, uint desired);
5054-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_uint *object, uint *expected,
5055- uint desired, memory_order success, memory_order failure);
5056-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_uint *object, uint *expected,
5057- uint desired, memory_order success, memory_order failure, memory_scope scope);
5058-bool __ovld atomic_compare_exchange_weak(volatile atomic_int *object, int *expected, int desired);
5059-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_int *object, int *expected,
5060- int desired, memory_order success, memory_order failure);
5061-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_int *object, int *expected,
5062- int desired, memory_order success, memory_order failure, memory_scope scope);
5063-bool __ovld atomic_compare_exchange_weak(volatile atomic_uint *object, uint *expected, uint desired);
5064-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_uint *object, uint *expected,
5065- uint desired, memory_order success, memory_order failure);
5066-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_uint *object, uint *expected,
5067- uint desired, memory_order success, memory_order failure, memory_scope scope);
5068-bool __ovld atomic_compare_exchange_strong(volatile atomic_float *object, float *expected, float desired);
5069-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_float *object, float *expected,
5070- float desired, memory_order success, memory_order failure);
5071-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_float *object, float *expected,
5072- float desired, memory_order success, memory_order failure, memory_scope scope);
5073-bool __ovld atomic_compare_exchange_weak(volatile atomic_float *object, float *expected, float desired);
5074-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_float *object, float *expected,
5075- float desired, memory_order success, memory_order failure);
5076-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_float *object, float *expected,
5077- float desired, memory_order success, memory_order failure, memory_scope scope);
5078+#ifdef __opencl_c_generic_address_space
5079+#if defined(__opencl_c_atomic_scope_device) && \
5080+ defined(__opencl_c_atomic_order_seq_cst)
5081+bool __ovld atomic_compare_exchange_strong(volatile atomic_int *object,
5082+ int *expected, int desired);
5083+bool __ovld atomic_compare_exchange_strong(volatile atomic_uint *object,
5084+ uint *expected, uint desired);
5085+bool __ovld atomic_compare_exchange_weak(volatile atomic_int *object,
5086+ int *expected, int desired);
5087+bool __ovld atomic_compare_exchange_weak(volatile atomic_uint *object,
5088+ uint *expected, uint desired);
5089+bool __ovld atomic_compare_exchange_strong(volatile atomic_float *object,
5090+ float *expected, float desired);
5091+bool __ovld atomic_compare_exchange_weak(volatile atomic_float *object,
5092+ float *expected, float desired);
5093+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
5094+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
5095+bool __ovld atomic_compare_exchange_strong(volatile atomic_double *object,
5096+ double *expected, double desired);
5097+bool __ovld atomic_compare_exchange_weak(volatile atomic_double *object,
5098+ double *expected, double desired);
5099+#endif
5100+bool __ovld atomic_compare_exchange_strong(volatile atomic_long *object,
5101+ long *expected, long desired);
5102+bool __ovld atomic_compare_exchange_weak(volatile atomic_long *object,
5103+ long *expected, long desired);
5104+bool __ovld atomic_compare_exchange_strong(volatile atomic_ulong *object,
5105+ ulong *expected, ulong desired);
5106+bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong *object,
5107+ ulong *expected, ulong desired);
5108+#endif // defined(cl_khr_int64_base_atomics) &&
5109+ // defined(cl_khr_int64_extended_atomics)
5110+#endif // defined(__opencl_c_atomic_scope_device) &&
5111+ // defined(__opencl_c_atomic_order_seq_cst)
5112+#endif // __opencl_c_generic_address_space
5113+
5114+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
5115+#if defined(__opencl_c_atomic_scope_device) && \
5116+ defined(__opencl_c_atomic_order_seq_cst)
5117+bool __ovld atomic_compare_exchange_strong(volatile atomic_int __global *object,
5118+ int __global *expected, int desired);
5119+bool __ovld atomic_compare_exchange_strong(volatile atomic_int __local *object,
5120+ int __global *expected, int desired);
5121+bool __ovld atomic_compare_exchange_strong(volatile atomic_int __global *object,
5122+ int __local *expected, int desired);
5123+bool __ovld atomic_compare_exchange_strong(volatile atomic_int __local *object,
5124+ int __local *expected, int desired);
5125+bool __ovld atomic_compare_exchange_strong(volatile atomic_int __global *object,
5126+ int __private *expected,
5127+ int desired);
5128+bool __ovld atomic_compare_exchange_strong(volatile atomic_int __local *object,
5129+ int __private *expected,
5130+ int desired);
5131+bool __ovld
5132+atomic_compare_exchange_strong(volatile atomic_uint __global *object,
5133+ uint __global *expected, uint desired);
5134+bool __ovld atomic_compare_exchange_strong(volatile atomic_uint __local *object,
5135+ uint __global *expected,
5136+ uint desired);
5137+bool __ovld
5138+atomic_compare_exchange_strong(volatile atomic_uint __global *object,
5139+ uint __local *expected, uint desired);
5140+bool __ovld atomic_compare_exchange_strong(volatile atomic_uint __local *object,
5141+ uint __local *expected,
5142+ uint desired);
5143+bool __ovld
5144+atomic_compare_exchange_strong(volatile atomic_uint __global *object,
5145+ uint __private *expected, uint desired);
5146+bool __ovld atomic_compare_exchange_strong(volatile atomic_uint __local *object,
5147+ uint __private *expected,
5148+ uint desired);
5149+bool __ovld atomic_compare_exchange_weak(volatile atomic_int __global *object,
5150+ int __global *expected, int desired);
5151+bool __ovld atomic_compare_exchange_weak(volatile atomic_int __local *object,
5152+ int __global *expected, int desired);
5153+bool __ovld atomic_compare_exchange_weak(volatile atomic_int __global *object,
5154+ int __local *expected, int desired);
5155+bool __ovld atomic_compare_exchange_weak(volatile atomic_int __local *object,
5156+ int __local *expected, int desired);
5157+bool __ovld atomic_compare_exchange_weak(volatile atomic_int __global *object,
5158+ int __private *expected, int desired);
5159+bool __ovld atomic_compare_exchange_weak(volatile atomic_int __local *object,
5160+ int __private *expected, int desired);
5161+bool __ovld atomic_compare_exchange_weak(volatile atomic_uint __global *object,
5162+ uint __global *expected, uint desired);
5163+bool __ovld atomic_compare_exchange_weak(volatile atomic_uint __local *object,
5164+ uint __global *expected, uint desired);
5165+bool __ovld atomic_compare_exchange_weak(volatile atomic_uint __global *object,
5166+ uint __local *expected, uint desired);
5167+bool __ovld atomic_compare_exchange_weak(volatile atomic_uint __local *object,
5168+ uint __local *expected, uint desired);
5169+bool __ovld atomic_compare_exchange_weak(volatile atomic_uint __global *object,
5170+ uint __private *expected,
5171+ uint desired);
5172+bool __ovld atomic_compare_exchange_weak(volatile atomic_uint __local *object,
5173+ uint __private *expected,
5174+ uint desired);
5175+bool __ovld
5176+atomic_compare_exchange_strong(volatile atomic_float __global *object,
5177+ float __global *expected, float desired);
5178+bool __ovld
5179+atomic_compare_exchange_strong(volatile atomic_float __local *object,
5180+ float __global *expected, float desired);
5181+bool __ovld
5182+atomic_compare_exchange_strong(volatile atomic_float __global *object,
5183+ float __local *expected, float desired);
5184+bool __ovld
5185+atomic_compare_exchange_strong(volatile atomic_float __local *object,
5186+ float __local *expected, float desired);
5187+bool __ovld
5188+atomic_compare_exchange_strong(volatile atomic_float __global *object,
5189+ float __private *expected, float desired);
5190+bool __ovld
5191+atomic_compare_exchange_strong(volatile atomic_float __local *object,
5192+ float __private *expected, float desired);
5193+bool __ovld atomic_compare_exchange_weak(volatile atomic_float __global *object,
5194+ float __global *expected,
5195+ float desired);
5196+bool __ovld atomic_compare_exchange_weak(volatile atomic_float __local *object,
5197+ float __global *expected,
5198+ float desired);
5199+bool __ovld atomic_compare_exchange_weak(volatile atomic_float __global *object,
5200+ float __local *expected,
5201+ float desired);
5202+bool __ovld atomic_compare_exchange_weak(volatile atomic_float __local *object,
5203+ float __local *expected,
5204+ float desired);
5205+bool __ovld atomic_compare_exchange_weak(volatile atomic_float __global *object,
5206+ float __private *expected,
5207+ float desired);
5208+bool __ovld atomic_compare_exchange_weak(volatile atomic_float __local *object,
5209+ float __private *expected,
5210+ float desired);
5211 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
5212-#ifdef cl_khr_fp64
5213-bool __ovld atomic_compare_exchange_strong(volatile atomic_double *object, double *expected, double desired);
5214-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_double *object, double *expected,
5215- double desired, memory_order success, memory_order failure);
5216-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_double *object, double *expected,
5217- double desired, memory_order success, memory_order failure, memory_scope scope);
5218-bool __ovld atomic_compare_exchange_weak(volatile atomic_double *object, double *expected, double desired);
5219-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_double *object, double *expected,
5220- double desired, memory_order success, memory_order failure);
5221-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_double *object, double *expected,
5222- double desired, memory_order success, memory_order failure, memory_scope scope);
5223-#endif //cl_khr_fp64
5224-bool __ovld atomic_compare_exchange_strong(volatile atomic_long *object, long *expected, long desired);
5225-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_long *object, long *expected,
5226- long desired, memory_order success, memory_order failure);
5227-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_long *object, long *expected,
5228- long desired, memory_order success, memory_order failure, memory_scope scope);
5229-bool __ovld atomic_compare_exchange_weak(volatile atomic_long *object, long *expected, long desired);
5230-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_long *object, long *expected,
5231- long desired, memory_order success, memory_order failure);
5232-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_long *object, long *expected,
5233- long desired, memory_order success, memory_order failure, memory_scope scope);
5234-bool __ovld atomic_compare_exchange_strong(volatile atomic_ulong *object, ulong *expected, ulong desired);
5235-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_ulong *object, ulong *expected,
5236- ulong desired, memory_order success, memory_order failure);
5237-bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_ulong *object, ulong *expected,
5238- ulong desired, memory_order success, memory_order failure, memory_scope scope);
5239-bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong *object, ulong *expected, ulong desired);
5240-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_ulong *object, ulong *expected,
5241- ulong desired, memory_order success, memory_order failure);
5242-bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_ulong *object, ulong *expected,
5243- ulong desired, memory_order success, memory_order failure, memory_scope scope);
5244+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
5245+bool __ovld
5246+atomic_compare_exchange_strong(volatile atomic_double __global *object,
5247+ double __global *expected, double desired);
5248+bool __ovld
5249+atomic_compare_exchange_strong(volatile atomic_double __local *object,
5250+ double __global *expected, double desired);
5251+bool __ovld
5252+atomic_compare_exchange_strong(volatile atomic_double __global *object,
5253+ double __local *expected, double desired);
5254+bool __ovld
5255+atomic_compare_exchange_strong(volatile atomic_double __local *object,
5256+ double __local *expected, double desired);
5257+bool __ovld
5258+atomic_compare_exchange_strong(volatile atomic_double __global *object,
5259+ double __private *expected, double desired);
5260+bool __ovld
5261+atomic_compare_exchange_strong(volatile atomic_double __local *object,
5262+ double __private *expected, double desired);
5263+bool __ovld
5264+atomic_compare_exchange_weak(volatile atomic_double __global *object,
5265+ double __global *expected, double desired);
5266+bool __ovld atomic_compare_exchange_weak(volatile atomic_double __local *object,
5267+ double __global *expected,
5268+ double desired);
5269+bool __ovld
5270+atomic_compare_exchange_weak(volatile atomic_double __global *object,
5271+ double __local *expected, double desired);
5272+bool __ovld atomic_compare_exchange_weak(volatile atomic_double __local *object,
5273+ double __local *expected,
5274+ double desired);
5275+bool __ovld
5276+atomic_compare_exchange_weak(volatile atomic_double __global *object,
5277+ double __private *expected, double desired);
5278+bool __ovld atomic_compare_exchange_weak(volatile atomic_double __local *object,
5279+ double __private *expected,
5280+ double desired);
5281 #endif
5282+bool __ovld
5283+atomic_compare_exchange_strong(volatile atomic_long __global *object,
5284+ long __global *expected, long desired);
5285+bool __ovld atomic_compare_exchange_strong(volatile atomic_long __local *object,
5286+ long __global *expected,
5287+ long desired);
5288+bool __ovld
5289+atomic_compare_exchange_strong(volatile atomic_long __global *object,
5290+ long __local *expected, long desired);
5291+bool __ovld atomic_compare_exchange_strong(volatile atomic_long __local *object,
5292+ long __local *expected,
5293+ long desired);
5294+bool __ovld
5295+atomic_compare_exchange_strong(volatile atomic_long __global *object,
5296+ long __private *expected, long desired);
5297+bool __ovld atomic_compare_exchange_strong(volatile atomic_long __local *object,
5298+ long __private *expected,
5299+ long desired);
5300+bool __ovld atomic_compare_exchange_weak(volatile atomic_long __global *object,
5301+ long __global *expected, long desired);
5302+bool __ovld atomic_compare_exchange_weak(volatile atomic_long __local *object,
5303+ long __global *expected, long desired);
5304+bool __ovld atomic_compare_exchange_weak(volatile atomic_long __global *object,
5305+ long __local *expected, long desired);
5306+bool __ovld atomic_compare_exchange_weak(volatile atomic_long __local *object,
5307+ long __local *expected, long desired);
5308+bool __ovld atomic_compare_exchange_weak(volatile atomic_long __global *object,
5309+ long __private *expected,
5310+ long desired);
5311+bool __ovld atomic_compare_exchange_weak(volatile atomic_long __local *object,
5312+ long __private *expected,
5313+ long desired);
5314+bool __ovld
5315+atomic_compare_exchange_strong(volatile atomic_ulong __global *object,
5316+ ulong __global *expected, ulong desired);
5317+bool __ovld
5318+atomic_compare_exchange_strong(volatile atomic_ulong __local *object,
5319+ ulong __global *expected, ulong desired);
5320+bool __ovld
5321+atomic_compare_exchange_strong(volatile atomic_ulong __global *object,
5322+ ulong __local *expected, ulong desired);
5323+bool __ovld
5324+atomic_compare_exchange_strong(volatile atomic_ulong __local *object,
5325+ ulong __local *expected, ulong desired);
5326+bool __ovld
5327+atomic_compare_exchange_strong(volatile atomic_ulong __global *object,
5328+ ulong __private *expected, ulong desired);
5329+bool __ovld
5330+atomic_compare_exchange_strong(volatile atomic_ulong __local *object,
5331+ ulong __private *expected, ulong desired);
5332+bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong __global *object,
5333+ ulong __global *expected,
5334+ ulong desired);
5335+bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong __local *object,
5336+ ulong __global *expected,
5337+ ulong desired);
5338+bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong __global *object,
5339+ ulong __local *expected,
5340+ ulong desired);
5341+bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong __local *object,
5342+ ulong __local *expected,
5343+ ulong desired);
5344+bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong __global *object,
5345+ ulong __private *expected,
5346+ ulong desired);
5347+bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong __local *object,
5348+ ulong __private *expected,
5349+ ulong desired);
5350+#endif // defined(cl_khr_int64_base_atomics) &&
5351+ // defined(cl_khr_int64_extended_atomics)
5352+#endif // defined(__opencl_c_atomic_scope_device) &&
5353+ // defined(__opencl_c_atomic_order_seq_cst)
5354+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
5355+
5356+#ifdef __opencl_c_generic_address_space
5357+#ifdef __opencl_c_atomic_scope_device
5358+bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_int *object,
5359+ int *expected, int desired,
5360+ memory_order success,
5361+ memory_order failure);
5362+bool __ovld atomic_compare_exchange_strong_explicit(
5363+ volatile atomic_uint *object, uint *expected, uint desired,
5364+ memory_order success, memory_order failure);
5365+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_int *object,
5366+ int *expected, int desired,
5367+ memory_order success,
5368+ memory_order failure);
5369+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_uint *object,
5370+ uint *expected, uint desired,
5371+ memory_order success,
5372+ memory_order failure);
5373+bool __ovld atomic_compare_exchange_strong_explicit(
5374+ volatile atomic_float *object, float *expected, float desired,
5375+ memory_order success, memory_order failure);
5376+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_float *object,
5377+ float *expected,
5378+ float desired,
5379+ memory_order success,
5380+ memory_order failure);
5381+#endif // __opencl_c_atomic_scope_device
5382+bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_int *object,
5383+ int *expected, int desired,
5384+ memory_order success,
5385+ memory_order failure,
5386+ memory_scope scope);
5387+bool __ovld atomic_compare_exchange_strong_explicit(
5388+ volatile atomic_uint *object, uint *expected, uint desired,
5389+ memory_order success, memory_order failure, memory_scope scope);
5390+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_int *object,
5391+ int *expected, int desired,
5392+ memory_order success,
5393+ memory_order failure,
5394+ memory_scope scope);
5395+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_uint *object,
5396+ uint *expected, uint desired,
5397+ memory_order success,
5398+ memory_order failure,
5399+ memory_scope scope);
5400+bool __ovld atomic_compare_exchange_strong_explicit(
5401+ volatile atomic_float *object, float *expected, float desired,
5402+ memory_order success, memory_order failure, memory_scope scope);
5403+bool __ovld atomic_compare_exchange_weak_explicit(
5404+ volatile atomic_float *object, float *expected, float desired,
5405+ memory_order success, memory_order failure, memory_scope scope);
5406+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
5407+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
5408+#ifdef __opencl_c_atomic_scope_device
5409+bool __ovld atomic_compare_exchange_strong_explicit(
5410+ volatile atomic_double *object, double *expected, double desired,
5411+ memory_order success, memory_order failure);
5412+bool __ovld atomic_compare_exchange_weak_explicit(
5413+ volatile atomic_double *object, double *expected, double desired,
5414+ memory_order success, memory_order failure);
5415+#endif // __opencl_c_atomic_scope_device
5416+bool __ovld atomic_compare_exchange_strong_explicit(
5417+ volatile atomic_double *object, double *expected, double desired,
5418+ memory_order success, memory_order failure, memory_scope scope);
5419+bool __ovld atomic_compare_exchange_weak_explicit(
5420+ volatile atomic_double *object, double *expected, double desired,
5421+ memory_order success, memory_order failure, memory_scope scope);
5422+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
5423+#ifdef __opencl_c_atomic_scope_device
5424+bool __ovld atomic_compare_exchange_strong_explicit(
5425+ volatile atomic_long *object, long *expected, long desired,
5426+ memory_order success, memory_order failure);
5427+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_long *object,
5428+ long *expected, long desired,
5429+ memory_order success,
5430+ memory_order failure);
5431+bool __ovld atomic_compare_exchange_strong_explicit(
5432+ volatile atomic_ulong *object, ulong *expected, ulong desired,
5433+ memory_order success, memory_order failure);
5434+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_ulong *object,
5435+ ulong *expected,
5436+ ulong desired,
5437+ memory_order success,
5438+ memory_order failure);
5439+#endif // __opencl_c_atomic_scope_device
5440+bool __ovld atomic_compare_exchange_strong_explicit(
5441+ volatile atomic_long *object, long *expected, long desired,
5442+ memory_order success, memory_order failure, memory_scope scope);
5443+bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_long *object,
5444+ long *expected, long desired,
5445+ memory_order success,
5446+ memory_order failure,
5447+ memory_scope scope);
5448+bool __ovld atomic_compare_exchange_strong_explicit(
5449+ volatile atomic_ulong *object, ulong *expected, ulong desired,
5450+ memory_order success, memory_order failure, memory_scope scope);
5451+bool __ovld atomic_compare_exchange_weak_explicit(
5452+ volatile atomic_ulong *object, ulong *expected, ulong desired,
5453+ memory_order success, memory_order failure, memory_scope scope);
5454+#endif // defined(cl_khr_int64_base_atomics) &&
5455+ // defined(cl_khr_int64_extended_atomics)
5456+#endif // __opencl_c_generic_address_space
5457+
5458+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
5459+#ifdef __opencl_c_atomic_scope_device
5460+bool __ovld atomic_compare_exchange_strong_explicit(
5461+ volatile atomic_int __global *object, int __global *expected, int desired,
5462+ memory_order success, memory_order failure);
5463+bool __ovld atomic_compare_exchange_strong_explicit(
5464+ volatile atomic_int __local *object, int __global *expected, int desired,
5465+ memory_order success, memory_order failure);
5466+bool __ovld atomic_compare_exchange_strong_explicit(
5467+ volatile atomic_int __global *object, int __local *expected, int desired,
5468+ memory_order success, memory_order failure);
5469+bool __ovld atomic_compare_exchange_strong_explicit(
5470+ volatile atomic_int __local *object, int __local *expected, int desired,
5471+ memory_order success, memory_order failure);
5472+bool __ovld atomic_compare_exchange_strong_explicit(
5473+ volatile atomic_int __global *object, int __private *expected, int desired,
5474+ memory_order success, memory_order failure);
5475+bool __ovld atomic_compare_exchange_strong_explicit(
5476+ volatile atomic_int __local *object, int __private *expected, int desired,
5477+ memory_order success, memory_order failure);
5478+bool __ovld atomic_compare_exchange_strong_explicit(
5479+ volatile atomic_uint __global *object, uint __global *expected,
5480+ uint desired, memory_order success, memory_order failure);
5481+bool __ovld atomic_compare_exchange_strong_explicit(
5482+ volatile atomic_uint __local *object, uint __global *expected, uint desired,
5483+ memory_order success, memory_order failure);
5484+bool __ovld atomic_compare_exchange_strong_explicit(
5485+ volatile atomic_uint __global *object, uint __local *expected, uint desired,
5486+ memory_order success, memory_order failure);
5487+bool __ovld atomic_compare_exchange_strong_explicit(
5488+ volatile atomic_uint __local *object, uint __local *expected, uint desired,
5489+ memory_order success, memory_order failure);
5490+bool __ovld atomic_compare_exchange_strong_explicit(
5491+ volatile atomic_uint __global *object, uint __private *expected,
5492+ uint desired, memory_order success, memory_order failure);
5493+bool __ovld atomic_compare_exchange_strong_explicit(
5494+ volatile atomic_uint __local *object, uint __private *expected,
5495+ uint desired, memory_order success, memory_order failure);
5496+bool __ovld atomic_compare_exchange_weak_explicit(
5497+ volatile atomic_int __global *object, int __global *expected, int desired,
5498+ memory_order success, memory_order failure);
5499+bool __ovld atomic_compare_exchange_weak_explicit(
5500+ volatile atomic_int __local *object, int __global *expected, int desired,
5501+ memory_order success, memory_order failure);
5502+bool __ovld atomic_compare_exchange_weak_explicit(
5503+ volatile atomic_int __global *object, int __local *expected, int desired,
5504+ memory_order success, memory_order failure);
5505+bool __ovld atomic_compare_exchange_weak_explicit(
5506+ volatile atomic_int __local *object, int __local *expected, int desired,
5507+ memory_order success, memory_order failure);
5508+bool __ovld atomic_compare_exchange_weak_explicit(
5509+ volatile atomic_int __global *object, int __private *expected, int desired,
5510+ memory_order success, memory_order failure);
5511+bool __ovld atomic_compare_exchange_weak_explicit(
5512+ volatile atomic_int __local *object, int __private *expected, int desired,
5513+ memory_order success, memory_order failure);
5514+bool __ovld atomic_compare_exchange_weak_explicit(
5515+ volatile atomic_uint __global *object, uint __global *expected,
5516+ uint desired, memory_order success, memory_order failure);
5517+bool __ovld atomic_compare_exchange_weak_explicit(
5518+ volatile atomic_uint __local *object, uint __global *expected, uint desired,
5519+ memory_order success, memory_order failure);
5520+bool __ovld atomic_compare_exchange_weak_explicit(
5521+ volatile atomic_uint __global *object, uint __local *expected, uint desired,
5522+ memory_order success, memory_order failure);
5523+bool __ovld atomic_compare_exchange_weak_explicit(
5524+ volatile atomic_uint __local *object, uint __local *expected, uint desired,
5525+ memory_order success, memory_order failure);
5526+bool __ovld atomic_compare_exchange_weak_explicit(
5527+ volatile atomic_uint __global *object, uint __private *expected,
5528+ uint desired, memory_order success, memory_order failure);
5529+bool __ovld atomic_compare_exchange_weak_explicit(
5530+ volatile atomic_uint __local *object, uint __private *expected,
5531+ uint desired, memory_order success, memory_order failure);
5532+bool __ovld atomic_compare_exchange_strong_explicit(
5533+ volatile atomic_float __global *object, float __global *expected,
5534+ float desired, memory_order success, memory_order failure);
5535+bool __ovld atomic_compare_exchange_strong_explicit(
5536+ volatile atomic_float __local *object, float __global *expected,
5537+ float desired, memory_order success, memory_order failure);
5538+bool __ovld atomic_compare_exchange_strong_explicit(
5539+ volatile atomic_float __global *object, float __local *expected,
5540+ float desired, memory_order success, memory_order failure);
5541+bool __ovld atomic_compare_exchange_strong_explicit(
5542+ volatile atomic_float __local *object, float __local *expected,
5543+ float desired, memory_order success, memory_order failure);
5544+bool __ovld atomic_compare_exchange_strong_explicit(
5545+ volatile atomic_float __global *object, float __private *expected,
5546+ float desired, memory_order success, memory_order failure);
5547+bool __ovld atomic_compare_exchange_strong_explicit(
5548+ volatile atomic_float __local *object, float __private *expected,
5549+ float desired, memory_order success, memory_order failure);
5550+bool __ovld atomic_compare_exchange_weak_explicit(
5551+ volatile atomic_float __global *object, float __global *expected,
5552+ float desired, memory_order success, memory_order failure);
5553+bool __ovld atomic_compare_exchange_weak_explicit(
5554+ volatile atomic_float __local *object, float __global *expected,
5555+ float desired, memory_order success, memory_order failure);
5556+bool __ovld atomic_compare_exchange_weak_explicit(
5557+ volatile atomic_float __global *object, float __local *expected,
5558+ float desired, memory_order success, memory_order failure);
5559+bool __ovld atomic_compare_exchange_weak_explicit(
5560+ volatile atomic_float __local *object, float __local *expected,
5561+ float desired, memory_order success, memory_order failure);
5562+bool __ovld atomic_compare_exchange_weak_explicit(
5563+ volatile atomic_float __global *object, float __private *expected,
5564+ float desired, memory_order success, memory_order failure);
5565+bool __ovld atomic_compare_exchange_weak_explicit(
5566+ volatile atomic_float __local *object, float __private *expected,
5567+ float desired, memory_order success, memory_order failure);
5568+#endif // __opencl_c_atomic_scope_device
5569+bool __ovld atomic_compare_exchange_strong_explicit(
5570+ volatile atomic_int __global *object, int __global *expected, int desired,
5571+ memory_order success, memory_order failure, memory_scope scope);
5572+bool __ovld atomic_compare_exchange_strong_explicit(
5573+ volatile atomic_int __local *object, int __global *expected, int desired,
5574+ memory_order success, memory_order failure, memory_scope scope);
5575+bool __ovld atomic_compare_exchange_strong_explicit(
5576+ volatile atomic_int __global *object, int __local *expected, int desired,
5577+ memory_order success, memory_order failure, memory_scope scope);
5578+bool __ovld atomic_compare_exchange_strong_explicit(
5579+ volatile atomic_int __local *object, int __local *expected, int desired,
5580+ memory_order success, memory_order failure, memory_scope scope);
5581+bool __ovld atomic_compare_exchange_strong_explicit(
5582+ volatile atomic_int __global *object, int __private *expected, int desired,
5583+ memory_order success, memory_order failure, memory_scope scope);
5584+bool __ovld atomic_compare_exchange_strong_explicit(
5585+ volatile atomic_int __local *object, int __private *expected, int desired,
5586+ memory_order success, memory_order failure, memory_scope scope);
5587+bool __ovld atomic_compare_exchange_strong_explicit(
5588+ volatile atomic_uint __global *object, uint __global *expected,
5589+ uint desired, memory_order success, memory_order failure,
5590+ memory_scope scope);
5591+bool __ovld atomic_compare_exchange_strong_explicit(
5592+ volatile atomic_uint __local *object, uint __global *expected, uint desired,
5593+ memory_order success, memory_order failure, memory_scope scope);
5594+bool __ovld atomic_compare_exchange_strong_explicit(
5595+ volatile atomic_uint __global *object, uint __local *expected, uint desired,
5596+ memory_order success, memory_order failure, memory_scope scope);
5597+bool __ovld atomic_compare_exchange_strong_explicit(
5598+ volatile atomic_uint __local *object, uint __local *expected, uint desired,
5599+ memory_order success, memory_order failure, memory_scope scope);
5600+bool __ovld atomic_compare_exchange_strong_explicit(
5601+ volatile atomic_uint __global *object, uint __private *expected,
5602+ uint desired, memory_order success, memory_order failure,
5603+ memory_scope scope);
5604+bool __ovld atomic_compare_exchange_strong_explicit(
5605+ volatile atomic_uint __local *object, uint __private *expected,
5606+ uint desired, memory_order success, memory_order failure,
5607+ memory_scope scope);
5608+bool __ovld atomic_compare_exchange_weak_explicit(
5609+ volatile atomic_int __global *object, int __global *expected, int desired,
5610+ memory_order success, memory_order failure, memory_scope scope);
5611+bool __ovld atomic_compare_exchange_weak_explicit(
5612+ volatile atomic_int __local *object, int __global *expected, int desired,
5613+ memory_order success, memory_order failure, memory_scope scope);
5614+bool __ovld atomic_compare_exchange_weak_explicit(
5615+ volatile atomic_int __global *object, int __local *expected, int desired,
5616+ memory_order success, memory_order failure, memory_scope scope);
5617+bool __ovld atomic_compare_exchange_weak_explicit(
5618+ volatile atomic_int __local *object, int __local *expected, int desired,
5619+ memory_order success, memory_order failure, memory_scope scope);
5620+bool __ovld atomic_compare_exchange_weak_explicit(
5621+ volatile atomic_int __global *object, int __private *expected, int desired,
5622+ memory_order success, memory_order failure, memory_scope scope);
5623+bool __ovld atomic_compare_exchange_weak_explicit(
5624+ volatile atomic_int __local *object, int __private *expected, int desired,
5625+ memory_order success, memory_order failure, memory_scope scope);
5626+bool __ovld atomic_compare_exchange_weak_explicit(
5627+ volatile atomic_uint __global *object, uint __global *expected,
5628+ uint desired, memory_order success, memory_order failure,
5629+ memory_scope scope);
5630+bool __ovld atomic_compare_exchange_weak_explicit(
5631+ volatile atomic_uint __local *object, uint __global *expected, uint desired,
5632+ memory_order success, memory_order failure, memory_scope scope);
5633+bool __ovld atomic_compare_exchange_weak_explicit(
5634+ volatile atomic_uint __global *object, uint __local *expected, uint desired,
5635+ memory_order success, memory_order failure, memory_scope scope);
5636+bool __ovld atomic_compare_exchange_weak_explicit(
5637+ volatile atomic_uint __local *object, uint __local *expected, uint desired,
5638+ memory_order success, memory_order failure, memory_scope scope);
5639+bool __ovld atomic_compare_exchange_weak_explicit(
5640+ volatile atomic_uint __global *object, uint __private *expected,
5641+ uint desired, memory_order success, memory_order failure,
5642+ memory_scope scope);
5643+bool __ovld atomic_compare_exchange_weak_explicit(
5644+ volatile atomic_uint __local *object, uint __private *expected,
5645+ uint desired, memory_order success, memory_order failure,
5646+ memory_scope scope);
5647+bool __ovld atomic_compare_exchange_strong_explicit(
5648+ volatile atomic_float __global *object, float __global *expected,
5649+ float desired, memory_order success, memory_order failure,
5650+ memory_scope scope);
5651+bool __ovld atomic_compare_exchange_strong_explicit(
5652+ volatile atomic_float __local *object, float __global *expected,
5653+ float desired, memory_order success, memory_order failure,
5654+ memory_scope scope);
5655+bool __ovld atomic_compare_exchange_strong_explicit(
5656+ volatile atomic_float __global *object, float __local *expected,
5657+ float desired, memory_order success, memory_order failure,
5658+ memory_scope scope);
5659+bool __ovld atomic_compare_exchange_strong_explicit(
5660+ volatile atomic_float __local *object, float __local *expected,
5661+ float desired, memory_order success, memory_order failure,
5662+ memory_scope scope);
5663+bool __ovld atomic_compare_exchange_strong_explicit(
5664+ volatile atomic_float __global *object, float __private *expected,
5665+ float desired, memory_order success, memory_order failure,
5666+ memory_scope scope);
5667+bool __ovld atomic_compare_exchange_strong_explicit(
5668+ volatile atomic_float __local *object, float __private *expected,
5669+ float desired, memory_order success, memory_order failure,
5670+ memory_scope scope);
5671+bool __ovld atomic_compare_exchange_weak_explicit(
5672+ volatile atomic_float __global *object, float __global *expected,
5673+ float desired, memory_order success, memory_order failure,
5674+ memory_scope scope);
5675+bool __ovld atomic_compare_exchange_weak_explicit(
5676+ volatile atomic_float __local *object, float __global *expected,
5677+ float desired, memory_order success, memory_order failure,
5678+ memory_scope scope);
5679+bool __ovld atomic_compare_exchange_weak_explicit(
5680+ volatile atomic_float __global *object, float __local *expected,
5681+ float desired, memory_order success, memory_order failure,
5682+ memory_scope scope);
5683+bool __ovld atomic_compare_exchange_weak_explicit(
5684+ volatile atomic_float __local *object, float __local *expected,
5685+ float desired, memory_order success, memory_order failure,
5686+ memory_scope scope);
5687+bool __ovld atomic_compare_exchange_weak_explicit(
5688+ volatile atomic_float __global *object, float __private *expected,
5689+ float desired, memory_order success, memory_order failure,
5690+ memory_scope scope);
5691+bool __ovld atomic_compare_exchange_weak_explicit(
5692+ volatile atomic_float __local *object, float __private *expected,
5693+ float desired, memory_order success, memory_order failure,
5694+ memory_scope scope);
5695+#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
5696+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
5697+#ifdef __opencl_c_atomic_scope_device
5698+bool __ovld atomic_compare_exchange_strong_explicit(
5699+ volatile atomic_double __global *object, double __global *expected,
5700+ double desired, memory_order success, memory_order failure);
5701+bool __ovld atomic_compare_exchange_strong_explicit(
5702+ volatile atomic_double __local *object, double __global *expected,
5703+ double desired, memory_order success, memory_order failure);
5704+bool __ovld atomic_compare_exchange_strong_explicit(
5705+ volatile atomic_double __global *object, double __local *expected,
5706+ double desired, memory_order success, memory_order failure);
5707+bool __ovld atomic_compare_exchange_strong_explicit(
5708+ volatile atomic_double __local *object, double __local *expected,
5709+ double desired, memory_order success, memory_order failure);
5710+bool __ovld atomic_compare_exchange_strong_explicit(
5711+ volatile atomic_double __global *object, double __private *expected,
5712+ double desired, memory_order success, memory_order failure);
5713+bool __ovld atomic_compare_exchange_strong_explicit(
5714+ volatile atomic_double __local *object, double __private *expected,
5715+ double desired, memory_order success, memory_order failure);
5716+bool __ovld atomic_compare_exchange_weak_explicit(
5717+ volatile atomic_double __global *object, double __global *expected,
5718+ double desired, memory_order success, memory_order failure);
5719+bool __ovld atomic_compare_exchange_weak_explicit(
5720+ volatile atomic_double __local *object, double __global *expected,
5721+ double desired, memory_order success, memory_order failure);
5722+bool __ovld atomic_compare_exchange_weak_explicit(
5723+ volatile atomic_double __global *object, double __local *expected,
5724+ double desired, memory_order success, memory_order failure);
5725+bool __ovld atomic_compare_exchange_weak_explicit(
5726+ volatile atomic_double __local *object, double __local *expected,
5727+ double desired, memory_order success, memory_order failure);
5728+bool __ovld atomic_compare_exchange_weak_explicit(
5729+ volatile atomic_double __global *object, double __private *expected,
5730+ double desired, memory_order success, memory_order failure);
5731+bool __ovld atomic_compare_exchange_weak_explicit(
5732+ volatile atomic_double __local *object, double __private *expected,
5733+ double desired, memory_order success, memory_order failure);
5734+#endif // __opencl_c_atomic_scope_device
5735+bool __ovld atomic_compare_exchange_strong_explicit(
5736+ volatile atomic_double __global *object, double __global *expected,
5737+ double desired, memory_order success, memory_order failure,
5738+ memory_scope scope);
5739+bool __ovld atomic_compare_exchange_strong_explicit(
5740+ volatile atomic_double __local *object, double __global *expected,
5741+ double desired, memory_order success, memory_order failure,
5742+ memory_scope scope);
5743+bool __ovld atomic_compare_exchange_strong_explicit(
5744+ volatile atomic_double __global *object, double __local *expected,
5745+ double desired, memory_order success, memory_order failure,
5746+ memory_scope scope);
5747+bool __ovld atomic_compare_exchange_strong_explicit(
5748+ volatile atomic_double __local *object, double __local *expected,
5749+ double desired, memory_order success, memory_order failure,
5750+ memory_scope scope);
5751+bool __ovld atomic_compare_exchange_strong_explicit(
5752+ volatile atomic_double __global *object, double __private *expected,
5753+ double desired, memory_order success, memory_order failure,
5754+ memory_scope scope);
5755+bool __ovld atomic_compare_exchange_strong_explicit(
5756+ volatile atomic_double __local *object, double __private *expected,
5757+ double desired, memory_order success, memory_order failure,
5758+ memory_scope scope);
5759+bool __ovld atomic_compare_exchange_weak_explicit(
5760+ volatile atomic_double __global *object, double __global *expected,
5761+ double desired, memory_order success, memory_order failure,
5762+ memory_scope scope);
5763+bool __ovld atomic_compare_exchange_weak_explicit(
5764+ volatile atomic_double __local *object, double __global *expected,
5765+ double desired, memory_order success, memory_order failure,
5766+ memory_scope scope);
5767+bool __ovld atomic_compare_exchange_weak_explicit(
5768+ volatile atomic_double __global *object, double __local *expected,
5769+ double desired, memory_order success, memory_order failure,
5770+ memory_scope scope);
5771+bool __ovld atomic_compare_exchange_weak_explicit(
5772+ volatile atomic_double __local *object, double __local *expected,
5773+ double desired, memory_order success, memory_order failure,
5774+ memory_scope scope);
5775+bool __ovld atomic_compare_exchange_weak_explicit(
5776+ volatile atomic_double __global *object, double __private *expected,
5777+ double desired, memory_order success, memory_order failure,
5778+ memory_scope scope);
5779+bool __ovld atomic_compare_exchange_weak_explicit(
5780+ volatile atomic_double __local *object, double __private *expected,
5781+ double desired, memory_order success, memory_order failure,
5782+ memory_scope scope);
5783+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
5784+#ifdef __opencl_c_atomic_scope_device
5785+bool __ovld atomic_compare_exchange_strong_explicit(
5786+ volatile atomic_long __global *object, long __global *expected,
5787+ long desired, memory_order success, memory_order failure);
5788+bool __ovld atomic_compare_exchange_strong_explicit(
5789+ volatile atomic_long __local *object, long __global *expected, long desired,
5790+ memory_order success, memory_order failure);
5791+bool __ovld atomic_compare_exchange_strong_explicit(
5792+ volatile atomic_long __global *object, long __local *expected, long desired,
5793+ memory_order success, memory_order failure);
5794+bool __ovld atomic_compare_exchange_strong_explicit(
5795+ volatile atomic_long __local *object, long __local *expected, long desired,
5796+ memory_order success, memory_order failure);
5797+bool __ovld atomic_compare_exchange_strong_explicit(
5798+ volatile atomic_long __global *object, long __private *expected,
5799+ long desired, memory_order success, memory_order failure);
5800+bool __ovld atomic_compare_exchange_strong_explicit(
5801+ volatile atomic_long __local *object, long __private *expected,
5802+ long desired, memory_order success, memory_order failure);
5803+bool __ovld atomic_compare_exchange_weak_explicit(
5804+ volatile atomic_long __global *object, long __global *expected,
5805+ long desired, memory_order success, memory_order failure);
5806+bool __ovld atomic_compare_exchange_weak_explicit(
5807+ volatile atomic_long __local *object, long __global *expected, long desired,
5808+ memory_order success, memory_order failure);
5809+bool __ovld atomic_compare_exchange_weak_explicit(
5810+ volatile atomic_long __global *object, long __local *expected, long desired,
5811+ memory_order success, memory_order failure);
5812+bool __ovld atomic_compare_exchange_weak_explicit(
5813+ volatile atomic_long __local *object, long __local *expected, long desired,
5814+ memory_order success, memory_order failure);
5815+bool __ovld atomic_compare_exchange_weak_explicit(
5816+ volatile atomic_long __global *object, long __private *expected,
5817+ long desired, memory_order success, memory_order failure);
5818+bool __ovld atomic_compare_exchange_weak_explicit(
5819+ volatile atomic_long __local *object, long __private *expected,
5820+ long desired, memory_order success, memory_order failure);
5821+bool __ovld atomic_compare_exchange_strong_explicit(
5822+ volatile atomic_ulong __global *object, ulong __global *expected,
5823+ ulong desired, memory_order success, memory_order failure);
5824+bool __ovld atomic_compare_exchange_strong_explicit(
5825+ volatile atomic_ulong __local *object, ulong __global *expected,
5826+ ulong desired, memory_order success, memory_order failure);
5827+bool __ovld atomic_compare_exchange_strong_explicit(
5828+ volatile atomic_ulong __global *object, ulong __local *expected,
5829+ ulong desired, memory_order success, memory_order failure);
5830+bool __ovld atomic_compare_exchange_strong_explicit(
5831+ volatile atomic_ulong __local *object, ulong __local *expected,
5832+ ulong desired, memory_order success, memory_order failure);
5833+bool __ovld atomic_compare_exchange_strong_explicit(
5834+ volatile atomic_ulong __global *object, ulong __private *expected,
5835+ ulong desired, memory_order success, memory_order failure);
5836+bool __ovld atomic_compare_exchange_strong_explicit(
5837+ volatile atomic_ulong __local *object, ulong __private *expected,
5838+ ulong desired, memory_order success, memory_order failure);
5839+bool __ovld atomic_compare_exchange_weak_explicit(
5840+ volatile atomic_ulong __global *object, ulong __global *expected,
5841+ ulong desired, memory_order success, memory_order failure);
5842+bool __ovld atomic_compare_exchange_weak_explicit(
5843+ volatile atomic_ulong __local *object, ulong __global *expected,
5844+ ulong desired, memory_order success, memory_order failure);
5845+bool __ovld atomic_compare_exchange_weak_explicit(
5846+ volatile atomic_ulong __global *object, ulong __local *expected,
5847+ ulong desired, memory_order success, memory_order failure);
5848+bool __ovld atomic_compare_exchange_weak_explicit(
5849+ volatile atomic_ulong __local *object, ulong __local *expected,
5850+ ulong desired, memory_order success, memory_order failure);
5851+bool __ovld atomic_compare_exchange_weak_explicit(
5852+ volatile atomic_ulong __global *object, ulong __private *expected,
5853+ ulong desired, memory_order success, memory_order failure);
5854+bool __ovld atomic_compare_exchange_weak_explicit(
5855+ volatile atomic_ulong __local *object, ulong __private *expected,
5856+ ulong desired, memory_order success, memory_order failure);
5857+#endif // __opencl_c_atomic_scope_device
5858+bool __ovld atomic_compare_exchange_strong_explicit(
5859+ volatile atomic_long __global *object, long __global *expected,
5860+ long desired, memory_order success, memory_order failure,
5861+ memory_scope scope);
5862+bool __ovld atomic_compare_exchange_strong_explicit(
5863+ volatile atomic_long __local *object, long __global *expected, long desired,
5864+ memory_order success, memory_order failure, memory_scope scope);
5865+bool __ovld atomic_compare_exchange_strong_explicit(
5866+ volatile atomic_long __global *object, long __local *expected, long desired,
5867+ memory_order success, memory_order failure, memory_scope scope);
5868+bool __ovld atomic_compare_exchange_strong_explicit(
5869+ volatile atomic_long __local *object, long __local *expected, long desired,
5870+ memory_order success, memory_order failure, memory_scope scope);
5871+bool __ovld atomic_compare_exchange_strong_explicit(
5872+ volatile atomic_long __global *object, long __private *expected,
5873+ long desired, memory_order success, memory_order failure,
5874+ memory_scope scope);
5875+bool __ovld atomic_compare_exchange_strong_explicit(
5876+ volatile atomic_long __local *object, long __private *expected,
5877+ long desired, memory_order success, memory_order failure,
5878+ memory_scope scope);
5879+bool __ovld atomic_compare_exchange_weak_explicit(
5880+ volatile atomic_long __global *object, long __global *expected,
5881+ long desired, memory_order success, memory_order failure,
5882+ memory_scope scope);
5883+bool __ovld atomic_compare_exchange_weak_explicit(
5884+ volatile atomic_long __local *object, long __global *expected, long desired,
5885+ memory_order success, memory_order failure, memory_scope scope);
5886+bool __ovld atomic_compare_exchange_weak_explicit(
5887+ volatile atomic_long __global *object, long __local *expected, long desired,
5888+ memory_order success, memory_order failure, memory_scope scope);
5889+bool __ovld atomic_compare_exchange_weak_explicit(
5890+ volatile atomic_long __local *object, long __local *expected, long desired,
5891+ memory_order success, memory_order failure, memory_scope scope);
5892+bool __ovld atomic_compare_exchange_weak_explicit(
5893+ volatile atomic_long __global *object, long __private *expected,
5894+ long desired, memory_order success, memory_order failure,
5895+ memory_scope scope);
5896+bool __ovld atomic_compare_exchange_weak_explicit(
5897+ volatile atomic_long __local *object, long __private *expected,
5898+ long desired, memory_order success, memory_order failure,
5899+ memory_scope scope);
5900+bool __ovld atomic_compare_exchange_strong_explicit(
5901+ volatile atomic_ulong __global *object, ulong __global *expected,
5902+ ulong desired, memory_order success, memory_order failure,
5903+ memory_scope scope);
5904+bool __ovld atomic_compare_exchange_strong_explicit(
5905+ volatile atomic_ulong __local *object, ulong __global *expected,
5906+ ulong desired, memory_order success, memory_order failure,
5907+ memory_scope scope);
5908+bool __ovld atomic_compare_exchange_strong_explicit(
5909+ volatile atomic_ulong __global *object, ulong __local *expected,
5910+ ulong desired, memory_order success, memory_order failure,
5911+ memory_scope scope);
5912+bool __ovld atomic_compare_exchange_strong_explicit(
5913+ volatile atomic_ulong __local *object, ulong __local *expected,
5914+ ulong desired, memory_order success, memory_order failure,
5915+ memory_scope scope);
5916+bool __ovld atomic_compare_exchange_strong_explicit(
5917+ volatile atomic_ulong __global *object, ulong __private *expected,
5918+ ulong desired, memory_order success, memory_order failure,
5919+ memory_scope scope);
5920+bool __ovld atomic_compare_exchange_strong_explicit(
5921+ volatile atomic_ulong __local *object, ulong __private *expected,
5922+ ulong desired, memory_order success, memory_order failure,
5923+ memory_scope scope);
5924+bool __ovld atomic_compare_exchange_weak_explicit(
5925+ volatile atomic_ulong __global *object, ulong __global *expected,
5926+ ulong desired, memory_order success, memory_order failure,
5927+ memory_scope scope);
5928+bool __ovld atomic_compare_exchange_weak_explicit(
5929+ volatile atomic_ulong __local *object, ulong __global *expected,
5930+ ulong desired, memory_order success, memory_order failure,
5931+ memory_scope scope);
5932+bool __ovld atomic_compare_exchange_weak_explicit(
5933+ volatile atomic_ulong __global *object, ulong __local *expected,
5934+ ulong desired, memory_order success, memory_order failure,
5935+ memory_scope scope);
5936+bool __ovld atomic_compare_exchange_weak_explicit(
5937+ volatile atomic_ulong __local *object, ulong __local *expected,
5938+ ulong desired, memory_order success, memory_order failure,
5939+ memory_scope scope);
5940+bool __ovld atomic_compare_exchange_weak_explicit(
5941+ volatile atomic_ulong __global *object, ulong __private *expected,
5942+ ulong desired, memory_order success, memory_order failure,
5943+ memory_scope scope);
5944+bool __ovld atomic_compare_exchange_weak_explicit(
5945+ volatile atomic_ulong __local *object, ulong __private *expected,
5946+ ulong desired, memory_order success, memory_order failure,
5947+ memory_scope scope);
5948+#endif // defined(cl_khr_int64_base_atomics) &&
5949+ // defined(cl_khr_int64_extended_atomics)
5950+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
5951
5952 // atomic_flag_test_and_set() and atomic_flag_clear()
5953-
5954+#if defined(__opencl_c_atomic_scope_device) && \
5955+ defined(__opencl_c_atomic_order_seq_cst)
5956+#ifdef __opencl_c_generic_address_space
5957 bool __ovld atomic_flag_test_and_set(volatile atomic_flag *object);
5958-bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order);
5959-bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order, memory_scope scope);
5960 void __ovld atomic_flag_clear(volatile atomic_flag *object);
5961-void __ovld atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order);
5962-void __ovld atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order, memory_scope scope);
5963+#endif // __opencl_c_generic_address_space
5964+
5965+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
5966+bool __ovld atomic_flag_test_and_set(volatile atomic_flag __global *object);
5967+bool __ovld atomic_flag_test_and_set(volatile atomic_flag __local *object);
5968+void __ovld atomic_flag_clear(volatile atomic_flag __global *object);
5969+void __ovld atomic_flag_clear(volatile atomic_flag __local *object);
5970+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
5971+#endif // defined(__opencl_c_atomic_scope_device) &&
5972+ // defined(__opencl_c_atomic_order_seq_cst)
5973+
5974+#ifdef __opencl_c_generic_address_space
5975+#ifdef __opencl_c_atomic_scope_device
5976+bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *object,
5977+ memory_order order);
5978+void __ovld atomic_flag_clear_explicit(volatile atomic_flag *object,
5979+ memory_order order);
5980+#endif // __opencl_c_atomic_scope_device
5981+bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *object,
5982+ memory_order order,
5983+ memory_scope scope);
5984+void __ovld atomic_flag_clear_explicit(volatile atomic_flag *object,
5985+ memory_order order, memory_scope scope);
5986+#endif // __opencl_c_generic_address_space
5987+
5988+#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
5989+#ifdef __opencl_c_atomic_scope_device
5990+bool __ovld atomic_flag_test_and_set_explicit(
5991+ volatile atomic_flag __global *object, memory_order order);
5992+bool __ovld atomic_flag_test_and_set_explicit(
5993+ volatile atomic_flag __local *object, memory_order order);
5994+void __ovld atomic_flag_clear_explicit(volatile atomic_flag __global *object,
5995+ memory_order order);
5996+void __ovld atomic_flag_clear_explicit(volatile atomic_flag __local *object,
5997+ memory_order order);
5998+#endif // __opencl_c_atomic_scope_device
5999+bool __ovld
6000+atomic_flag_test_and_set_explicit(volatile atomic_flag __global *object,
6001+ memory_order order, memory_scope scope);
6002+bool __ovld
6003+atomic_flag_test_and_set_explicit(volatile atomic_flag __local *object,
6004+ memory_order order, memory_scope scope);
6005+void __ovld atomic_flag_clear_explicit(volatile atomic_flag __global *object,
6006+ memory_order order, memory_scope scope);
6007+void __ovld atomic_flag_clear_explicit(volatile atomic_flag __local *object,
6008+ memory_order order, memory_scope scope);
6009+#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0)
6010
6011 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6012
6013@@ -13906,7 +15943,7 @@ float16 __ovld __cnfn shuffle(float4 x, uint16 mask);
6014 float16 __ovld __cnfn shuffle(float8 x, uint16 mask);
6015 float16 __ovld __cnfn shuffle(float16 x, uint16 mask);
6016
6017-#ifdef cl_khr_fp64
6018+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6019 double2 __ovld __cnfn shuffle(double2 x, ulong2 mask);
6020 double2 __ovld __cnfn shuffle(double4 x, ulong2 mask);
6021 double2 __ovld __cnfn shuffle(double8 x, ulong2 mask);
6022@@ -13926,7 +15963,7 @@ double16 __ovld __cnfn shuffle(double2 x, ulong16 mask);
6023 double16 __ovld __cnfn shuffle(double4 x, ulong16 mask);
6024 double16 __ovld __cnfn shuffle(double8 x, ulong16 mask);
6025 double16 __ovld __cnfn shuffle(double16 x, ulong16 mask);
6026-#endif //cl_khr_fp64
6027+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6028
6029 #ifdef cl_khr_fp16
6030 half2 __ovld __cnfn shuffle(half2 x, ushort2 mask);
6031@@ -14130,7 +16167,7 @@ float16 __ovld __cnfn shuffle2(float4 x, float4 y, uint16 mask);
6032 float16 __ovld __cnfn shuffle2(float8 x, float8 y, uint16 mask);
6033 float16 __ovld __cnfn shuffle2(float16 x, float16 y, uint16 mask);
6034
6035-#ifdef cl_khr_fp64
6036+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6037 double2 __ovld __cnfn shuffle2(double2 x, double2 y, ulong2 mask);
6038 double2 __ovld __cnfn shuffle2(double4 x, double4 y, ulong2 mask);
6039 double2 __ovld __cnfn shuffle2(double8 x, double8 y, ulong2 mask);
6040@@ -14150,7 +16187,7 @@ double16 __ovld __cnfn shuffle2(double2 x, double2 y, ulong16 mask);
6041 double16 __ovld __cnfn shuffle2(double4 x, double4 y, ulong16 mask);
6042 double16 __ovld __cnfn shuffle2(double8 x, double8 y, ulong16 mask);
6043 double16 __ovld __cnfn shuffle2(double16 x, double16 y, ulong16 mask);
6044-#endif //cl_khr_fp64
6045+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6046
6047 #ifdef cl_khr_fp16
6048 half2 __ovld __cnfn shuffle2(half2 x, half2 y, ushort2 mask);
6049@@ -14186,6 +16223,7 @@ int printf(__constant const char* st, ...) __attribute__((format(printf, 1, 2)))
6050 #pragma OPENCL EXTENSION cl_khr_gl_msaa_sharing : enable
6051 #endif //cl_khr_gl_msaa_sharing
6052
6053+#ifdef __opencl_c_images
6054 /**
6055 * Use the coordinate (coord.xy) to do an element lookup in
6056 * the 2D image object specified by image.
6057@@ -14464,6 +16502,7 @@ half4 __purefn __ovld read_imageh(read_only image1d_buffer_t image, int coord);
6058
6059 // Image read functions for read_write images
6060 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6061+#ifdef __opencl_c_read_write_images
6062 float4 __purefn __ovld read_imagef(read_write image1d_t image, int coord);
6063 int4 __purefn __ovld read_imagei(read_write image1d_t image, int coord);
6064 uint4 __purefn __ovld read_imageui(read_write image1d_t image, int coord);
6065@@ -14507,6 +16546,7 @@ float __purefn __ovld read_imagef(read_write image2d_array_msaa_depth_t image, i
6066 #endif //cl_khr_gl_msaa_sharing
6067
6068 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6069+#ifdef __opencl_c_read_write_images
6070 #ifdef cl_khr_mipmap_image
6071 float4 __purefn __ovld read_imagef(read_write image1d_t image, sampler_t sampler, float coord, float lod);
6072 int4 __purefn __ovld read_imagei(read_write image1d_t image, sampler_t sampler, float coord, float lod);
6073@@ -14557,6 +16597,7 @@ int4 __purefn __ovld read_imagei(read_write image3d_t image, sampler_t sampler,
6074 uint4 __purefn __ovld read_imageui(read_write image3d_t image, sampler_t sampler, float4 coord, float4 gradientX, float4 gradientY);
6075
6076 #endif //cl_khr_mipmap_image
6077+#endif //__opencl_c_read_write_images
6078 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6079
6080 // Image read functions returning half4 type
6081@@ -14568,6 +16609,7 @@ half4 __purefn __ovld read_imageh(read_write image1d_array_t image, int2 coord);
6082 half4 __purefn __ovld read_imageh(read_write image2d_array_t image, int4 coord);
6083 half4 __purefn __ovld read_imageh(read_write image1d_buffer_t image, int coord);
6084 #endif //cl_khr_fp16
6085+#endif //__opencl_c_read_write_images
6086 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6087
6088 /**
6089@@ -14657,7 +16699,7 @@ void __ovld write_imagef(write_only image1d_array_t image_array, int2 coord, flo
6090 void __ovld write_imagei(write_only image1d_array_t image_array, int2 coord, int4 color);
6091 void __ovld write_imageui(write_only image1d_array_t image_array, int2 coord, uint4 color);
6092
6093-#ifdef cl_khr_3d_image_writes
6094+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6095 void __ovld write_imagef(write_only image3d_t image, int4 coord, float4 color);
6096 void __ovld write_imagei(write_only image3d_t image, int4 coord, int4 color);
6097 void __ovld write_imageui(write_only image3d_t image, int4 coord, uint4 color);
6098@@ -14690,7 +16732,7 @@ void __ovld write_imageui(write_only image2d_array_t image_array, int4 coord, in
6099 void __ovld write_imagef(write_only image2d_depth_t image, int2 coord, int lod, float depth);
6100 void __ovld write_imagef(write_only image2d_array_depth_t image, int4 coord, int lod, float depth);
6101
6102-#ifdef cl_khr_3d_image_writes
6103+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6104 void __ovld write_imagef(write_only image3d_t image, int4 coord, int lod, float4 color);
6105 void __ovld write_imagei(write_only image3d_t image, int4 coord, int lod, int4 color);
6106 void __ovld write_imageui(write_only image3d_t image, int4 coord, int lod, uint4 color);
6107@@ -14703,7 +16745,7 @@ void __ovld write_imageui(write_only image3d_t image, int4 coord, int lod, uint4
6108 #ifdef cl_khr_fp16
6109 void __ovld write_imageh(write_only image1d_t image, int coord, half4 color);
6110 void __ovld write_imageh(write_only image2d_t image, int2 coord, half4 color);
6111-#ifdef cl_khr_3d_image_writes
6112+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6113 void __ovld write_imageh(write_only image3d_t image, int4 coord, half4 color);
6114 #endif
6115 void __ovld write_imageh(write_only image1d_array_t image, int2 coord, half4 color);
6116@@ -14713,6 +16755,7 @@ void __ovld write_imageh(write_only image1d_buffer_t image, int coord, half4 col
6117
6118 // Image write functions for read_write images
6119 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6120+#ifdef __opencl_c_read_write_images
6121 void __ovld write_imagef(read_write image2d_t image, int2 coord, float4 color);
6122 void __ovld write_imagei(read_write image2d_t image, int2 coord, int4 color);
6123 void __ovld write_imageui(read_write image2d_t image, int2 coord, uint4 color);
6124@@ -14733,7 +16776,7 @@ void __ovld write_imagef(read_write image1d_array_t image_array, int2 coord, flo
6125 void __ovld write_imagei(read_write image1d_array_t image_array, int2 coord, int4 color);
6126 void __ovld write_imageui(read_write image1d_array_t image_array, int2 coord, uint4 color);
6127
6128-#ifdef cl_khr_3d_image_writes
6129+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6130 void __ovld write_imagef(read_write image3d_t image, int4 coord, float4 color);
6131 void __ovld write_imagei(read_write image3d_t image, int4 coord, int4 color);
6132 void __ovld write_imageui(read_write image3d_t image, int4 coord, uint4 color);
6133@@ -14765,7 +16808,7 @@ void __ovld write_imageui(read_write image2d_array_t image_array, int4 coord, in
6134 void __ovld write_imagef(read_write image2d_depth_t image, int2 coord, int lod, float color);
6135 void __ovld write_imagef(read_write image2d_array_depth_t image, int4 coord, int lod, float color);
6136
6137-#ifdef cl_khr_3d_image_writes
6138+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6139 void __ovld write_imagef(read_write image3d_t image, int4 coord, int lod, float4 color);
6140 void __ovld write_imagei(read_write image3d_t image, int4 coord, int lod, int4 color);
6141 void __ovld write_imageui(read_write image3d_t image, int4 coord, int lod, uint4 color);
6142@@ -14778,13 +16821,14 @@ void __ovld write_imageui(read_write image3d_t image, int4 coord, int lod, uint4
6143 #ifdef cl_khr_fp16
6144 void __ovld write_imageh(read_write image1d_t image, int coord, half4 color);
6145 void __ovld write_imageh(read_write image2d_t image, int2 coord, half4 color);
6146-#ifdef cl_khr_3d_image_writes
6147+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6148 void __ovld write_imageh(read_write image3d_t image, int4 coord, half4 color);
6149 #endif
6150 void __ovld write_imageh(read_write image1d_array_t image, int2 coord, half4 color);
6151 void __ovld write_imageh(read_write image2d_array_t image, int4 coord, half4 color);
6152 void __ovld write_imageh(read_write image1d_buffer_t image, int coord, half4 color);
6153 #endif //cl_khr_fp16
6154+#endif //__opencl_c_read_write_images
6155 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6156
6157 // Note: In OpenCL v1.0/1.1/1.2, image argument of image query builtin functions does not have
6158@@ -14798,7 +16842,7 @@ void __ovld write_imageh(read_write image1d_buffer_t image, int coord, half4 col
6159 int __ovld __cnfn get_image_width(read_only image1d_t image);
6160 int __ovld __cnfn get_image_width(read_only image1d_buffer_t image);
6161 int __ovld __cnfn get_image_width(read_only image2d_t image);
6162-#ifdef cl_khr_3d_image_writes
6163+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6164 int __ovld __cnfn get_image_width(read_only image3d_t image);
6165 #endif
6166 int __ovld __cnfn get_image_width(read_only image1d_array_t image);
6167@@ -14817,7 +16861,7 @@ int __ovld __cnfn get_image_width(read_only image2d_array_msaa_depth_t image);
6168 int __ovld __cnfn get_image_width(write_only image1d_t image);
6169 int __ovld __cnfn get_image_width(write_only image1d_buffer_t image);
6170 int __ovld __cnfn get_image_width(write_only image2d_t image);
6171-#ifdef cl_khr_3d_image_writes
6172+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6173 int __ovld __cnfn get_image_width(write_only image3d_t image);
6174 #endif
6175 int __ovld __cnfn get_image_width(write_only image1d_array_t image);
6176@@ -14834,6 +16878,7 @@ int __ovld __cnfn get_image_width(write_only image2d_array_msaa_depth_t image);
6177 #endif //cl_khr_gl_msaa_sharing
6178
6179 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6180+#ifdef __opencl_c_read_write_images
6181 int __ovld __cnfn get_image_width(read_write image1d_t image);
6182 int __ovld __cnfn get_image_width(read_write image1d_buffer_t image);
6183 int __ovld __cnfn get_image_width(read_write image2d_t image);
6184@@ -14850,6 +16895,7 @@ int __ovld __cnfn get_image_width(read_write image2d_msaa_depth_t image);
6185 int __ovld __cnfn get_image_width(read_write image2d_array_msaa_t image);
6186 int __ovld __cnfn get_image_width(read_write image2d_array_msaa_depth_t image);
6187 #endif //cl_khr_gl_msaa_sharing
6188+#endif //__opencl_c_read_write_images
6189 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6190
6191 /**
6192@@ -14870,7 +16916,7 @@ int __ovld __cnfn get_image_height(read_only image2d_array_msaa_depth_t image);
6193 #endif //cl_khr_gl_msaa_sharing
6194
6195 int __ovld __cnfn get_image_height(write_only image2d_t image);
6196-#ifdef cl_khr_3d_image_writes
6197+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6198 int __ovld __cnfn get_image_height(write_only image3d_t image);
6199 #endif
6200 int __ovld __cnfn get_image_height(write_only image2d_array_t image);
6201@@ -14886,6 +16932,7 @@ int __ovld __cnfn get_image_height(write_only image2d_array_msaa_depth_t image);
6202 #endif //cl_khr_gl_msaa_sharing
6203
6204 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6205+#ifdef __opencl_c_read_write_images
6206 int __ovld __cnfn get_image_height(read_write image2d_t image);
6207 int __ovld __cnfn get_image_height(read_write image3d_t image);
6208 int __ovld __cnfn get_image_height(read_write image2d_array_t image);
6209@@ -14899,6 +16946,7 @@ int __ovld __cnfn get_image_height(read_write image2d_msaa_depth_t image);
6210 int __ovld __cnfn get_image_height(read_write image2d_array_msaa_t image);
6211 int __ovld __cnfn get_image_height(read_write image2d_array_msaa_depth_t image);
6212 #endif //cl_khr_gl_msaa_sharing
6213+#endif //__opencl_c_read_write_images
6214 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6215
6216 /**
6217@@ -14906,12 +16954,14 @@ int __ovld __cnfn get_image_height(read_write image2d_array_msaa_depth_t image);
6218 */
6219 int __ovld __cnfn get_image_depth(read_only image3d_t image);
6220
6221-#ifdef cl_khr_3d_image_writes
6222+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6223 int __ovld __cnfn get_image_depth(write_only image3d_t image);
6224 #endif
6225
6226 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6227+#ifdef __opencl_c_read_write_images
6228 int __ovld __cnfn get_image_depth(read_write image3d_t image);
6229+#endif //__opencl_c_read_write_images
6230 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6231
6232 // OpenCL Extension v2.0 s9.18 - Mipmaps
6233@@ -14927,13 +16977,15 @@ int __ovld get_image_num_mip_levels(read_only image3d_t image);
6234
6235 int __ovld get_image_num_mip_levels(write_only image1d_t image);
6236 int __ovld get_image_num_mip_levels(write_only image2d_t image);
6237-#ifdef cl_khr_3d_image_writes
6238+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6239 int __ovld get_image_num_mip_levels(write_only image3d_t image);
6240 #endif
6241
6242+#ifdef __opencl_c_read_write_images
6243 int __ovld get_image_num_mip_levels(read_write image1d_t image);
6244 int __ovld get_image_num_mip_levels(read_write image2d_t image);
6245 int __ovld get_image_num_mip_levels(read_write image3d_t image);
6246+#endif //__opencl_c_read_write_images
6247
6248 int __ovld get_image_num_mip_levels(read_only image1d_array_t image);
6249 int __ovld get_image_num_mip_levels(read_only image2d_array_t image);
6250@@ -14945,10 +16997,12 @@ int __ovld get_image_num_mip_levels(write_only image2d_array_t image);
6251 int __ovld get_image_num_mip_levels(write_only image2d_array_depth_t image);
6252 int __ovld get_image_num_mip_levels(write_only image2d_depth_t image);
6253
6254+#ifdef __opencl_c_read_write_images
6255 int __ovld get_image_num_mip_levels(read_write image1d_array_t image);
6256 int __ovld get_image_num_mip_levels(read_write image2d_array_t image);
6257 int __ovld get_image_num_mip_levels(read_write image2d_array_depth_t image);
6258 int __ovld get_image_num_mip_levels(read_write image2d_depth_t image);
6259+#endif //__opencl_c_read_write_images
6260
6261 #endif //cl_khr_mipmap_image
6262 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6263@@ -14992,7 +17046,7 @@ int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_msaa_depth
6264 int __ovld __cnfn get_image_channel_data_type(write_only image1d_t image);
6265 int __ovld __cnfn get_image_channel_data_type(write_only image1d_buffer_t image);
6266 int __ovld __cnfn get_image_channel_data_type(write_only image2d_t image);
6267-#ifdef cl_khr_3d_image_writes
6268+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6269 int __ovld __cnfn get_image_channel_data_type(write_only image3d_t image);
6270 #endif
6271 int __ovld __cnfn get_image_channel_data_type(write_only image1d_array_t image);
6272@@ -15009,6 +17063,7 @@ int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_msaa_dept
6273 #endif //cl_khr_gl_msaa_sharing
6274
6275 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6276+#ifdef __opencl_c_read_write_images
6277 int __ovld __cnfn get_image_channel_data_type(read_write image1d_t image);
6278 int __ovld __cnfn get_image_channel_data_type(read_write image1d_buffer_t image);
6279 int __ovld __cnfn get_image_channel_data_type(read_write image2d_t image);
6280@@ -15025,6 +17080,7 @@ int __ovld __cnfn get_image_channel_data_type(read_write image2d_msaa_depth_t im
6281 int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_msaa_t image);
6282 int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_msaa_depth_t image);
6283 #endif //cl_khr_gl_msaa_sharing
6284+#endif //__opencl_c_read_write_images
6285 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6286
6287 /**
6288@@ -15064,7 +17120,7 @@ int __ovld __cnfn get_image_channel_order(read_only image2d_array_msaa_depth_t i
6289 int __ovld __cnfn get_image_channel_order(write_only image1d_t image);
6290 int __ovld __cnfn get_image_channel_order(write_only image1d_buffer_t image);
6291 int __ovld __cnfn get_image_channel_order(write_only image2d_t image);
6292-#ifdef cl_khr_3d_image_writes
6293+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6294 int __ovld __cnfn get_image_channel_order(write_only image3d_t image);
6295 #endif
6296 int __ovld __cnfn get_image_channel_order(write_only image1d_array_t image);
6297@@ -15081,6 +17137,7 @@ int __ovld __cnfn get_image_channel_order(write_only image2d_array_msaa_depth_t
6298 #endif //cl_khr_gl_msaa_sharing
6299
6300 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6301+#ifdef __opencl_c_read_write_images
6302 int __ovld __cnfn get_image_channel_order(read_write image1d_t image);
6303 int __ovld __cnfn get_image_channel_order(read_write image1d_buffer_t image);
6304 int __ovld __cnfn get_image_channel_order(read_write image2d_t image);
6305@@ -15097,6 +17154,7 @@ int __ovld __cnfn get_image_channel_order(read_write image2d_msaa_depth_t image)
6306 int __ovld __cnfn get_image_channel_order(read_write image2d_array_msaa_t image);
6307 int __ovld __cnfn get_image_channel_order(read_write image2d_array_msaa_depth_t image);
6308 #endif //cl_khr_gl_msaa_sharing
6309+#endif //__opencl_c_read_write_images
6310 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6311
6312 /**
6313@@ -15131,6 +17189,7 @@ int2 __ovld __cnfn get_image_dim(write_only image2d_array_msaa_depth_t image);
6314 #endif //cl_khr_gl_msaa_sharing
6315
6316 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6317+#ifdef __opencl_c_read_write_images
6318 int2 __ovld __cnfn get_image_dim(read_write image2d_t image);
6319 int2 __ovld __cnfn get_image_dim(read_write image2d_array_t image);
6320 #ifdef cl_khr_depth_images
6321@@ -15143,6 +17202,7 @@ int2 __ovld __cnfn get_image_dim(read_write image2d_msaa_depth_t image);
6322 int2 __ovld __cnfn get_image_dim(read_write image2d_array_msaa_t image);
6323 int2 __ovld __cnfn get_image_dim(read_write image2d_array_msaa_depth_t image);
6324 #endif //cl_khr_gl_msaa_sharing
6325+#endif //__opencl_c_read_write_images
6326 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6327
6328 /**
6329@@ -15152,11 +17212,13 @@ int2 __ovld __cnfn get_image_dim(read_write image2d_array_msaa_depth_t image);
6330 * component and the w component is 0.
6331 */
6332 int4 __ovld __cnfn get_image_dim(read_only image3d_t image);
6333-#ifdef cl_khr_3d_image_writes
6334+#if defined(cl_khr_3d_image_writes) || defined(__opencl_c_3d_image_writes)
6335 int4 __ovld __cnfn get_image_dim(write_only image3d_t image);
6336 #endif
6337 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6338+#ifdef __opencl_c_read_write_images
6339 int4 __ovld __cnfn get_image_dim(read_write image3d_t image);
6340+#endif //__opencl_c_read_write_images
6341 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6342
6343 /**
6344@@ -15184,6 +17246,7 @@ size_t __ovld __cnfn get_image_array_size(write_only image2d_array_msaa_depth_t
6345 #endif //cl_khr_gl_msaa_sharing
6346
6347 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6348+#ifdef __opencl_c_read_write_images
6349 size_t __ovld __cnfn get_image_array_size(read_write image1d_array_t image_array);
6350 size_t __ovld __cnfn get_image_array_size(read_write image2d_array_t image_array);
6351 #ifdef cl_khr_depth_images
6352@@ -15193,6 +17256,7 @@ size_t __ovld __cnfn get_image_array_size(read_write image2d_array_depth_t image
6353 size_t __ovld __cnfn get_image_array_size(read_write image2d_array_msaa_t image_array);
6354 size_t __ovld __cnfn get_image_array_size(read_write image2d_array_msaa_depth_t image_array);
6355 #endif //cl_khr_gl_msaa_sharing
6356+#endif //__opencl_c_read_write_images
6357 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6358
6359 /**
6360@@ -15210,16 +17274,21 @@ int __ovld get_image_num_samples(write_only image2d_array_msaa_t image);
6361 int __ovld get_image_num_samples(write_only image2d_array_msaa_depth_t image);
6362
6363 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6364+#ifdef __opencl_c_read_write_images
6365 int __ovld get_image_num_samples(read_write image2d_msaa_t image);
6366 int __ovld get_image_num_samples(read_write image2d_msaa_depth_t image);
6367 int __ovld get_image_num_samples(read_write image2d_array_msaa_t image);
6368 int __ovld get_image_num_samples(read_write image2d_array_msaa_depth_t image);
6369+#endif //__opencl_c_read_write_images
6370 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6371 #endif
6372
6373+#endif //__opencl_c_images
6374+
6375 // OpenCL v2.0 s6.13.15 - Work-group Functions
6376
6377 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6378+#ifdef __opencl_c_work_group_collective_functions
6379 int __ovld __conv work_group_all(int predicate);
6380 int __ovld __conv work_group_any(int predicate);
6381
6382@@ -15243,11 +17312,11 @@ ulong __ovld __conv work_group_broadcast(ulong a, size_t x, size_t y, size_t z);
6383 float __ovld __conv work_group_broadcast(float a, size_t local_id);
6384 float __ovld __conv work_group_broadcast(float a, size_t x, size_t y);
6385 float __ovld __conv work_group_broadcast(float a, size_t x, size_t y, size_t z);
6386-#ifdef cl_khr_fp64
6387+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6388 double __ovld __conv work_group_broadcast(double a, size_t local_id);
6389 double __ovld __conv work_group_broadcast(double a, size_t x, size_t y);
6390 double __ovld __conv work_group_broadcast(double a, size_t x, size_t y, size_t z);
6391-#endif //cl_khr_fp64
6392+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6393
6394 #ifdef cl_khr_fp16
6395 half __ovld __conv work_group_reduce_add(half x);
6396@@ -15305,7 +17374,7 @@ float __ovld __conv work_group_scan_exclusive_max(float x);
6397 float __ovld __conv work_group_scan_inclusive_add(float x);
6398 float __ovld __conv work_group_scan_inclusive_min(float x);
6399 float __ovld __conv work_group_scan_inclusive_max(float x);
6400-#ifdef cl_khr_fp64
6401+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6402 double __ovld __conv work_group_reduce_add(double x);
6403 double __ovld __conv work_group_reduce_min(double x);
6404 double __ovld __conv work_group_reduce_max(double x);
6405@@ -15315,19 +17384,18 @@ double __ovld __conv work_group_scan_exclusive_max(double x);
6406 double __ovld __conv work_group_scan_inclusive_add(double x);
6407 double __ovld __conv work_group_scan_inclusive_min(double x);
6408 double __ovld __conv work_group_scan_inclusive_max(double x);
6409-#endif //cl_khr_fp64
6410-
6411+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6412+#endif //__opencl_c_work_group_collective_functions
6413 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6414
6415 // OpenCL v2.0 s6.13.16 - Pipe Functions
6416-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6417+#ifdef __opencl_c_pipes
6418 bool __ovld is_valid_reserve_id(reserve_id_t reserve_id);
6419-#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6420-
6421+#endif //__opencl_c_pipes
6422
6423 // OpenCL v2.0 s6.13.17 - Enqueue Kernels
6424 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6425-
6426+#ifdef __opencl_c_device_enqueue
6427 ndrange_t __ovld ndrange_1D(size_t);
6428 ndrange_t __ovld ndrange_1D(size_t, size_t);
6429 ndrange_t __ovld ndrange_1D(size_t, size_t, size_t);
6430@@ -15355,11 +17423,13 @@ bool __ovld is_valid_event (clk_event_t event);
6431 void __ovld capture_event_profiling_info(clk_event_t, clk_profiling_info, __global void* value);
6432
6433 queue_t __ovld get_default_queue(void);
6434+#endif //__opencl_c_device_enqueue
6435 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6436
6437 // OpenCL Extension v2.0 s9.17 - Sub-groups
6438
6439-#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups)
6440+#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups) || \
6441+ defined(__opencl_c_subgroups)
6442 // Shared Sub Group Functions
6443 uint __ovld get_sub_group_size(void);
6444 uint __ovld get_max_sub_group_size(void);
6445@@ -15445,7 +17515,7 @@ half __ovld __conv sub_group_scan_inclusive_min(half x);
6446 half __ovld __conv sub_group_scan_inclusive_max(half x);
6447 #endif //cl_khr_fp16
6448
6449-#ifdef cl_khr_fp64
6450+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6451 double __ovld __conv sub_group_broadcast(double x, uint sub_group_local_id);
6452 double __ovld __conv sub_group_reduce_add(double x);
6453 double __ovld __conv sub_group_reduce_min(double x);
6454@@ -15456,7 +17526,7 @@ double __ovld __conv sub_group_scan_exclusive_max(double x);
6455 double __ovld __conv sub_group_scan_inclusive_add(double x);
6456 double __ovld __conv sub_group_scan_inclusive_min(double x);
6457 double __ovld __conv sub_group_scan_inclusive_max(double x);
6458-#endif //cl_khr_fp64
6459+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6460
6461 #endif //cl_khr_subgroups cl_intel_subgroups
6462
6463@@ -16226,16 +18296,22 @@ uint16 __ovld __conv intel_sub_group_shuffle_xor( uint16 x, uint c );
6464 long __ovld __conv intel_sub_group_shuffle_xor( long x, uint c );
6465 ulong __ovld __conv intel_sub_group_shuffle_xor( ulong x, uint c );
6466
6467+#ifdef __opencl_c_images
6468 uint __ovld __conv intel_sub_group_block_read( read_only image2d_t image, int2 coord );
6469 uint2 __ovld __conv intel_sub_group_block_read2( read_only image2d_t image, int2 coord );
6470 uint4 __ovld __conv intel_sub_group_block_read4( read_only image2d_t image, int2 coord );
6471 uint8 __ovld __conv intel_sub_group_block_read8( read_only image2d_t image, int2 coord );
6472+#endif //__opencl_c_images
6473
6474 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6475+#ifdef __opencl_c_images
6476+#ifdef __opencl_c_read_write_images
6477 uint __ovld __conv intel_sub_group_block_read(read_write image2d_t image, int2 coord);
6478 uint2 __ovld __conv intel_sub_group_block_read2(read_write image2d_t image, int2 coord);
6479 uint4 __ovld __conv intel_sub_group_block_read4(read_write image2d_t image, int2 coord);
6480 uint8 __ovld __conv intel_sub_group_block_read8(read_write image2d_t image, int2 coord);
6481+#endif //__opencl_c_read_write_images
6482+#endif //__opencl_c_images
6483 #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6484
6485 uint __ovld __conv intel_sub_group_block_read( const __global uint* p );
6486@@ -16243,16 +18319,22 @@ uint2 __ovld __conv intel_sub_group_block_read2( const __global uint* p );
6487 uint4 __ovld __conv intel_sub_group_block_read4( const __global uint* p );
6488 uint8 __ovld __conv intel_sub_group_block_read8( const __global uint* p );
6489
6490+#ifdef __opencl_c_images
6491 void __ovld __conv intel_sub_group_block_write(write_only image2d_t image, int2 coord, uint data);
6492 void __ovld __conv intel_sub_group_block_write2(write_only image2d_t image, int2 coord, uint2 data);
6493 void __ovld __conv intel_sub_group_block_write4(write_only image2d_t image, int2 coord, uint4 data);
6494 void __ovld __conv intel_sub_group_block_write8(write_only image2d_t image, int2 coord, uint8 data);
6495+#endif //__opencl_c_images
6496
6497 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6498+#ifdef __opencl_c_images
6499+#ifdef __opencl_c_read_write_images
6500 void __ovld __conv intel_sub_group_block_write(read_write image2d_t image, int2 coord, uint data);
6501 void __ovld __conv intel_sub_group_block_write2(read_write image2d_t image, int2 coord, uint2 data);
6502 void __ovld __conv intel_sub_group_block_write4(read_write image2d_t image, int2 coord, uint4 data);
6503 void __ovld __conv intel_sub_group_block_write8(read_write image2d_t image, int2 coord, uint8 data);
6504+#endif // __opencl_c_read_write_images
6505+#endif // __opencl_c_images
6506 #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6507
6508 void __ovld __conv intel_sub_group_block_write( __global uint* p, uint data );
6509@@ -16267,7 +18349,7 @@ half __ovld __conv intel_sub_group_shuffle_up( half prev, half cur, uint c );
6510 half __ovld __conv intel_sub_group_shuffle_xor( half x, uint c );
6511 #endif
6512
6513-#if defined(cl_khr_fp64)
6514+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
6515 double __ovld __conv intel_sub_group_shuffle( double x, uint c );
6516 double __ovld __conv intel_sub_group_shuffle_down( double prev, double cur, uint c );
6517 double __ovld __conv intel_sub_group_shuffle_up( double prev, double cur, uint c );
6518@@ -16366,16 +18448,22 @@ ushort __ovld __conv intel_sub_group_scan_inclusive_min( ushort x );
6519 short __ovld __conv intel_sub_group_scan_inclusive_max( short x );
6520 ushort __ovld __conv intel_sub_group_scan_inclusive_max( ushort x );
6521
6522+#ifdef __opencl_c_images
6523 uint __ovld __conv intel_sub_group_block_read_ui( read_only image2d_t image, int2 byte_coord );
6524 uint2 __ovld __conv intel_sub_group_block_read_ui2( read_only image2d_t image, int2 byte_coord );
6525 uint4 __ovld __conv intel_sub_group_block_read_ui4( read_only image2d_t image, int2 byte_coord );
6526 uint8 __ovld __conv intel_sub_group_block_read_ui8( read_only image2d_t image, int2 byte_coord );
6527+#endif //__opencl_c_images
6528
6529 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6530+#ifdef __opencl_c_images
6531+#ifdef __opencl_c_read_write_images
6532 uint __ovld __conv intel_sub_group_block_read_ui( read_write image2d_t image, int2 byte_coord );
6533 uint2 __ovld __conv intel_sub_group_block_read_ui2( read_write image2d_t image, int2 byte_coord );
6534 uint4 __ovld __conv intel_sub_group_block_read_ui4( read_write image2d_t image, int2 byte_coord );
6535 uint8 __ovld __conv intel_sub_group_block_read_ui8( read_write image2d_t image, int2 byte_coord );
6536+#endif //__opencl_c_read_write_images
6537+#endif //__opencl_c_images
6538 #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6539
6540 uint __ovld __conv intel_sub_group_block_read_ui( const __global uint* p );
6541@@ -16383,16 +18471,22 @@ uint2 __ovld __conv intel_sub_group_block_read_ui2( const __global uint* p
6542 uint4 __ovld __conv intel_sub_group_block_read_ui4( const __global uint* p );
6543 uint8 __ovld __conv intel_sub_group_block_read_ui8( const __global uint* p );
6544
6545+#ifdef __opencl_c_images
6546 void __ovld __conv intel_sub_group_block_write_ui( read_only image2d_t image, int2 byte_coord, uint data );
6547 void __ovld __conv intel_sub_group_block_write_ui2( read_only image2d_t image, int2 byte_coord, uint2 data );
6548 void __ovld __conv intel_sub_group_block_write_ui4( read_only image2d_t image, int2 byte_coord, uint4 data );
6549 void __ovld __conv intel_sub_group_block_write_ui8( read_only image2d_t image, int2 byte_coord, uint8 data );
6550+#endif //__opencl_c_images
6551
6552 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6553+#ifdef __opencl_c_images
6554+#ifdef __opencl_c_read_write_images
6555 void __ovld __conv intel_sub_group_block_write_ui( read_write image2d_t image, int2 byte_coord, uint data );
6556 void __ovld __conv intel_sub_group_block_write_ui2( read_write image2d_t image, int2 byte_coord, uint2 data );
6557 void __ovld __conv intel_sub_group_block_write_ui4( read_write image2d_t image, int2 byte_coord, uint4 data );
6558 void __ovld __conv intel_sub_group_block_write_ui8( read_write image2d_t image, int2 byte_coord, uint8 data );
6559+#endif //__opencl_c_read_write_images
6560+#endif //__opencl_c_images
6561 #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6562
6563 void __ovld __conv intel_sub_group_block_write_ui( __global uint* p, uint data );
6564@@ -16400,16 +18494,22 @@ void __ovld __conv intel_sub_group_block_write_ui2( __global uint* p, uint
6565 void __ovld __conv intel_sub_group_block_write_ui4( __global uint* p, uint4 data );
6566 void __ovld __conv intel_sub_group_block_write_ui8( __global uint* p, uint8 data );
6567
6568+#ifdef __opencl_c_images
6569 ushort __ovld __conv intel_sub_group_block_read_us( read_only image2d_t image, int2 coord );
6570 ushort2 __ovld __conv intel_sub_group_block_read_us2( read_only image2d_t image, int2 coord );
6571 ushort4 __ovld __conv intel_sub_group_block_read_us4( read_only image2d_t image, int2 coord );
6572 ushort8 __ovld __conv intel_sub_group_block_read_us8( read_only image2d_t image, int2 coord );
6573+#endif //__opencl_c_images
6574
6575 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6576+#ifdef __opencl_c_images
6577+#ifdef __opencl_c_read_write_images
6578 ushort __ovld __conv intel_sub_group_block_read_us(read_write image2d_t image, int2 coord);
6579 ushort2 __ovld __conv intel_sub_group_block_read_us2(read_write image2d_t image, int2 coord);
6580 ushort4 __ovld __conv intel_sub_group_block_read_us4(read_write image2d_t image, int2 coord);
6581 ushort8 __ovld __conv intel_sub_group_block_read_us8(read_write image2d_t image, int2 coord);
6582+#endif //__opencl_c_read_write_images
6583+#endif //__opencl_c_images
6584 #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6585
6586 ushort __ovld __conv intel_sub_group_block_read_us( const __global ushort* p );
6587@@ -16417,16 +18517,22 @@ ushort2 __ovld __conv intel_sub_group_block_read_us2( const __global ushort*
6588 ushort4 __ovld __conv intel_sub_group_block_read_us4( const __global ushort* p );
6589 ushort8 __ovld __conv intel_sub_group_block_read_us8( const __global ushort* p );
6590
6591+#ifdef __opencl_c_images
6592 void __ovld __conv intel_sub_group_block_write_us(write_only image2d_t image, int2 coord, ushort data);
6593 void __ovld __conv intel_sub_group_block_write_us2(write_only image2d_t image, int2 coord, ushort2 data);
6594 void __ovld __conv intel_sub_group_block_write_us4(write_only image2d_t image, int2 coord, ushort4 data);
6595 void __ovld __conv intel_sub_group_block_write_us8(write_only image2d_t image, int2 coord, ushort8 data);
6596+#endif //__opencl_c_images
6597
6598 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6599+#ifdef __opencl_c_images
6600+#ifdef __opencl_c_read_write_images
6601 void __ovld __conv intel_sub_group_block_write_us(read_write image2d_t image, int2 coord, ushort data);
6602 void __ovld __conv intel_sub_group_block_write_us2(read_write image2d_t image, int2 coord, ushort2 data);
6603 void __ovld __conv intel_sub_group_block_write_us4(read_write image2d_t image, int2 coord, ushort4 data);
6604 void __ovld __conv intel_sub_group_block_write_us8(read_write image2d_t image, int2 coord, ushort8 data);
6605+#endif //__opencl_c_read_write_images
6606+#endif //__opencl_c_images
6607 #endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
6608
6609 void __ovld __conv intel_sub_group_block_write_us( __global ushort* p, ushort data );
6610@@ -16545,6 +18651,7 @@ short2 __ovld intel_sub_group_avc_ime_adjust_ref_offset(
6611 short2 ref_offset, ushort2 src_coord, ushort2 ref_window_size,
6612 ushort2 image_size);
6613
6614+#ifdef __opencl_c_images
6615 intel_sub_group_avc_ime_result_t __ovld
6616 intel_sub_group_avc_ime_evaluate_with_single_reference(
6617 read_only image2d_t src_image, read_only image2d_t ref_image,
6618@@ -16585,6 +18692,7 @@ intel_sub_group_avc_ime_evaluate_with_dual_reference_streaminout(
6619 read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler,
6620 intel_sub_group_avc_ime_payload_t payload,
6621 intel_sub_group_avc_ime_dual_reference_streamin_t streamin_components);
6622+#endif //__opencl_c_images
6623
6624 intel_sub_group_avc_ime_single_reference_streamin_t __ovld
6625 intel_sub_group_avc_ime_get_single_reference_streamin(
6626@@ -16649,6 +18757,7 @@ intel_sub_group_avc_ref_payload_t __ovld
6627 intel_sub_group_avc_ref_set_bilinear_filter_enable(
6628 intel_sub_group_avc_ref_payload_t payload);
6629
6630+#ifdef __opencl_c_images
6631 intel_sub_group_avc_ref_result_t __ovld
6632 intel_sub_group_avc_ref_evaluate_with_single_reference(
6633 read_only image2d_t src_image, read_only image2d_t ref_image,
6634@@ -16667,6 +18776,7 @@ intel_sub_group_avc_ref_evaluate_with_multi_reference(
6635 read_only image2d_t src_image, uint packed_reference_ids,
6636 uchar packed_reference_field_polarities, sampler_t vme_media_sampler,
6637 intel_sub_group_avc_ref_payload_t payload);
6638+#endif //__opencl_c_images
6639
6640 // SIC built-in functions
6641 intel_sub_group_avc_sic_payload_t __ovld
6642@@ -16717,6 +18827,7 @@ intel_sub_group_avc_sic_set_block_based_raw_skip_sad(
6643 uchar block_based_skip_type,
6644 intel_sub_group_avc_sic_payload_t payload);
6645
6646+#ifdef __opencl_c_images
6647 intel_sub_group_avc_sic_result_t __ovld
6648 intel_sub_group_avc_sic_evaluate_ipe(
6649 read_only image2d_t src_image, sampler_t vme_media_sampler,
6650@@ -16739,6 +18850,7 @@ intel_sub_group_avc_sic_evaluate_with_multi_reference(
6651 read_only image2d_t src_image, uint packed_reference_ids,
6652 uchar packed_reference_field_polarities, sampler_t vme_media_sampler,
6653 intel_sub_group_avc_sic_payload_t payload);
6654+#endif //__opencl_c_images
6655
6656 uchar __ovld intel_sub_group_avc_sic_get_ipe_luma_shape(
6657 intel_sub_group_avc_sic_result_t result);
6658diff --git a/clang/lib/Parse/ParseDecl.cpp b/clang/lib/Parse/ParseDecl.cpp
6659index c87d240a8206..8c8f03bba0f3 100644
6660--- a/clang/lib/Parse/ParseDecl.cpp
6661+++ b/clang/lib/Parse/ParseDecl.cpp
6662@@ -3799,8 +3799,7 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
6663 isInvalid = DS.SetTypeAltiVecBool(true, Loc, PrevSpec, DiagID, Policy);
6664 break;
6665 case tok::kw_pipe:
6666- if (!getLangOpts().OpenCL || (getLangOpts().OpenCLVersion < 200 &&
6667- !getLangOpts().OpenCLCPlusPlus)) {
6668+ if (!getLangOpts().OpenCLPipeKeyword) {
6669 // OpenCL 2.0 defined this keyword. OpenCL 1.2 and earlier should
6670 // support the "pipe" word as identifier.
6671 Tok.getIdentifierInfo()->revertTokenIDToIdentifier();
6672@@ -3922,8 +3921,7 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
6673 case tok::kw___generic:
6674 // generic address space is introduced only in OpenCL v2.0
6675 // see OpenCL C Spec v2.0 s6.5.5
6676- if (Actions.getLangOpts().OpenCLVersion < 200 &&
6677- !Actions.getLangOpts().OpenCLCPlusPlus) {
6678+ if (!Actions.getLangOpts().OpenCLGenericKeyword) {
6679 DiagID = diag::err_opencl_unknown_type_specifier;
6680 PrevSpec = Tok.getIdentifierInfo()->getNameStart();
6681 isInvalid = true;
6682@@ -4973,8 +4971,7 @@ bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) {
6683 default: return false;
6684
6685 case tok::kw_pipe:
6686- return (getLangOpts().OpenCL && getLangOpts().OpenCLVersion >= 200) ||
6687- getLangOpts().OpenCLCPlusPlus;
6688+ return getLangOpts().OpenCLPipeKeyword;
6689
6690 case tok::identifier: // foo::bar
6691 // Unfortunate hack to support "Class.factoryMethod" notation.
6692@@ -5499,8 +5496,7 @@ static bool isPtrOperatorToken(tok::TokenKind Kind, const LangOptions &Lang,
6693 if (Kind == tok::star || Kind == tok::caret)
6694 return true;
6695
6696- if (Kind == tok::kw_pipe &&
6697- ((Lang.OpenCL && Lang.OpenCLVersion >= 200) || Lang.OpenCLCPlusPlus))
6698+ if (Kind == tok::kw_pipe && Lang.OpenCLPipeKeyword)
6699 return true;
6700
6701 if (!Lang.CPlusPlus)
6702diff --git a/clang/lib/Parse/ParsePragma.cpp b/clang/lib/Parse/ParsePragma.cpp
6703index 6402b31d00b2..65f283ad556b 100644
6704--- a/clang/lib/Parse/ParsePragma.cpp
6705+++ b/clang/lib/Parse/ParsePragma.cpp
6706@@ -749,12 +749,14 @@ void Parser::HandlePragmaOpenCLExtension() {
6707 if (Name == "all") {
6708 if (State == Disable) {
6709 Opt.disableAll();
6710- Opt.enableSupportedCore(getLangOpts());
6711+ Opt.enableSupportedCore();
6712 } else {
6713 PP.Diag(NameLoc, diag::warn_pragma_expected_predicate) << 1;
6714 }
6715+ } else if (Opt.isFeature(Name)) {
6716+ PP.Diag(NameLoc, diag::warn_opencl_pragma_feature_ignore) << Ident;
6717 } else if (State == Begin) {
6718- if (!Opt.isKnown(Name) || !Opt.isSupported(Name, getLangOpts())) {
6719+ if (!Opt.isKnown(Name) || !Opt.isSupported(Name)) {
6720 Opt.support(Name);
6721 }
6722 Actions.setCurrentOpenCLExtension(Name);
6723@@ -764,9 +766,9 @@ void Parser::HandlePragmaOpenCLExtension() {
6724 Actions.setCurrentOpenCLExtension("");
6725 } else if (!Opt.isKnown(Name))
6726 PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << Ident;
6727- else if (Opt.isSupportedExtension(Name, getLangOpts()))
6728+ else if (Opt.isSupportedExtension(Name))
6729 Opt.enable(Name, State == Enable);
6730- else if (Opt.isSupportedCore(Name, getLangOpts()))
6731+ else if (Opt.isSupportedCore(Name))
6732 PP.Diag(NameLoc, diag::warn_pragma_extension_is_core) << Ident;
6733 else
6734 PP.Diag(NameLoc, diag::warn_pragma_unsupported_extension) << Ident;
6735diff --git a/clang/lib/Sema/OpenCLBuiltins.td b/clang/lib/Sema/OpenCLBuiltins.td
6736index 745363a6b43f..6a1fce567090 100644
6737--- a/clang/lib/Sema/OpenCLBuiltins.td
6738+++ b/clang/lib/Sema/OpenCLBuiltins.td
6739@@ -22,11 +22,13 @@
6740 class Version<int _Version> {
6741 int ID = _Version;
6742 }
6743+
6744 def CLAll : Version< 0>;
6745 def CL10 : Version<100>;
6746 def CL11 : Version<110>;
6747 def CL12 : Version<120>;
6748 def CL20 : Version<200>;
6749+def CL30 : Version<300>;
6750
6751 // Address spaces
6752 // Pointer types need to be assigned an address space.
6753@@ -72,6 +74,14 @@ def ArmIntegerDotProductAccumulateInt8 : FunctionExtension<"cl_arm_integ
6754 def ArmIntegerDotProductAccumulateInt16 : FunctionExtension<"cl_arm_integer_dot_product_accumulate_int16">;
6755 def ArmIntegerDotProductAccumulateSaturateInt8 : FunctionExtension<"cl_arm_integer_dot_product_accumulate_saturate_int8">;
6756
6757+// Features
6758+def FuncExtGenericAddressSpace : FunctionExtension<"__opencl_c_generic_address_space">;
6759+def FuncExtWorkGroupCollective : FunctionExtension<"__opencl_c_work_group_collective_functions">;
6760+def FuncExtPipes : FunctionExtension<"__opencl_c_pipes">;
6761+def FuncExtDeviceSidEenqueue : FunctionExtension<"__opencl_c_device_enqueue">;
6762+def FuncNonExplicitAtomicFeatures : FunctionExtension<"__opencl_c_atomic_order_seq_cst __opencl_c_atomic_scope_device">;
6763+def FuncNonExplicitAtomicFeaturesAndGenericAS : FunctionExtension<"__opencl_c_atomic_order_seq_cst __opencl_c_atomic_scope_device __opencl_c_generic_address_space">;
6764+
6765 // Qualified Type. These map to ASTContext::QualType.
6766 class QualType<string _Name, bit _IsAbstract=0> {
6767 // Name of the field or function in a clang::ASTContext
6768@@ -236,13 +246,9 @@ class Builtin<string _Name, list<Type> _Signature, list<bit> _Attributes = Attr.
6769 bit IsConv = _Attributes[2];
6770 // OpenCL extensions to which the function belongs.
6771 FunctionExtension Extension = FuncExtNone;
6772- // Version of OpenCL from which the function is available (e.g.: CL10).
6773- // MinVersion is inclusive.
6774- Version MinVersion = CL10;
6775- // Version of OpenCL from which the function is not supported anymore.
6776- // MaxVersion is exclusive.
6777+ // List of OpenCL version in which this function available.
6778 // CLAll makes the function available for all versions.
6779- Version MaxVersion = CLAll;
6780+ list<Version> Versions = [CLAll];
6781 }
6782
6783 //===----------------------------------------------------------------------===//
6784@@ -421,7 +427,7 @@ foreach name = ["get_global_size", "get_global_id", "get_local_size",
6785 def : Builtin<name, [Size, UInt], Attr.Const>;
6786 }
6787
6788-let MinVersion = CL20 in {
6789+let Versions = [CL20, CL30] in {
6790 def : Builtin<"get_enqueued_local_size", [Size, UInt]>;
6791 foreach name = ["get_global_linear_id", "get_local_linear_id"] in {
6792 def : Builtin<name, [Size]>;
6793@@ -494,7 +500,7 @@ foreach name = ["fma", "mad"] in {
6794 }
6795
6796 // --- Version dependent ---
6797-let MaxVersion = CL20 in {
6798+let Versions = [CL10, CL11, CL12, CL30] in {
6799 foreach AS = [GlobalAS, LocalAS, PrivateAS] in {
6800 foreach name = ["fract", "modf", "sincos"] in {
6801 def : Builtin<name, [FGenTypeN, FGenTypeN, PointerType<FGenTypeN, AS>]>;
6802@@ -511,7 +517,9 @@ let MaxVersion = CL20 in {
6803 }
6804 }
6805 }
6806-let MinVersion = CL20 in {
6807+
6808+let Versions = [CL20, CL30] in {
6809+ let Extension = FuncExtGenericAddressSpace in {
6810 foreach name = ["fract", "modf", "sincos"] in {
6811 def : Builtin<name, [FGenTypeN, FGenTypeN, PointerType<FGenTypeN, GenericAS>]>;
6812 }
6813@@ -524,6 +532,7 @@ let MinVersion = CL20 in {
6814 def : Builtin<name, [Type, Type, Type, PointerType<GenTypeIntVecAndScalar, GenericAS>]>;
6815 }
6816 }
6817+ }
6818 }
6819
6820 // --- Table 9 ---
6821@@ -554,7 +563,7 @@ foreach name = ["abs"] in {
6822 foreach name = ["clz", "popcount"] in {
6823 def : Builtin<name, [AIGenTypeN, AIGenTypeN], Attr.Const>;
6824 }
6825-let MinVersion = CL20 in {
6826+let Versions = [CL20, CL30] in {
6827 foreach name = ["ctz"] in {
6828 def : Builtin<name, [AIGenTypeN, AIGenTypeN]>;
6829 }
6830@@ -728,7 +737,7 @@ foreach name = ["select"] in {
6831 // --- Table 15 ---
6832 // Variants for OpenCL versions below 2.0, using pointers to the global, local
6833 // and private address spaces.
6834-let MaxVersion = CL20 in {
6835+let Versions = [CL10, CL11, CL12, CL30] in {
6836 foreach AS = [GlobalAS, LocalAS, PrivateAS] in {
6837 foreach VSize = [2, 3, 4, 8, 16] in {
6838 foreach name = ["vload" # VSize] in {
6839@@ -771,7 +780,8 @@ let MaxVersion = CL20 in {
6840 }
6841 // Variants for OpenCL versions above 2.0, using pointers to the generic
6842 // address space.
6843-let MinVersion = CL20 in {
6844+let Versions = [CL20, CL30] in {
6845+ let Extension = FuncExtGenericAddressSpace in {
6846 foreach VSize = [2, 3, 4, 8, 16] in {
6847 foreach name = ["vload" # VSize] in {
6848 def : Builtin<name, [VectorType<Char, VSize>, Size, PointerType<ConstType<Char>, GenericAS>]>;
6849@@ -809,6 +819,7 @@ let MinVersion = CL20 in {
6850 }
6851 }
6852 }
6853+ }
6854 }
6855 // Variants using pointers to the constant address space.
6856 foreach VSize = [2, 3, 4, 8, 16] in {
6857@@ -829,7 +840,7 @@ foreach VSize = [2, 3, 4, 8, 16] in {
6858 def : Builtin<name, [VectorType<Float, VSize>, Size, PointerType<ConstType<Half>, ConstantAS>]>;
6859 }
6860 }
6861-let MaxVersion = CL20 in {
6862+let Versions = [CL10, CL11, CL12, CL30] in {
6863 foreach AS = [GlobalAS, LocalAS, PrivateAS] in {
6864 def : Builtin<"vload_half", [Float, Size, PointerType<ConstType<Half>, AS>]>;
6865 def : Builtin<"vloada_half", [Float, Size, PointerType<ConstType<Half>, AS>]>;
6866@@ -852,7 +863,8 @@ let MaxVersion = CL20 in {
6867 }
6868 }
6869 }
6870-let MinVersion = CL20 in {
6871+let Versions = [CL20, CL30] in {
6872+ let Extension = FuncExtGenericAddressSpace in {
6873 foreach AS = [GenericAS] in {
6874 def : Builtin<"vload_half", [Float, Size, PointerType<ConstType<Half>, AS>]>;
6875 def : Builtin<"vloada_half", [Float, Size, PointerType<ConstType<Half>, AS>]>;
6876@@ -874,6 +886,7 @@ let MinVersion = CL20 in {
6877 }
6878 }
6879 }
6880+ }
6881 }
6882
6883 foreach AS = [ConstantAS] in {
6884@@ -899,7 +912,9 @@ foreach name = ["async_work_group_strided_copy"] in {
6885 def : Builtin<name, [Event, PointerType<AGenTypeN, GlobalAS>, PointerType<ConstType<AGenTypeN>, LocalAS>, Size, Size, Event]>;
6886 }
6887 foreach name = ["wait_group_events"] in {
6888+ let Extension = FuncExtGenericAddressSpace in {
6889 def : Builtin<name, [Void, Int, PointerType<Event, GenericAS>]>;
6890+ }
6891 }
6892 foreach name = ["prefetch"] in {
6893 def : Builtin<name, [Void, PointerType<ConstType<AGenTypeN>, GlobalAS>, Size]>;
6894@@ -1000,13 +1015,25 @@ foreach AS = [GlobalAS, LocalAS] in {
6895 }
6896 }
6897 }
6898+
6899 // OpenCL v2.0 s6.13.11 - Atomic Functions.
6900-let MinVersion = CL20 in {
6901+
6902+let Versions = [CL20, CL30] in {
6903+ let Extension = FuncExtGenericAddressSpace in {
6904+ foreach TypePair = [[AtomicInt, Int], [AtomicUInt, UInt],
6905+ [AtomicLong, Long], [AtomicULong, ULong],
6906+ [AtomicFloat, Float], [AtomicDouble, Double]] in {
6907+ def : Builtin<"atomic_init",
6908+ [Void, PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[1]]>;
6909+ }
6910+ }
6911+}
6912+
6913+let Versions = [CL20, CL30] in {
6914+ let Extension = FuncNonExplicitAtomicFeaturesAndGenericAS in {
6915 foreach TypePair = [[AtomicInt, Int], [AtomicUInt, UInt],
6916 [AtomicLong, Long], [AtomicULong, ULong],
6917 [AtomicFloat, Float], [AtomicDouble, Double]] in {
6918- def : Builtin<"atomic_init",
6919- [Void, PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[1]]>;
6920 def : Builtin<"atomic_store",
6921 [Void, PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[1]]>;
6922 def : Builtin<"atomic_load",
6923@@ -1038,6 +1065,59 @@ let MinVersion = CL20 in {
6924 [TypePair[1], PointerType<VolatileType<TypePair[0]>, GenericAS>, TypePair[2]]>;
6925 }
6926 }
6927+ }
6928+}
6929+
6930+let Versions = [CL30] in {
6931+ foreach AS = [GlobalAS, LocalAS] in {
6932+ foreach TypePair = [[AtomicInt, Int], [AtomicUInt, UInt],
6933+ [AtomicLong, Long], [AtomicULong, ULong],
6934+ [AtomicFloat, Float], [AtomicDouble, Double]] in {
6935+ def : Builtin<"atomic_init",
6936+ [Void, PointerType<VolatileType<TypePair[0]>, AS>, TypePair[1]]>;
6937+ }
6938+ }
6939+}
6940+
6941+let Versions = [CL30] in {
6942+ let Extension = FuncNonExplicitAtomicFeatures in {
6943+ foreach AS = [GlobalAS, LocalAS] in {
6944+ foreach TypePair = [[AtomicInt, Int], [AtomicUInt, UInt],
6945+ [AtomicLong, Long], [AtomicULong, ULong],
6946+ [AtomicFloat, Float], [AtomicDouble, Double]] in {
6947+ def : Builtin<"atomic_store",
6948+ [Void, PointerType<VolatileType<TypePair[0]>, AS>, TypePair[1]]>;
6949+ def : Builtin<"atomic_load",
6950+ [TypePair[1], PointerType<VolatileType<TypePair[0]>, AS>]>;
6951+ def : Builtin<"atomic_exchange",
6952+ [TypePair[1], PointerType<VolatileType<TypePair[0]>, AS>, TypePair[1]]>;
6953+ foreach Variant = ["weak", "strong"] in {
6954+ def : Builtin<"atomic_compare_exchange_" # Variant,
6955+ [Bool, PointerType<VolatileType<TypePair[0]>, AS>,
6956+ PointerType<TypePair[1], AS>, TypePair[1]]>;
6957+ }
6958+ }
6959+
6960+ foreach TypePair = [[AtomicInt, Int, Int], [AtomicUInt, UInt, UInt],
6961+ [AtomicLong, Long, Long], [AtomicULong, ULong, ULong],
6962+ [AtomicIntPtr, IntPtr, PtrDiff],
6963+ [AtomicUIntPtr, UIntPtr, PtrDiff]] in {
6964+ foreach ModOp = ["add", "sub"] in {
6965+ def : Builtin<"atomic_fetch_" # ModOp,
6966+ [TypePair[1], PointerType<VolatileType<TypePair[0]>, AS>, TypePair[2]]>;
6967+ }
6968+ }
6969+ foreach TypePair = [[AtomicInt, Int, Int], [AtomicUInt, UInt, UInt],
6970+ [AtomicLong, Long, Long], [AtomicULong, ULong, ULong],
6971+ [AtomicIntPtr, IntPtr, IntPtr],
6972+ [AtomicUIntPtr, UIntPtr, UIntPtr]] in {
6973+ foreach ModOp = ["or", "xor", "and", "min", "max"] in {
6974+ def : Builtin<"atomic_fetch_" # ModOp,
6975+ [TypePair[1], PointerType<VolatileType<TypePair[0]>, AS>, TypePair[2]]>;
6976+ }
6977+ }
6978+ }
6979+ }
6980 }
6981
6982 //--------------------------------------------------------------------
6983@@ -1217,7 +1297,8 @@ foreach aQual = ["WO", "RW"] in {
6984 //--------------------------------------------------------------------
6985 // OpenCL v2.0 s6.13.15 - Work-group Functions
6986 // --- Table 26 ---
6987-let MinVersion = CL20 in {
6988+let Versions = [CL20, CL30] in {
6989+ let Extension = FuncExtWorkGroupCollective in {
6990 foreach name = ["work_group_all", "work_group_any"] in {
6991 def : Builtin<name, [Int, Int], Attr.Convergent>;
6992 }
6993@@ -1232,6 +1313,7 @@ let MinVersion = CL20 in {
6994 def : Builtin<name # op, [IntLongFloatGenType1, IntLongFloatGenType1], Attr.Convergent>;
6995 }
6996 }
6997+ }
6998 }
6999
7000
7001@@ -1241,8 +1323,10 @@ let MinVersion = CL20 in {
7002 // Defined in Builtins.def
7003
7004 // --- Table 28 ---
7005-// Builtins taking pipe arguments are defined in Builtins.def
7006-def : Builtin<"is_valid_reserve_id", [Bool, ReserveId]>;
7007+let Extension = FuncExtPipes in {
7008+ // Builtins taking pipe arguments are defined in Builtins.def
7009+ def : Builtin<"is_valid_reserve_id", [Bool, ReserveId]>;
7010+}
7011
7012 // --- Table 29 ---
7013 // Defined in Builtins.def
7014@@ -1257,21 +1341,22 @@ def : Builtin<"is_valid_reserve_id", [Bool, ReserveId]>;
7015 // Defined in Builtins.def
7016
7017 // --- Table 33 ---
7018-def : Builtin<"enqueue_marker",
7019- [Int, Queue, UInt, PointerType<ConstType<ClkEvent>, GenericAS>, PointerType<ClkEvent, GenericAS>]>;
7020+let Extension = FuncExtDeviceSidEenqueue in {
7021+ def : Builtin<"enqueue_marker",
7022+ [Int, Queue, UInt, PointerType<ConstType<ClkEvent>, GenericAS>, PointerType<ClkEvent, GenericAS>]>;
7023
7024-// --- Table 34 ---
7025-def : Builtin<"retain_event", [Void, ClkEvent]>;
7026-def : Builtin<"release_event", [Void, ClkEvent]>;
7027-def : Builtin<"create_user_event", [ClkEvent]>;
7028-def : Builtin<"is_valid_event", [Bool, ClkEvent]>;
7029-def : Builtin<"set_user_event_status", [Void, ClkEvent, Int]>;
7030-// TODO: capture_event_profiling_info
7031-
7032-// --- Table 35 ---
7033-def : Builtin<"get_default_queue", [Queue]>;
7034-// TODO: ndrange functions
7035+ // --- Table 34 ---
7036+ def : Builtin<"retain_event", [Void, ClkEvent]>;
7037+ def : Builtin<"release_event", [Void, ClkEvent]>;
7038+ def : Builtin<"create_user_event", [ClkEvent]>;
7039+ def : Builtin<"is_valid_event", [Bool, ClkEvent]>;
7040+ def : Builtin<"set_user_event_status", [Void, ClkEvent, Int]>;
7041+ // TODO: capture_event_profiling_info
7042
7043+ // --- Table 35 ---
7044+ def : Builtin<"get_default_queue", [Queue]>;
7045+ // TODO: ndrange functions
7046+}
7047
7048 //--------------------------------------------------------------------
7049 // End of the builtin functions defined in the OpenCL C specification.
7050@@ -1456,7 +1541,7 @@ let Extension = FuncExtKhrSubgroups in {
7051 "get_sub_group_local_id"] in {
7052 def : Builtin<name, [UInt]>;
7053 }
7054- let MinVersion = CL20 in {
7055+ let Versions = [CL20] in {
7056 foreach name = ["get_enqueued_num_sub_groups"] in {
7057 def : Builtin<name, [UInt]>;
7058 }
7059diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp
7060index 2f2b52106f3d..5092a4691b9b 100644
7061--- a/clang/lib/Sema/Sema.cpp
7062+++ b/clang/lib/Sema/Sema.cpp
7063@@ -291,9 +291,10 @@ void Sema::Initialize() {
7064 // Initialize predefined OpenCL types and supported extensions and (optional)
7065 // core features.
7066 if (getLangOpts().OpenCL) {
7067+ getOpenCLOptions().setOpenCLVersion(getLangOpts());
7068 getOpenCLOptions().addSupport(
7069 Context.getTargetInfo().getSupportedOpenCLOpts());
7070- getOpenCLOptions().enableSupportedCore(getLangOpts());
7071+ getOpenCLOptions().enableSupportedCore();
7072 addImplicitTypedef("sampler_t", Context.OCLSamplerTy);
7073 addImplicitTypedef("event_t", Context.OCLEventTy);
7074 if (getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) {
7075@@ -349,12 +350,18 @@ void Sema::Initialize() {
7076 "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics");
7077
7078 setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64");
7079+ setOpenCLExtensionForType(Context.OCLReserveIDTy, "__opencl_c_pipes");
7080+ setOpenCLExtensionForType(Context.OCLClkEventTy,
7081+ "__opencl_c_device_enqueue");
7082+ setOpenCLExtensionForType(Context.OCLQueueTy,
7083+ "__opencl_c_device_enqueue");
7084 }
7085
7086 setOpenCLExtensionForType(Context.DoubleTy, "cl_khr_fp64");
7087
7088-#define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \
7089- setOpenCLExtensionForType(Context.Id, Ext);
7090+#define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \
7091+ setOpenCLExtensionForType(Context.Id, Ext); \
7092+ setOpenCLExtensionForType(Context.Id, "__opencl_c_images");
7093 #include "clang/Basic/OpenCLImageTypes.def"
7094 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
7095 addImplicitTypedef(#ExtType, Context.Id##Ty); \
7096@@ -2423,6 +2430,27 @@ bool Sema::isOpenCLDisabledDecl(Decl *FD) {
7097 return false;
7098 }
7099
7100+template <typename DiagLocT, typename DiagInfoT>
7101+void Sema::DiagnoseOpenCLRequiresOption(llvm::StringRef OpenCLOptName,
7102+ DiagLocT DiagLoc, DiagInfoT DiagInfo,
7103+ unsigned Selector,
7104+ SourceRange SrcRange) {
7105+ const auto &LO = getLangOpts();
7106+ auto CLVer = LO.OpenCLCPlusPlus ? 200 : LO.OpenCLVersion;
7107+ // For versions higher that 3.0 diagnosing feature
7108+ if (CLVer >= 300) {
7109+ OpenCLOptName =
7110+ llvm::StringSwitch<llvm::StringRef>(OpenCLOptName)
7111+ .Case("cl_khr_3d_image_writes", "__opencl_c_3d_image_writes")
7112+ .Case("cl_khr_subgroups", "__opencl_c_subgroups")
7113+ .Case("cl_khr_fp64", "__opencl_c_fp64")
7114+ .Default(OpenCLOptName);
7115+ }
7116+
7117+ Diag(DiagLoc, diag::err_opencl_requires_extension)
7118+ << Selector << DiagInfo << OpenCLOptName << SrcRange;
7119+}
7120+
7121 template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
7122 bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
7123 DiagInfoT DiagInfo, MapT &Map,
7124@@ -2434,8 +2462,7 @@ bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
7125 bool Disabled = false;
7126 for (auto &I : Loc->second) {
7127 if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
7128- Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
7129- << I << SrcRange;
7130+ DiagnoseOpenCLRequiresOption(I, DiagLoc, DiagInfo, Selector, SrcRange);
7131 Disabled = true;
7132 }
7133 }
7134@@ -2471,3 +2498,13 @@ bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) {
7135 return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
7136 OpenCLDeclExtMap, 1, D.getSourceRange());
7137 }
7138+
7139+bool Sema::checkOpenCLSubgroupExtForCallExpr(CallExpr *Call) {
7140+ if (!getOpenCLOptions().isEnabled("cl_khr_subgroups")) {
7141+ DiagnoseOpenCLRequiresOption("cl_khr_subgroups", Call->getBeginLoc(),
7142+ Call->getDirectCallee(), 1,
7143+ Call->getSourceRange());
7144+ return true;
7145+ }
7146+ return false;
7147+}
7148diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
7149index 1bf04d9cb4f2..9dd63db0f420 100644
7150--- a/clang/lib/Sema/SemaChecking.cpp
7151+++ b/clang/lib/Sema/SemaChecking.cpp
7152@@ -835,20 +835,11 @@ static bool checkOpenCLBlockArgs(Sema &S, Expr *BlockArg) {
7153 return IllegalParams;
7154 }
7155
7156-static bool checkOpenCLSubgroupExt(Sema &S, CallExpr *Call) {
7157- if (!S.getOpenCLOptions().isEnabled("cl_khr_subgroups")) {
7158- S.Diag(Call->getBeginLoc(), diag::err_opencl_requires_extension)
7159- << 1 << Call->getDirectCallee() << "cl_khr_subgroups";
7160- return true;
7161- }
7162- return false;
7163-}
7164-
7165 static bool SemaOpenCLBuiltinNDRangeAndBlock(Sema &S, CallExpr *TheCall) {
7166 if (checkArgCount(S, TheCall, 2))
7167 return true;
7168
7169- if (checkOpenCLSubgroupExt(S, TheCall))
7170+ if (S.checkOpenCLSubgroupExtForCallExpr(TheCall))
7171 return true;
7172
7173 // First argument is an ndrange_t type.
7174@@ -1883,7 +1874,7 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
7175 break;
7176 case Builtin::BIsub_group_reserve_read_pipe:
7177 case Builtin::BIsub_group_reserve_write_pipe:
7178- if (checkOpenCLSubgroupExt(*this, TheCall) ||
7179+ if (checkOpenCLSubgroupExtForCallExpr(TheCall) ||
7180 SemaBuiltinReserveRWPipe(*this, TheCall))
7181 return ExprError();
7182 break;
7183@@ -1896,7 +1887,7 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
7184 break;
7185 case Builtin::BIsub_group_commit_read_pipe:
7186 case Builtin::BIsub_group_commit_write_pipe:
7187- if (checkOpenCLSubgroupExt(*this, TheCall) ||
7188+ if (checkOpenCLSubgroupExtForCallExpr(TheCall) ||
7189 SemaBuiltinCommitRWPipe(*this, TheCall))
7190 return ExprError();
7191 break;
7192@@ -4149,6 +4140,20 @@ DiagnoseCStringFormatDirectiveInCFAPI(Sema &S,
7193 }
7194 }
7195
7196+bool Sema::isSupportedOpenCLOMemoryOrdering(int64_t Ordering) const {
7197+ assert(llvm::isValidAtomicOrderingCABI(Ordering));
7198+ auto OrderingCABI = (llvm::AtomicOrderingCABI)Ordering;
7199+ switch (OrderingCABI) {
7200+ case llvm::AtomicOrderingCABI::acquire:
7201+ case llvm::AtomicOrderingCABI::release:
7202+ case llvm::AtomicOrderingCABI::acq_rel:
7203+ return OpenCLFeatures.isEnabled("__opencl_c_atomic_order_acq_rel");
7204+
7205+ default:
7206+ return true;
7207+ }
7208+}
7209+
7210 /// Determine whether the given type has a non-null nullability annotation.
7211 static bool isNonNullType(ASTContext &ctx, QualType type) {
7212 if (auto nullability = type->getNullability(ctx))
7213@@ -4920,10 +4925,17 @@ ExprResult Sema::BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
7214 if (SubExprs.size() >= 2 && Form != Init) {
7215 llvm::APSInt Result(32);
7216 if (SubExprs[1]->isIntegerConstantExpr(Result, Context) &&
7217- !isValidOrderingForOp(Result.getSExtValue(), Op))
7218+ !isValidOrderingForOp(Result.getSExtValue(), Op)) {
7219 Diag(SubExprs[1]->getBeginLoc(),
7220 diag::warn_atomic_op_has_invalid_memory_order)
7221 << SubExprs[1]->getSourceRange();
7222+ } else if (IsOpenCL &&
7223+ !isSupportedOpenCLOMemoryOrdering(Result.getSExtValue())) {
7224+ Diag(SubExprs[1]->getBeginLoc(),
7225+ diag::err_opencl_memory_ordering_require_feat)
7226+ << SubExprs[1]->getSourceRange();
7227+ return ExprError();
7228+ }
7229 }
7230
7231 if (auto ScopeModel = AtomicExpr::getScopeModel(Op)) {
7232diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
7233index 5b0417fa8859..2dee60763d57 100644
7234--- a/clang/lib/Sema/SemaDecl.cpp
7235+++ b/clang/lib/Sema/SemaDecl.cpp
7236@@ -6290,7 +6290,9 @@ void Sema::deduceOpenCLAddressSpace(ValueDecl *Decl) {
7237 if (Type->isSamplerT() || Type->isVoidType())
7238 return;
7239 LangAS ImplAS = LangAS::opencl_private;
7240- if ((getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) &&
7241+ if ((getLangOpts().OpenCLCPlusPlus ||
7242+ getOpenCLOptions().isEnabled(
7243+ "__opencl_c_program_scope_global_variables")) &&
7244 Var->hasGlobalStorage())
7245 ImplAS = LangAS::opencl_global;
7246 // If the original type from a decayed type is an array type and that array
7247@@ -7849,18 +7851,22 @@ void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {
7248 // OpenCL C v2.0 s6.5.1 - Variables defined at program scope and static
7249 // variables inside a function can also be declared in the global
7250 // address space.
7251+ // OpenCL C v3.0 s5.5 - For OpenCL C 2.0, or with the
7252+ // __opencl_c_program_scope_global_variables feature macro, the
7253+ // address space for a variable at program scope or a static variable
7254+ // also be __global
7255 // C++ for OpenCL inherits rule from OpenCL C v2.0.
7256 // FIXME: Adding local AS in C++ for OpenCL might make sense.
7257 if (NewVD->isFileVarDecl() || NewVD->isStaticLocal() ||
7258 NewVD->hasExternalStorage()) {
7259- if (!T->isSamplerT() &&
7260- !T->isDependentType() &&
7261+ if (!T->isSamplerT() && !T->isDependentType() &&
7262 !(T.getAddressSpace() == LangAS::opencl_constant ||
7263 (T.getAddressSpace() == LangAS::opencl_global &&
7264- (getLangOpts().OpenCLVersion == 200 ||
7265- getLangOpts().OpenCLCPlusPlus)))) {
7266+ (OpenCLFeatures.isEnabled(
7267+ "__opencl_c_program_scope_global_variables"))))) {
7268 int Scope = NewVD->isStaticLocal() | NewVD->hasExternalStorage() << 1;
7269- if (getLangOpts().OpenCLVersion == 200 || getLangOpts().OpenCLCPlusPlus)
7270+ if (OpenCLFeatures.isEnabled(
7271+ "__opencl_c_program_scope_global_variables"))
7272 Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space)
7273 << Scope << "global or constant";
7274 else
7275diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp
7276index a9a2a19b4797..73b35eae176a 100644
7277--- a/clang/lib/Sema/SemaDeclAttr.cpp
7278+++ b/clang/lib/Sema/SemaDeclAttr.cpp
7279@@ -6488,7 +6488,7 @@ static void handleInternalLinkageAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
7280 }
7281
7282 static void handleOpenCLNoSVMAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
7283- if (S.LangOpts.OpenCLVersion != 200)
7284+ if (S.LangOpts.OpenCLVersion < 200)
7285 S.Diag(AL.getLoc(), diag::err_attribute_requires_opencl_version)
7286 << AL << "2.0" << 0;
7287 else
7288@@ -6572,6 +6572,13 @@ static void handleOpenCLAccessAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
7289 << AL << PDecl->getType() << DeclTy->isImageType();
7290 D->setInvalidDecl(true);
7291 return;
7292+ } else if ((!S.getLangOpts().OpenCLCPlusPlus &&
7293+ S.getLangOpts().OpenCLVersion >= 200) &&
7294+ !S.getOpenCLOptions().isEnabled(
7295+ "__opencl_c_read_write_images")) {
7296+ S.Diag(AL.getLoc(), diag::err_opencl_requires_extension)
7297+ << 0 << PDecl->getType() << "__opencl_c_read_write_images";
7298+ return;
7299 }
7300 }
7301 }
7302diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
7303index 22bf35dbd0cb..b2081bb6b407 100644
7304--- a/clang/lib/Sema/SemaDeclCXX.cpp
7305+++ b/clang/lib/Sema/SemaDeclCXX.cpp
7306@@ -38,9 +38,9 @@
7307 #include "clang/Sema/ScopeInfo.h"
7308 #include "clang/Sema/SemaInternal.h"
7309 #include "clang/Sema/Template.h"
7310+#include "llvm/ADT/STLExtras.h"
7311 #include "llvm/ADT/ScopeExit.h"
7312 #include "llvm/ADT/SmallString.h"
7313-#include "llvm/ADT/STLExtras.h"
7314 #include "llvm/ADT/StringExtras.h"
7315 #include <map>
7316 #include <set>
7317@@ -15228,6 +15228,11 @@ CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl,
7318 if (auto *PtrTy = ResultType->getAs<PointerType>()) {
7319 ResultType = RemoveAddressSpaceFromPtr(SemaRef, PtrTy);
7320 }
7321+ if (CanQual<PointerType> ExpectedPtrTy =
7322+ ExpectedResultType->getAs<PointerType>()) {
7323+ ExpectedResultType = SemaRef.Context.getCanonicalType(
7324+ RemoveAddressSpaceFromPtr(SemaRef, ExpectedPtrTy->getTypePtr()));
7325+ }
7326 }
7327
7328 // Check that the result type is what we expect.
7329@@ -15261,6 +15266,11 @@ CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl,
7330 FnDecl->getParamDecl(0)->getType()->getAs<PointerType>()) {
7331 FirstParamType = RemoveAddressSpaceFromPtr(SemaRef, PtrTy);
7332 }
7333+ if (CanQual<PointerType> ExpectedPtrTy =
7334+ ExpectedFirstParamType->getAs<PointerType>()) {
7335+ ExpectedFirstParamType = SemaRef.Context.getCanonicalType(
7336+ RemoveAddressSpaceFromPtr(SemaRef, ExpectedPtrTy->getTypePtr()));
7337+ }
7338 }
7339
7340 // Check that the first parameter type is what we expect.
7341diff --git a/clang/lib/Sema/SemaLookup.cpp b/clang/lib/Sema/SemaLookup.cpp
7342index bcbecd545398..40eaebbc9495 100644
7343--- a/clang/lib/Sema/SemaLookup.cpp
7344+++ b/clang/lib/Sema/SemaLookup.cpp
7345@@ -775,19 +775,20 @@ static void InsertOCLBuiltinDeclarationsFromTable(Sema &S, LookupResult &LR,
7346 // as argument. Only meaningful for generic types, otherwise equals 1.
7347 unsigned GenTypeMaxCnt;
7348
7349+ ASTContext &Context = S.Context;
7350+
7351+ // Ignore this BIF if its version does not match the language options.
7352+ unsigned OpenCLVersion = Context.getLangOpts().OpenCLVersion;
7353+ if (Context.getLangOpts().OpenCLCPlusPlus)
7354+ OpenCLVersion = 200;
7355+
7356+ unsigned short VersionCode = OpenCLOptions::EncodeVersion(OpenCLVersion);
7357+
7358 for (unsigned SignatureIndex = 0; SignatureIndex < Len; SignatureIndex++) {
7359 const OpenCLBuiltinStruct &OpenCLBuiltin =
7360 BuiltinTable[FctIndex + SignatureIndex];
7361- ASTContext &Context = S.Context;
7362
7363- // Ignore this BIF if its version does not match the language options.
7364- unsigned OpenCLVersion = Context.getLangOpts().OpenCLVersion;
7365- if (Context.getLangOpts().OpenCLCPlusPlus)
7366- OpenCLVersion = 200;
7367- if (OpenCLVersion < OpenCLBuiltin.MinVersion)
7368- continue;
7369- if ((OpenCLBuiltin.MaxVersion != 0) &&
7370- (OpenCLVersion >= OpenCLBuiltin.MaxVersion))
7371+ if (!(OpenCLBuiltin.AllVersions & VersionCode))
7372 continue;
7373
7374 SmallVector<QualType, 1> RetTypes;
7375diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
7376index cc151a048b98..f380a5656a57 100644
7377--- a/clang/lib/Sema/SemaType.cpp
7378+++ b/clang/lib/Sema/SemaType.cpp
7379@@ -2042,7 +2042,7 @@ static QualType deduceOpenCLPointeeAddrSpace(Sema &S, QualType PointeeType) {
7380 !PointeeType.hasAddressSpace())
7381 PointeeType = S.getASTContext().getAddrSpaceQualType(
7382 PointeeType,
7383- S.getLangOpts().OpenCLCPlusPlus || S.getLangOpts().OpenCLVersion == 200
7384+ S.getOpenCLOptions().isEnabled("__opencl_c_generic_address_space")
7385 ? LangAS::opencl_generic
7386 : LangAS::opencl_private);
7387 return PointeeType;
7388@@ -5316,9 +5316,15 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
7389 }
7390
7391 case DeclaratorChunk::Pipe: {
7392- T = S.BuildReadPipeType(T, DeclType.Loc);
7393- processTypeAttrs(state, T, TAL_DeclSpec,
7394- D.getMutableDeclSpec().getAttributes());
7395+ if (S.getOpenCLOptions().isEnabled("__opencl_c_pipes")) {
7396+ T = S.BuildReadPipeType(T, DeclType.Loc);
7397+ processTypeAttrs(state, T, TAL_DeclSpec,
7398+ D.getMutableDeclSpec().getAttributes());
7399+ } else {
7400+ D.setInvalidType(true);
7401+ T = Context.IntTy;
7402+ S.Diag(D.getIdentifierLoc(), diag::err_opencl_pipes_require_feat);
7403+ }
7404 break;
7405 }
7406 }
7407diff --git a/clang/test/CodeGenOpenCL/addr-space-struct-arg.cl b/clang/test/CodeGenOpenCL/addr-space-struct-arg.cl
7408index e1f3f6fe1419..b43d9df5935c 100644
7409--- a/clang/test/CodeGenOpenCL/addr-space-struct-arg.cl
7410+++ b/clang/test/CodeGenOpenCL/addr-space-struct-arg.cl
7411@@ -2,7 +2,8 @@
7412 // RUN: %clang_cc1 %s -emit-llvm -o - -O0 -triple amdgcn | FileCheck -enable-var-scope -check-prefixes=ALL,AMDGCN %s
7413 // RUN: %clang_cc1 %s -emit-llvm -o - -cl-std=CL2.0 -O0 -triple amdgcn | FileCheck -enable-var-scope -check-prefixes=ALL,AMDGCN,AMDGCN20 %s
7414 // RUN: %clang_cc1 %s -emit-llvm -o - -cl-std=CL1.2 -O0 -triple spir-unknown-unknown-unknown | FileCheck -enable-var-scope -check-prefixes=SPIR %s
7415-
7416+// RUN: %clang_cc1 %s -emit-llvm -o - -cl-std=CL3.0 -O0 -triple spir-unknown-unknown-unknown | FileCheck -enable-var-scope -check-prefixes=SPIR %s
7417+// RUN: %clang_cc1 %s -emit-llvm -o - -cl-std=CL3.0 -cl-ext=__opencl_c_program_scope_global_variables -O0 -triple spir-unknown-unknown-unknown | FileCheck -enable-var-scope -check-prefixes=SPIR %s
7418 typedef int int2 __attribute__((ext_vector_type(2)));
7419
7420 typedef struct {
7421@@ -39,7 +40,7 @@ struct LargeStructTwoMember {
7422 int2 y[20];
7423 };
7424
7425-#if __OPENCL_C_VERSION__ >= 200
7426+#ifdef __opencl_c_program_scope_global_variables
7427 struct LargeStructOneMember g_s;
7428 #endif
7429
7430@@ -98,7 +99,7 @@ void FuncOneLargeMember(struct LargeStructOneMember u) {
7431 // AMDGCN20: %[[r0:.*]] = bitcast %struct.LargeStructOneMember addrspace(5)* %[[byval_temp]] to i8 addrspace(5)*
7432 // AMDGCN20: call void @llvm.memcpy.p5i8.p1i8.i64(i8 addrspace(5)* align 8 %[[r0]], i8 addrspace(1)* align 8 bitcast (%struct.LargeStructOneMember addrspace(1)* @g_s to i8 addrspace(1)*), i64 800, i1 false)
7433 // AMDGCN20: call void @FuncOneLargeMember(%struct.LargeStructOneMember addrspace(5)* byval(%struct.LargeStructOneMember) align 8 %[[byval_temp]])
7434-#if __OPENCL_C_VERSION__ >= 200
7435+#ifdef __opencl_c_program_scope_global_variables
7436 void test_indirect_arg_globl(void) {
7437 FuncOneLargeMember(g_s);
7438 }
7439diff --git a/clang/test/CodeGenOpenCL/address-spaces-conversions.cl b/clang/test/CodeGenOpenCL/address-spaces-conversions.cl
7440index 52feccc540bb..9ecffcca5ee9 100644
7441--- a/clang/test/CodeGenOpenCL/address-spaces-conversions.cl
7442+++ b/clang/test/CodeGenOpenCL/address-spaces-conversions.cl
7443@@ -1,5 +1,7 @@
7444 // RUN: %clang_cc1 %s -triple x86_64-unknown-linux-gnu -O0 -ffake-address-space-map -cl-std=CL2.0 -emit-llvm -o - | FileCheck %s
7445+// RUN: %clang_cc1 %s -triple x86_64-unknown-linux-gnu -O0 -ffake-address-space-map -cl-std=CL3.0 -cl-ext=__opencl_c_generic_address_space -emit-llvm -o - | FileCheck %s
7446 // RUN: %clang_cc1 %s -triple x86_64-unknown-linux-gnu -O0 -cl-std=CL2.0 -emit-llvm -o - | FileCheck --check-prefix=CHECK-NOFAKE %s
7447+// RUN: %clang_cc1 %s -triple x86_64-unknown-linux-gnu -O0 -cl-std=CL3.0 -cl-ext=__opencl_c_generic_address_space -emit-llvm -o - | FileCheck --check-prefix=CHECK-NOFAKE %s
7448 // When -ffake-address-space-map is not used, all addr space mapped to 0 for x86_64.
7449
7450 // test that we generate address space casts everywhere we need conversions of
7451diff --git a/clang/test/CodeGenOpenCL/address-spaces-mangling.cl b/clang/test/CodeGenOpenCL/address-spaces-mangling.cl
7452index 50622f099143..e19ec8451d0d 100644
7453--- a/clang/test/CodeGenOpenCL/address-spaces-mangling.cl
7454+++ b/clang/test/CodeGenOpenCL/address-spaces-mangling.cl
7455@@ -6,6 +6,7 @@
7456 // We check that the address spaces are mangled the same in both version of OpenCL
7457 // RUN: %clang_cc1 %s -triple spir-unknown-unknown -cl-std=CL2.0 -emit-llvm -o - | FileCheck -check-prefix=OCL-20 %s
7458 // RUN: %clang_cc1 %s -triple spir-unknown-unknown -cl-std=CL1.2 -emit-llvm -o - | FileCheck -check-prefix=OCL-12 %s
7459+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -cl-std=CL3.0 -emit-llvm -o - | FileCheck -check-prefix=OCL-12 %s
7460
7461 // We can't name this f as private is equivalent to default
7462 // no specifier given address space so we get multiple definition
7463@@ -47,7 +48,7 @@ void f(constant int *arg) { }
7464 // OCL-20-DAG: @_Z1fPU3AS2i
7465 // OCL-12-DAG: @_Z1fPU3AS2i
7466
7467-#if __OPENCL_C_VERSION__ >= 200
7468+#if __OPENCL_C_VERSION__ == 200
7469 __attribute__((overloadable))
7470 void f(generic int *arg) { }
7471 // ASMANG20: @_Z1fPU3AS4i
7472diff --git a/clang/test/CodeGenOpenCL/address-spaces.cl b/clang/test/CodeGenOpenCL/address-spaces.cl
7473index 144466a690b3..b150e1080b53 100644
7474--- a/clang/test/CodeGenOpenCL/address-spaces.cl
7475+++ b/clang/test/CodeGenOpenCL/address-spaces.cl
7476@@ -1,9 +1,13 @@
7477 // RUN: %clang_cc1 %s -O0 -ffake-address-space-map -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,SPIR
7478+// RUN: %clang_cc1 %s -O0 -cl-std=CL3.0 -ffake-address-space-map -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,SPIR
7479 // RUN: %clang_cc1 %s -O0 -DCL20 -cl-std=CL2.0 -ffake-address-space-map -emit-llvm -o - | FileCheck %s --check-prefixes=CL20,CL20SPIR
7480 // RUN: %clang_cc1 %s -O0 -triple amdgcn-amd-amdhsa -emit-llvm -o - | FileCheck --check-prefixes=CHECK,AMDGCN %s
7481+// RUN: %clang_cc1 %s -O0 -cl-std=CL3.0 -triple amdgcn-amd-amdhsa -emit-llvm -o - | FileCheck --check-prefixes=CHECK,AMDGCN %s
7482 // RUN: %clang_cc1 %s -O0 -triple amdgcn-amd-amdhsa -DCL20 -cl-std=CL2.0 -emit-llvm -o - | FileCheck %s --check-prefixes=CL20,CL20AMDGCN
7483 // RUN: %clang_cc1 %s -O0 -triple amdgcn-mesa-mesa3d -emit-llvm -o - | FileCheck --check-prefixes=CHECK,AMDGCN %s
7484+// RUN: %clang_cc1 %s -O0 -cl-std=CL3.0 -triple amdgcn-mesa-mesa3d -emit-llvm -o - | FileCheck --check-prefixes=CHECK,AMDGCN %s
7485 // RUN: %clang_cc1 %s -O0 -triple r600-- -emit-llvm -o - | FileCheck --check-prefixes=CHECK,AMDGCN %s
7486+// RUN: %clang_cc1 %s -O0 -cl-std=CL3.0 -triple r600-- -emit-llvm -o - | FileCheck --check-prefixes=CHECK,AMDGCN %s
7487
7488 // SPIR: %struct.S = type { i32, i32, i32* }
7489 // CL20SPIR: %struct.S = type { i32, i32, i32 addrspace(4)* }
7490diff --git a/clang/test/CodeGenOpenCL/amdgcn-automatic-variable.cl b/clang/test/CodeGenOpenCL/amdgcn-automatic-variable.cl
7491index 7216cb517495..8d3b30fe8074 100644
7492--- a/clang/test/CodeGenOpenCL/amdgcn-automatic-variable.cl
7493+++ b/clang/test/CodeGenOpenCL/amdgcn-automatic-variable.cl
7494@@ -1,4 +1,5 @@
7495 // RUN: %clang_cc1 -O0 -cl-std=CL1.2 -triple amdgcn---amdgizcl -emit-llvm %s -o - | FileCheck -check-prefixes=CHECK,CL12 %s
7496+// RUN: %clang_cc1 -O0 -cl-std=CL3.0 -triple amdgcn---amdgizcl -emit-llvm %s -o - | FileCheck -check-prefixes=CHECK,CL12 %s
7497 // RUN: %clang_cc1 -O0 -cl-std=CL2.0 -triple amdgcn---amdgizcl -emit-llvm %s -o - | FileCheck -check-prefixes=CHECK,CL20 %s
7498
7499 // CL12-LABEL: define void @func1(i32 addrspace(5)* %x)
7500diff --git a/clang/test/CodeGenOpenCL/amdgpu-sizeof-alignof.cl b/clang/test/CodeGenOpenCL/amdgpu-sizeof-alignof.cl
7501index a5d438933fa4..8073c7756eb6 100644
7502--- a/clang/test/CodeGenOpenCL/amdgpu-sizeof-alignof.cl
7503+++ b/clang/test/CodeGenOpenCL/amdgpu-sizeof-alignof.cl
7504@@ -4,6 +4,17 @@
7505 // RUN: %clang_cc1 -triple amdgcn---opencl -cl-std=CL2.0 %s -emit-llvm -o - | FileCheck %s
7506 // RUN: %clang_cc1 -triple amdgcn---amdgizcl -cl-std=CL1.2 %s -emit-llvm -o - | FileCheck %s
7507 // RUN: %clang_cc1 -triple amdgcn---amdgizcl -cl-std=CL2.0 %s -emit-llvm -o - | FileCheck %s
7508+// RUN: %clang_cc1 -triple r600 -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7509+// RUN: %clang_cc1 -triple amdgcn-mesa-mesa3d -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7510+// RUN: %clang_cc1 -triple amdgcn---opencl -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7511+// RUN: %clang_cc1 -triple amdgcn---amdgizcl -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7512+// RUN: %clang_cc1 -triple amdgcn-mesa-mesa3d -cl-ext=__opencl_c_generic_address_space -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7513+// RUN: %clang_cc1 -triple amdgcn---opencl -cl-ext=__opencl_c_generic_address_space -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7514+// RUN: %clang_cc1 -triple amdgcn---amdgizcl -cl-ext=__opencl_c_generic_address_space -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7515+// RUN: %clang_cc1 -triple r600 -cl-ext=__opencl_c_fp64 -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7516+// RUN: %clang_cc1 -triple amdgcn-mesa-mesa3d -cl-ext=__opencl_c_fp64 -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7517+// RUN: %clang_cc1 -triple amdgcn---opencl -cl-ext=__opencl_c_fp64 -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7518+// RUN: %clang_cc1 -triple amdgcn---amdgizcl -cl-ext=__opencl_c_fp64 -cl-std=CL3.0 %s -emit-llvm -o - | FileCheck %s
7519
7520 #ifdef __AMDGCN__
7521 #define PTSIZE 8
7522@@ -11,7 +22,7 @@
7523 #define PTSIZE 4
7524 #endif
7525
7526-#ifdef cl_khr_fp64
7527+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
7528 #pragma OPENCL EXTENSION cl_khr_fp64 : enable
7529 #endif
7530 #ifdef cl_khr_fp16
7531@@ -59,8 +70,12 @@ void test() {
7532 check(__alignof__(double) == 8);
7533 #endif
7534
7535- check(sizeof(void*) == (__OPENCL_C_VERSION__ >= 200 ? 8 : 4));
7536- check(__alignof__(void*) == (__OPENCL_C_VERSION__ >= 200 ? 8 : 4));
7537+ check(sizeof(private void*) == 4);
7538+ check(__alignof__(private void*) == 4);
7539+#ifdef __opencl_c_generic_address_space
7540+ check(sizeof(generic void*) == 8);
7541+ check(__alignof__(generic void*) == 8);
7542+#endif
7543 check(sizeof(global_ptr_t) == PTSIZE);
7544 check(__alignof__(global_ptr_t) == PTSIZE);
7545 check(sizeof(constant_ptr_t) == PTSIZE);
7546diff --git a/clang/test/CodeGenOpenCL/arm-integer-dot-product.cl b/clang/test/CodeGenOpenCL/arm-integer-dot-product.cl
7547index d1ab6aceac5c..70c5bace023b 100644
7548--- a/clang/test/CodeGenOpenCL/arm-integer-dot-product.cl
7549+++ b/clang/test/CodeGenOpenCL/arm-integer-dot-product.cl
7550@@ -1,4 +1,5 @@
7551 // RUN: %clang_cc1 %s -triple spir-unknown-unknown -finclude-default-header -cl-std=CL1.2 -emit-llvm -o - -O0 | FileCheck %s
7552+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -finclude-default-header -cl-std=CL3.0 -emit-llvm -o - -O0 | FileCheck %s
7553
7554 #pragma OPENCL EXTENSION cl_arm_integer_dot_product_int8 : enable
7555 void test_int8(uchar4 ua, uchar4 ub, char4 sa, char4 sb) {
7556diff --git a/clang/test/CodeGenOpenCL/cl-uniform-wg-size.cl b/clang/test/CodeGenOpenCL/cl-uniform-wg-size.cl
7557index 76ace5dca21e..5dc43e222f75 100644
7558--- a/clang/test/CodeGenOpenCL/cl-uniform-wg-size.cl
7559+++ b/clang/test/CodeGenOpenCL/cl-uniform-wg-size.cl
7560@@ -1,6 +1,8 @@
7561 // RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL1.2 -o - %s 2>&1 | FileCheck %s -check-prefixes CHECK,CHECK-UNIFORM
7562 // RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL2.0 -o - %s 2>&1 | FileCheck %s -check-prefixes CHECK,CHECK-NONUNIFORM
7563 // RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL2.0 -cl-uniform-work-group-size -o - %s 2>&1 | FileCheck %s -check-prefixes CHECK,CHECK-UNIFORM
7564+// RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL3.0 -o - %s 2>&1 | FileCheck %s -check-prefixes CHECK,CHECK-NONUNIFORM
7565+// RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL3.0 -cl-uniform-work-group-size -o - %s 2>&1 | FileCheck %s -check-prefixes CHECK,CHECK-UNIFORM
7566
7567 kernel void ker() {};
7568 // CHECK: define{{.*}}@ker() #0
7569diff --git a/clang/test/CodeGenOpenCL/fpmath.cl b/clang/test/CodeGenOpenCL/fpmath.cl
7570index 0108d909c94e..b28392739c71 100644
7571--- a/clang/test/CodeGenOpenCL/fpmath.cl
7572+++ b/clang/test/CodeGenOpenCL/fpmath.cl
7573@@ -2,6 +2,8 @@
7574 // RUN: %clang_cc1 %s -emit-llvm -o - -triple spir-unknown-unknown -cl-fp32-correctly-rounded-divide-sqrt | FileCheck --check-prefix=CHECK --check-prefix=DIVOPT %s
7575 // RUN: %clang_cc1 %s -emit-llvm -o - -DNOFP64 -cl-std=CL1.2 -triple r600-unknown-unknown -target-cpu r600 -pedantic | FileCheck --check-prefix=CHECK-FLT %s
7576 // RUN: %clang_cc1 %s -emit-llvm -o - -DFP64 -cl-std=CL1.2 -triple spir-unknown-unknown -pedantic | FileCheck --check-prefix=CHECK-DBL %s
7577+// RUN: %clang_cc1 %s -emit-llvm -o - -DNOFP64 -cl-std=CL3.0 -triple r600-unknown-unknown -target-cpu r600 -pedantic | FileCheck --check-prefix=CHECK-FLT %s
7578+// RUN: %clang_cc1 %s -emit-llvm -o - -DFP64 -cl-std=CL3.0 -cl-ext=__opencl_c_fp64 -triple spir-unknown-unknown -pedantic | FileCheck --check-prefix=CHECK-DBL %s
7579
7580 typedef __attribute__(( ext_vector_type(4) )) float float4;
7581
7582diff --git a/clang/test/CodeGenOpenCL/generic-address-space-feature.cl b/clang/test/CodeGenOpenCL/generic-address-space-feature.cl
7583new file mode 100644
7584index 000000000000..890860abe4d9
7585--- /dev/null
7586+++ b/clang/test/CodeGenOpenCL/generic-address-space-feature.cl
7587@@ -0,0 +1,28 @@
7588+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -O0 -cl-std=CL1.2 -cl-ext=-cl_khr_fp64 -finclude-default-header -emit-llvm -o - | FileCheck %s --check-prefixes=CL12
7589+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -O0 -cl-std=CL1.2 -cl-ext=-cl_khr_fp64 -fdeclare-opencl-builtins -emit-llvm -o - | FileCheck %s --check-prefixes=CL12
7590+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -O0 -cl-std=CL2.0 -cl-ext=-cl_khr_fp64 -finclude-default-header -emit-llvm -o - | FileCheck %s --check-prefixes=CL20
7591+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -O0 -cl-std=CL2.0 -cl-ext=-cl_khr_fp64 -fdeclare-opencl-builtins -emit-llvm -o - | FileCheck %s --check-prefixes=CL20
7592+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -O0 -cl-std=CL3.0 -cl-ext=-cl_khr_fp64 -finclude-default-header -emit-llvm -o - | FileCheck %s --check-prefixes=CL30
7593+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -O0 -cl-std=CL3.0 -cl-ext=-cl_khr_fp64,__opencl_c_generic_address_space -finclude-default-header -emit-llvm -o - | FileCheck %s --check-prefixes=CL30-GENERIC
7594+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -O0 -cl-std=CL3.0 -cl-ext=-cl_khr_fp64 -fdeclare-opencl-builtins -emit-llvm -o - | FileCheck %s --check-prefixes=CL30
7595+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -O0 -cl-std=CL3.0 -cl-ext=-cl_khr_fp64,__opencl_c_generic_address_space -fdeclare-opencl-builtins -emit-llvm -o - | FileCheck %s --check-prefixes=CL30-GENERIC
7596+
7597+void test(global float* src1, local float *src2, private float *src3, float *src4, float tmp) {
7598+ // CL20: %{{.+}} = addrspacecast float addrspace(1)* %{{.+}} to float addrspace(4)*
7599+ // CL12-NOT: addrspacecast
7600+ // CL30-NOT: addrspacecast
7601+ // CL30-GENERIC-NOT: addrspacecast
7602+ tmp = sincos(tmp, src1);
7603+ // CL20: %{{.+}} = addrspacecast float addrspace(3)* %{{.+}} to float addrspace(4)*
7604+ // CL12-NOT: addrspacecast
7605+ // CL30-NOT: addrspacecast
7606+ // CL30-GENERIC-NOT: addrspacecast
7607+ tmp = sincos(tmp, src2);
7608+
7609+ // CL12: %{{.+}} = call {{(spir_func )?}}float [[FUNCNAME:@.*sincos.*]](float %{{.+}}, float* {{.+}})
7610+ // CL20: %{{.+}} = call {{(spir_func )?}}float [[FUNCNAME:@.*sincos.*]](float %{{.+}}, float addrspace(4)* {{.+}})
7611+ // CL30: %{{.+}} = call {{(spir_func )?}}float [[FUNCNAME:@.*sincos.*]](float %{{.+}}, float* {{.+}})
7612+ // CL30-GENERIC: %{{.+}} = call {{(spir_func )?}}float [[FUNCNAME:@.*sincos.*]](float %{{.+}}, float addrspace(4)* {{.+}})
7613+ // CHECK: addrspacecast
7614+ tmp = sincos(tmp, src4);
7615+}
7616diff --git a/clang/test/CodeGenOpenCL/intel-subgroups-avc-ext-types.cl b/clang/test/CodeGenOpenCL/intel-subgroups-avc-ext-types.cl
7617index 515f13f6e768..5aa31ac6f345 100644
7618--- a/clang/test/CodeGenOpenCL/intel-subgroups-avc-ext-types.cl
7619+++ b/clang/test/CodeGenOpenCL/intel-subgroups-avc-ext-types.cl
7620@@ -1,4 +1,5 @@
7621 // RUN: %clang_cc1 %s -triple spir-unknown-unknown -cl-std=CL1.2 -cl-ext=+cl_intel_device_side_avc_motion_estimation -emit-llvm -o - -O0 | FileCheck %s
7622+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -cl-std=CL3.0 -cl-ext=+cl_intel_device_side_avc_motion_estimation -emit-llvm -o - -O0 | FileCheck %s
7623
7624 // CHECK: %opencl.intel_sub_group_avc_mce_payload_t = type opaque
7625 // CHECK: %opencl.intel_sub_group_avc_ime_payload_t = type opaque
7626diff --git a/clang/test/CodeGenOpenCL/kernels-have-spir-cc-by-default.cl b/clang/test/CodeGenOpenCL/kernels-have-spir-cc-by-default.cl
7627index e89237623478..3d6708ac361f 100644
7628--- a/clang/test/CodeGenOpenCL/kernels-have-spir-cc-by-default.cl
7629+++ b/clang/test/CodeGenOpenCL/kernels-have-spir-cc-by-default.cl
7630@@ -1,5 +1,8 @@
7631 // RUN: %clang_cc1 %s -cl-std=CL1.2 -emit-llvm -triple x86_64-unknown-unknown -o - | FileCheck %s
7632 // RUN: %clang_cc1 %s -cl-std=CL1.2 -emit-llvm -triple amdgcn-unknown-unknown -o - | FileCheck -check-prefixes=AMDGCN %s
7633+// RUN: %clang_cc1 %s -cl-std=CL3.0 -cl-ext=__opencl_c_fp64 -emit-llvm -triple x86_64-unknown-unknown -o - | FileCheck %s
7634+// RUN: %clang_cc1 %s -cl-std=CL3.0 -cl-ext=__opencl_c_fp64 -emit-llvm -triple amdgcn-unknown-unknown -o - | FileCheck -check-prefixes=AMDGCN %s
7635+
7636 // Test that the kernels always use the SPIR calling convention
7637 // to have unambiguous mapping of arguments to feasibly implement
7638 // clSetKernelArg().
7639diff --git a/clang/test/CodeGenOpenCL/logical-ops.cl b/clang/test/CodeGenOpenCL/logical-ops.cl
7640index f083a8580ee7..499eab65039b 100644
7641--- a/clang/test/CodeGenOpenCL/logical-ops.cl
7642+++ b/clang/test/CodeGenOpenCL/logical-ops.cl
7643@@ -1,4 +1,5 @@
7644 // RUN: %clang_cc1 %s -emit-llvm -o - -cl-std=CL1.2 -O1 -triple x86_64-unknown-linux-gnu | FileCheck %s
7645+// RUN: %clang_cc1 %s -emit-llvm -o - -cl-std=CL3.0 -cl-ext=__opencl_c_fp64 -O1 -triple x86_64-unknown-linux-gnu | FileCheck %s
7646 // RUN: %clang_cc1 %s -emit-llvm -o - -cl-std=clc++ -O1 -triple x86_64-unknown-linux-gnu | FileCheck %s
7647
7648 #pragma OPENCL EXTENSION cl_khr_fp64 : enable
7649diff --git a/clang/test/CodeGenOpenCL/no-half.cl b/clang/test/CodeGenOpenCL/no-half.cl
7650index aee8f678f01a..46da7fa339e8 100644
7651--- a/clang/test/CodeGenOpenCL/no-half.cl
7652+++ b/clang/test/CodeGenOpenCL/no-half.cl
7653@@ -1,6 +1,7 @@
7654 // RUN: %clang_cc1 %s -cl-std=cl2.0 -emit-llvm -o - -triple spir-unknown-unknown | FileCheck %s
7655 // RUN: %clang_cc1 %s -cl-std=cl1.2 -emit-llvm -o - -triple spir-unknown-unknown | FileCheck %s
7656 // RUN: %clang_cc1 %s -cl-std=cl1.1 -emit-llvm -o - -triple spir-unknown-unknown | FileCheck %s
7657+// RUN: %clang_cc1 %s -cl-std=cl3.0 -cl-ext=__opencl_c_fp64 -emit-llvm -o - -triple spir-unknown-unknown | FileCheck %s
7658
7659 #pragma OPENCL EXTENSION cl_khr_fp64:enable
7660
7661diff --git a/clang/test/CodeGenOpenCL/pipe_builtin.cl b/clang/test/CodeGenOpenCL/pipe_builtin.cl
7662index 02b9669b7ab1..0bf35c336199 100644
7663--- a/clang/test/CodeGenOpenCL/pipe_builtin.cl
7664+++ b/clang/test/CodeGenOpenCL/pipe_builtin.cl
7665@@ -1,4 +1,7 @@
7666 // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -cl-ext=+cl_khr_subgroups -O0 -cl-std=clc++ -o - %s | FileCheck %s
7667+// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -cl-ext=+cl_khr_subgroups -O0 -cl-std=cl2.0 -o - %s | FileCheck %s
7668+// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -cl-ext=+cl_khr_subgroups -O0 -cl-std=cl3.0 -cl-ext=__opencl_c_pipes,__opencl_c_subgroups -o - %s | FileCheck %s
7669+
7670 // FIXME: Add MS ABI manglings of OpenCL things and remove %itanium_abi_triple
7671 // above to support OpenCL in the MS C++ ABI.
7672
7673diff --git a/clang/test/CodeGenOpenCL/pipe_types.cl b/clang/test/CodeGenOpenCL/pipe_types.cl
7674index ba064c6d7557..b7a523d4f084 100644
7675--- a/clang/test/CodeGenOpenCL/pipe_types.cl
7676+++ b/clang/test/CodeGenOpenCL/pipe_types.cl
7677@@ -1,4 +1,5 @@
7678 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -O0 -cl-std=CL2.0 -o - %s | FileCheck %s
7679+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -O0 -cl-std=CL3.0 -cl-ext=__opencl_c_pipes -o - %s | FileCheck %s
7680
7681 // CHECK: %opencl.pipe_ro_t = type opaque
7682 // CHECK: %opencl.pipe_wo_t = type opaque
7683diff --git a/clang/test/CodeGenOpenCL/printf.cl b/clang/test/CodeGenOpenCL/printf.cl
7684index fc139d776db6..0133c5595d81 100644
7685--- a/clang/test/CodeGenOpenCL/printf.cl
7686+++ b/clang/test/CodeGenOpenCL/printf.cl
7687@@ -1,5 +1,7 @@
7688 // RUN: %clang_cc1 -cl-std=CL1.2 -cl-ext=-+cl_khr_fp64 -triple spir-unknown-unknown -disable-llvm-passes -emit-llvm -o - %s | FileCheck -check-prefixes=FP64,ALL %s
7689 // RUN: %clang_cc1 -cl-std=CL1.2 -cl-ext=-cl_khr_fp64 -triple spir-unknown-unknown -disable-llvm-passes -emit-llvm -o - %s | FileCheck -check-prefixes=NOFP64,ALL %s
7690+// RUN: %clang_cc1 -cl-std=CL3.0 -cl-ext=+__opencl_c_fp64 -triple spir-unknown-unknown -disable-llvm-passes -emit-llvm -o - %s | FileCheck -check-prefixes=FP64,ALL %s
7691+// RUN: %clang_cc1 -cl-std=CL3.0 -triple spir-unknown-unknown -disable-llvm-passes -emit-llvm -o - %s | FileCheck -check-prefixes=NOFP64,ALL %s
7692
7693 typedef __attribute__((ext_vector_type(2))) float float2;
7694 typedef __attribute__((ext_vector_type(2))) half half2;
7695diff --git a/clang/test/CodeGenOpenCL/unroll-hint.cl b/clang/test/CodeGenOpenCL/unroll-hint.cl
7696index 0f84450a1ae6..9347c935869b 100644
7697--- a/clang/test/CodeGenOpenCL/unroll-hint.cl
7698+++ b/clang/test/CodeGenOpenCL/unroll-hint.cl
7699@@ -1,5 +1,6 @@
7700 // RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL2.0 -o - %s | FileCheck %s
7701 // RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL1.2 -o - %s | FileCheck %s
7702+// RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL3.0 -o - %s | FileCheck %s
7703
7704 /*** for ***/
7705 void for_count()
7706diff --git a/clang/test/Driver/autocomplete.c b/clang/test/Driver/autocomplete.c
7707index 18b31320ea80..a6e7be887c8c 100644
7708--- a/clang/test/Driver/autocomplete.c
7709+++ b/clang/test/Driver/autocomplete.c
7710@@ -43,6 +43,8 @@
7711 // CLSTDALL-NEXT: CL1.2
7712 // CLSTDALL-NEXT: cl2.0
7713 // CLSTDALL-NEXT: CL2.0
7714+// CLSTDALL-NEXT: cl3.0
7715+// CLSTDALL-NEXT: CL3.0
7716 // CLSTDALL-NEXT: clc++
7717 // CLSTDALL-NEXT: CLC++
7718 // RUN: %clang --autocomplete=-fno-sanitize-coverage=,f | FileCheck %s -check-prefix=FNOSANICOVER
7719diff --git a/clang/test/Driver/opencl.cl b/clang/test/Driver/opencl.cl
7720index 05588f2c8b81..cc0a9143ab37 100644
7721--- a/clang/test/Driver/opencl.cl
7722+++ b/clang/test/Driver/opencl.cl
7723@@ -2,6 +2,7 @@
7724 // RUN: %clang -S -### -cl-std=CL1.1 %s 2>&1 | FileCheck --check-prefix=CHECK-CL11 %s
7725 // RUN: %clang -S -### -cl-std=CL1.2 %s 2>&1 | FileCheck --check-prefix=CHECK-CL12 %s
7726 // RUN: %clang -S -### -cl-std=CL2.0 %s 2>&1 | FileCheck --check-prefix=CHECK-CL20 %s
7727+// RUN: %clang -S -### -cl-std=CL3.0 %s 2>&1 | FileCheck --check-prefix=CHECK-CL30 %s
7728 // RUN: %clang -S -### -cl-std=clc++ %s 2>&1 | FileCheck --check-prefix=CHECK-CLCPP %s
7729 // RUN: %clang -S -### -cl-opt-disable %s 2>&1 | FileCheck --check-prefix=CHECK-OPT-DISABLE %s
7730 // RUN: %clang -S -### -cl-strict-aliasing %s 2>&1 | FileCheck --check-prefix=CHECK-STRICT-ALIASING %s
7731@@ -22,6 +23,7 @@
7732 // CHECK-CL11: "-cc1" {{.*}} "-cl-std=CL1.1"
7733 // CHECK-CL12: "-cc1" {{.*}} "-cl-std=CL1.2"
7734 // CHECK-CL20: "-cc1" {{.*}} "-cl-std=CL2.0"
7735+// CHECK-CL30: "-cc1" {{.*}} "-cl-std=CL3.0"
7736 // CHECK-CLCPP: "-cc1" {{.*}} "-cl-std=clc++"
7737 // CHECK-OPT-DISABLE: "-cc1" {{.*}} "-cl-opt-disable"
7738 // CHECK-STRICT-ALIASING: "-cc1" {{.*}} "-cl-strict-aliasing"
7739diff --git a/clang/test/Driver/unknown-std.cl b/clang/test/Driver/unknown-std.cl
7740index 6f371bac13ac..00209fb62556 100644
7741--- a/clang/test/Driver/unknown-std.cl
7742+++ b/clang/test/Driver/unknown-std.cl
7743@@ -10,6 +10,7 @@
7744 // CHECK-NEXT: note: use 'cl1.1' for 'OpenCL 1.1' standard
7745 // CHECK-NEXT: note: use 'cl1.2' for 'OpenCL 1.2' standard
7746 // CHECK-NEXT: note: use 'cl2.0' for 'OpenCL 2.0' standard
7747+// CHECK-NEXT: note: use 'cl3.0' for 'OpenCL 3.0' standard
7748 // CHECK-NEXT: note: use 'clc++' for 'C++ for OpenCL' standard
7749
7750 // Make sure that no other output is present.
7751diff --git a/clang/test/Frontend/stdlang.c b/clang/test/Frontend/stdlang.c
7752index 51484999e37a..eac4632fbdd6 100644
7753--- a/clang/test/Frontend/stdlang.c
7754+++ b/clang/test/Frontend/stdlang.c
7755@@ -9,6 +9,7 @@
7756 // RUN: %clang_cc1 -x cl -cl-std=CL1.1 -DOPENCL %s
7757 // RUN: %clang_cc1 -x cl -cl-std=CL1.2 -DOPENCL %s
7758 // RUN: %clang_cc1 -x cl -cl-std=CL2.0 -DOPENCL %s
7759+// RUN: %clang_cc1 -x cl -cl-std=CL3.0 -DOPENCL %s
7760 // RUN: %clang_cc1 -x cl -cl-std=CLC++ -DOPENCL %s
7761 // RUN: not %clang_cc1 -x cl -std=c99 -DOPENCL %s 2>&1 | FileCheck --check-prefix=CHECK-C99 %s
7762 // RUN: not %clang_cc1 -x cl -cl-std=invalid -DOPENCL %s 2>&1 | FileCheck --check-prefix=CHECK-INVALID %s
7763diff --git a/clang/test/Headers/opencl-c-header.cl b/clang/test/Headers/opencl-c-header.cl
7764index 1b151ffdd16a..2716076acdcf 100644
7765--- a/clang/test/Headers/opencl-c-header.cl
7766+++ b/clang/test/Headers/opencl-c-header.cl
7767@@ -1,6 +1,7 @@
7768 // RUN: %clang_cc1 -O0 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s -verify | FileCheck %s
7769 // RUN: %clang_cc1 -O0 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s -verify -cl-std=CL1.1 | FileCheck %s
7770 // RUN: %clang_cc1 -O0 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s -verify -cl-std=CL1.2 | FileCheck %s
7771+// RUN: %clang_cc1 -O0 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s -verify -cl-std=CL3.0 | FileCheck %s
7772 // RUN: %clang_cc1 -O0 -triple spir-unknown-unknown -internal-isystem ../../lib/Headers -include opencl-c.h -emit-llvm -o - %s -verify -cl-std=clc++ | FileCheck %s --check-prefix=CHECK20
7773
7774 // Test including the default header as a module.
7775@@ -39,9 +40,11 @@
7776 // RUN: rm -rf %t
7777 // RUN: mkdir -p %t
7778 // RUN: %clang_cc1 -triple spir64-unknown-unknown -emit-llvm -o - -cl-std=CL1.2 -finclude-default-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ftime-report %s 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=CHECK-MOD %s
7779+// RUN: %clang_cc1 -triple spir64-unknown-unknown -emit-llvm -o - -cl-std=CL3.0 -finclude-default-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ftime-report %s 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=CHECK-MOD %s
7780 // RUN: %clang_cc1 -triple amdgcn--amdhsa -O0 -emit-llvm -o - -cl-std=CL2.0 -finclude-default-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ftime-report %s 2>&1 | FileCheck --check-prefix=CHECK20 --check-prefix=CHECK-MOD %s
7781 // RUN: chmod u-w %t
7782 // RUN: %clang_cc1 -triple spir64-unknown-unknown -emit-llvm -o - -cl-std=CL1.2 -finclude-default-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ftime-report %s 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=CHECK-MOD %s
7783+// RUN: %clang_cc1 -triple spir64-unknown-unknown -emit-llvm -o - -cl-std=CL3.0 -finclude-default-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ftime-report %s 2>&1 | FileCheck --check-prefix=CHECK --check-prefix=CHECK-MOD %s
7784 // RUN: %clang_cc1 -triple amdgcn--amdhsa -O0 -emit-llvm -o - -cl-std=CL2.0 -finclude-default-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -ftime-report %s 2>&1 | FileCheck --check-prefix=CHECK20 --check-prefix=CHECK-MOD %s
7785 // RUN: chmod u+w %t
7786
7787@@ -67,7 +70,7 @@ char f(char x) {
7788 // from OpenCL 2.0 onwards.
7789
7790 // CHECK20: _Z12write_imagef14ocl_image3d_wo
7791-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
7792+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ == CL_VERSION_2_0)
7793 void test_image3dwo(write_only image3d_t img) {
7794 write_imagef(img, (0), (0.0f));
7795 }
7796@@ -81,7 +84,7 @@ void test_atomics(__generic volatile unsigned int* a) {
7797 #endif
7798
7799 // Verify that ATOMIC_VAR_INIT is defined.
7800-#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
7801+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ == CL_VERSION_2_0)
7802 global atomic_int z = ATOMIC_VAR_INIT(99);
7803 #endif //__OPENCL_C_VERSION__
7804
7805diff --git a/clang/test/Index/pipe-size.cl b/clang/test/Index/pipe-size.cl
7806index 94a1255f0a48..59b76051eda1 100644
7807--- a/clang/test/Index/pipe-size.cl
7808+++ b/clang/test/Index/pipe-size.cl
7809@@ -2,6 +2,13 @@
7810 // RUN: %clang_cc1 -x cl -O0 -cl-std=CL2.0 -emit-llvm -triple spir-unknown-unknown %s -o - | FileCheck %s --check-prefix=SPIR
7811 // RUN: %clang_cc1 -x cl -O0 -cl-std=CL2.0 -emit-llvm -triple spir64-unknown-unknown %s -o - | FileCheck %s --check-prefix=SPIR64
7812 // RUN: %clang_cc1 -x cl -O0 -cl-std=CL2.0 -emit-llvm -triple amdgcn-amd-amdhsa %s -o - | FileCheck %s --check-prefix=AMDGCN
7813+// RUN: %clang_cc1 -x cl -O0 -cl-std=CL3.0 -cl-ext=__opencl_c_pipes -emit-llvm -triple x86_64-unknown-linux-gnu %s -o - | FileCheck %s --check-prefix=X86
7814+// RUN: %clang_cc1 -x cl -O0 -cl-std=CL3.0 -cl-ext=__opencl_c_pipes -emit-llvm -triple spir-unknown-unknown %s -o - | FileCheck %s --check-prefix=SPIR
7815+// RUN: %clang_cc1 -x cl -O0 -cl-std=CL3.0 -cl-ext=__opencl_c_pipes -emit-llvm -triple spir64-unknown-unknown %s -o - | FileCheck %s --check-prefix=SPIR64
7816+// RUN: %clang_cc1 -x cl -O0 -cl-std=CL3.0 -cl-ext=__opencl_c_pipes -emit-llvm -triple amdgcn-amd-amdhsa %s -o - | FileCheck %s --check-prefix=AMDGCN
7817+
7818+
7819+
7820 __kernel void testPipe( pipe int test )
7821 {
7822 int s = sizeof(test);
7823diff --git a/clang/test/Preprocessor/init-aarch64.c b/clang/test/Preprocessor/init-aarch64.c
7824index df2a6128989b..cbb0995b48b0 100644
7825--- a/clang/test/Preprocessor/init-aarch64.c
7826+++ b/clang/test/Preprocessor/init-aarch64.c
7827@@ -109,12 +109,12 @@
7828 // AARCH64-NEXT: #define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 1
7829 // AARCH64_CXX-NEXT: #define __GLIBCXX_BITSIZE_INT_N_0 128
7830 // AARCH64_CXX-NEXT: #define __GLIBCXX_TYPE_INT_N_0 __int128
7831-// AARCH64-NEXT: #define __INT16_C_SUFFIX__
7832+// AARCH64-NEXT: #define __INT16_C_SUFFIX__
7833 // AARCH64-NEXT: #define __INT16_FMTd__ "hd"
7834 // AARCH64-NEXT: #define __INT16_FMTi__ "hi"
7835 // AARCH64-NEXT: #define __INT16_MAX__ 32767
7836 // AARCH64-NEXT: #define __INT16_TYPE__ short
7837-// AARCH64-NEXT: #define __INT32_C_SUFFIX__
7838+// AARCH64-NEXT: #define __INT32_C_SUFFIX__
7839 // AARCH64-NEXT: #define __INT32_FMTd__ "d"
7840 // AARCH64-NEXT: #define __INT32_FMTi__ "i"
7841 // AARCH64-NEXT: #define __INT32_MAX__ 2147483647
7842@@ -124,7 +124,7 @@
7843 // AARCH64-NEXT: #define __INT64_FMTi__ "li"
7844 // AARCH64-NEXT: #define __INT64_MAX__ 9223372036854775807L
7845 // AARCH64-NEXT: #define __INT64_TYPE__ long int
7846-// AARCH64-NEXT: #define __INT8_C_SUFFIX__
7847+// AARCH64-NEXT: #define __INT8_C_SUFFIX__
7848 // AARCH64-NEXT: #define __INT8_FMTd__ "hhd"
7849 // AARCH64-NEXT: #define __INT8_FMTi__ "hhi"
7850 // AARCH64-NEXT: #define __INT8_MAX__ 127
7851@@ -238,7 +238,7 @@
7852 // AARCH64-NEXT: #define __STDC_UTF_32__ 1
7853 // AARCH64_C: #define __STDC_VERSION__ 201710L
7854 // AARCH64-NEXT: #define __STDC__ 1
7855-// AARCH64-NEXT: #define __UINT16_C_SUFFIX__
7856+// AARCH64-NEXT: #define __UINT16_C_SUFFIX__
7857 // AARCH64-NEXT: #define __UINT16_FMTX__ "hX"
7858 // AARCH64-NEXT: #define __UINT16_FMTo__ "ho"
7859 // AARCH64-NEXT: #define __UINT16_FMTu__ "hu"
7860@@ -259,7 +259,7 @@
7861 // AARCH64-NEXT: #define __UINT64_FMTx__ "lx"
7862 // AARCH64-NEXT: #define __UINT64_MAX__ 18446744073709551615UL
7863 // AARCH64-NEXT: #define __UINT64_TYPE__ long unsigned int
7864-// AARCH64-NEXT: #define __UINT8_C_SUFFIX__
7865+// AARCH64-NEXT: #define __UINT8_C_SUFFIX__
7866 // AARCH64-NEXT: #define __UINT8_FMTX__ "hhX"
7867 // AARCH64-NEXT: #define __UINT8_FMTo__ "hho"
7868 // AARCH64-NEXT: #define __UINT8_FMTu__ "hhu"
7869@@ -329,7 +329,7 @@
7870 // AARCH64-NEXT: #define __UINT_LEAST8_FMTx__ "hhx"
7871 // AARCH64-NEXT: #define __UINT_LEAST8_MAX__ 255
7872 // AARCH64-NEXT: #define __UINT_LEAST8_TYPE__ unsigned char
7873-// AARCH64-NEXT: #define __USER_LABEL_PREFIX__
7874+// AARCH64-NEXT: #define __USER_LABEL_PREFIX__
7875 // AARCH64-NEXT: #define __VERSION__ "{{.*}}"
7876 // AARCH64-NEXT: #define __WCHAR_MAX__ 4294967295U
7877 // AARCH64-NEXT: #define __WCHAR_TYPE__ unsigned int
7878diff --git a/clang/test/Preprocessor/predefined-macros.c b/clang/test/Preprocessor/predefined-macros.c
7879index 083f0e539d88..6c80517ec4d4 100644
7880--- a/clang/test/Preprocessor/predefined-macros.c
7881+++ b/clang/test/Preprocessor/predefined-macros.c
7882@@ -129,6 +129,8 @@
7883 // RUN: | FileCheck -match-full-lines %s --check-prefix=CHECK-CL12
7884 // RUN: %clang_cc1 %s -E -dM -o - -x cl -cl-std=CL2.0 \
7885 // RUN: | FileCheck -match-full-lines %s --check-prefix=CHECK-CL20
7886+// RUN: %clang_cc1 %s -E -dM -o - -x cl -cl-std=CL3.0 \
7887+// RUN: | FileCheck -match-full-lines %s --check-prefix=CHECK-CL30
7888 // RUN: %clang_cc1 %s -E -dM -o - -x cl -cl-fast-relaxed-math \
7889 // RUN: | FileCheck -match-full-lines %s --check-prefix=CHECK-FRM
7890 // RUN: %clang_cc1 %s -E -dM -o - -x cl -cl-std=clc++ \
7891@@ -137,26 +139,37 @@
7892 // CHECK-CL10: #define CL_VERSION_1_1 110
7893 // CHECK-CL10: #define CL_VERSION_1_2 120
7894 // CHECK-CL10: #define CL_VERSION_2_0 200
7895+// CHECK-CL10: #define CL_VERSION_3_0 300
7896 // CHECK-CL10: #define __OPENCL_C_VERSION__ 100
7897 // CHECK-CL10-NOT: #define __FAST_RELAXED_MATH__ 1
7898 // CHECK-CL11: #define CL_VERSION_1_0 100
7899 // CHECK-CL11: #define CL_VERSION_1_1 110
7900 // CHECK-CL11: #define CL_VERSION_1_2 120
7901 // CHECK-CL11: #define CL_VERSION_2_0 200
7902+// CHECK-CL11: #define CL_VERSION_3_0 300
7903 // CHECK-CL11: #define __OPENCL_C_VERSION__ 110
7904 // CHECK-CL11-NOT: #define __FAST_RELAXED_MATH__ 1
7905 // CHECK-CL12: #define CL_VERSION_1_0 100
7906 // CHECK-CL12: #define CL_VERSION_1_1 110
7907 // CHECK-CL12: #define CL_VERSION_1_2 120
7908 // CHECK-CL12: #define CL_VERSION_2_0 200
7909+// CHECK-CL12: #define CL_VERSION_3_0 300
7910 // CHECK-CL12: #define __OPENCL_C_VERSION__ 120
7911 // CHECK-CL12-NOT: #define __FAST_RELAXED_MATH__ 1
7912 // CHECK-CL20: #define CL_VERSION_1_0 100
7913 // CHECK-CL20: #define CL_VERSION_1_1 110
7914 // CHECK-CL20: #define CL_VERSION_1_2 120
7915 // CHECK-CL20: #define CL_VERSION_2_0 200
7916+// CHECK-CL20: #define CL_VERSION_3_0 300
7917 // CHECK-CL20: #define __OPENCL_C_VERSION__ 200
7918 // CHECK-CL20-NOT: #define __FAST_RELAXED_MATH__ 1
7919+// CHECK-CL30: #define CL_VERSION_1_0 100
7920+// CHECK-CL30: #define CL_VERSION_1_1 110
7921+// CHECK-CL30: #define CL_VERSION_1_2 120
7922+// CHECK-CL30: #define CL_VERSION_2_0 200
7923+// CHECK-CL30: #define CL_VERSION_3_0 300
7924+// CHECK-CL30: #define __OPENCL_C_VERSION__ 300
7925+// CHECK-CL30-NOT: #define __FAST_RELAXED_MATH__ 1
7926 // CHECK-FRM: #define __FAST_RELAXED_MATH__ 1
7927 // CHECK-CLCPP10: #define __CL_CPP_VERSION_1_0__ 100
7928 // CHECK-CLCPP10: #define __OPENCL_CPP_VERSION__ 100
7929diff --git a/clang/test/Sema/feature-extensions-simult-support.cl b/clang/test/Sema/feature-extensions-simult-support.cl
7930new file mode 100644
7931index 000000000000..0789105002b2
7932--- /dev/null
7933+++ b/clang/test/Sema/feature-extensions-simult-support.cl
7934@@ -0,0 +1,75 @@
7935+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2 -cl-ext=-cl_khr_fp64
7936+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2 -cl-ext=+cl_khr_fp64
7937+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2 -cl-ext=-cl_khr_3d_image_writes
7938+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2 -cl-ext=+cl_khr_3d_image_writes
7939+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2 -cl-ext=-cl_khr_subgroups
7940+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2 -cl-ext=+cl_khr_subgroups
7941+
7942+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -cl-ext=-cl_khr_fp64
7943+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -cl-ext=+cl_khr_fp64
7944+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -cl-ext=-cl_khr_3d_image_writes
7945+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -cl-ext=+cl_khr_3d_image_writes
7946+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -cl-ext=-cl_khr_subgroups
7947+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -cl-ext=+cl_khr_subgroups
7948+
7949+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_fp64
7950+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_3d_image_writes
7951+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_subgroups
7952+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_pipes
7953+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_device_enqueue
7954+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_read_write_images
7955+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_fp64,-cl_khr_fp64
7956+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_3d_image_writes,-cl_khr_3d_image_writes
7957+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+__opencl_c_subgroups,-cl_khr_subgroups
7958+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+cl_khr_fp64
7959+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+cl_khr_3d_image_writes
7960+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=+cl_khr_subgroups
7961+
7962+// expected-no-diagnostics
7963+
7964+#ifdef cl_khr_fp64
7965+ #ifndef __opencl_c_fp64
7966+ #error macros were not properly set up
7967+ #endif
7968+#endif
7969+#ifdef __opencl_c_fp64
7970+ #ifndef cl_khr_fp64
7971+ #error macros were not properly set up
7972+ #endif
7973+#endif
7974+
7975+#ifdef cl_khr_3d_image_writes
7976+ #ifndef __opencl_c_3d_image_writes
7977+ #error macros were not properly set up
7978+ #endif
7979+#endif
7980+#ifdef __opencl_c_3d_image_writes
7981+ #ifndef cl_khr_3d_image_writes
7982+ #error macros were not properly set up
7983+ #endif
7984+#endif
7985+
7986+#ifdef cl_khr_subgroups
7987+ #ifndef __opencl_c_subgroups
7988+ #error macros were not properly set up
7989+ #endif
7990+#endif
7991+#ifdef __opencl_c_subgroups
7992+ #ifndef cl_khr_subgroups
7993+ #error macros were not properly set up
7994+ #endif
7995+#endif
7996+
7997+#if defined(__opencl_c_pipes) || defined(__opencl_c_device_enqueue)
7998+ #ifndef __opencl_c_generic_address_space
7999+ #error macros were not properly set up
8000+ #endif
8001+#endif
8002+
8003+#if defined(__opencl_c_3d_image_writes) || defined(__opencl_c_read_write_images)
8004+ #ifndef __opencl_c_images
8005+ #error macros were not properly set up
8006+ #endif
8007+#endif
8008+
8009+kernel void test(){}
8010diff --git a/clang/test/Sema/features-ignore-pragma.cl b/clang/test/Sema/features-ignore-pragma.cl
8011new file mode 100644
8012index 000000000000..046ce5390754
8013--- /dev/null
8014+++ b/clang/test/Sema/features-ignore-pragma.cl
8015@@ -0,0 +1,24 @@
8016+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0
8017+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=__opencl_c_fp64
8018+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=__opencl_c_subgroups
8019+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=__opencl_c_3d_image_writes
8020+
8021+#pragma OPENCL EXTENSION __opencl_c_fp64 : enable
8022+// expected-warning@-1 {{OpenCL feature support can't be controlled via pragma, ignoring}}
8023+
8024+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
8025+#ifndef __opencl_c_fp64
8026+// expected-warning@-2{{unsupported OpenCL extension 'cl_khr_fp64' - ignoring}}
8027+#endif
8028+
8029+#pragma OPENCL EXTENSION cl_khr_subgroups : enable
8030+#ifndef __opencl_c_subgroups
8031+// expected-warning@-2{{unsupported OpenCL extension 'cl_khr_subgroups' - ignoring}}
8032+#endif
8033+
8034+#pragma OPENCL EXTENSION cl_khr_3d_image_writes : enable
8035+#ifndef __opencl_c_3d_image_writes
8036+// expected-warning@-2{{unsupported OpenCL extension 'cl_khr_3d_image_writes' - ignoring}}
8037+#endif
8038+
8039+kernel void foo() {}
8040diff --git a/clang/test/Sema/opencl-features-pipes.cl b/clang/test/Sema/opencl-features-pipes.cl
8041new file mode 100644
8042index 000000000000..c0ac778f24a6
8043--- /dev/null
8044+++ b/clang/test/Sema/opencl-features-pipes.cl
8045@@ -0,0 +1,18 @@
8046+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.1
8047+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2
8048+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -DHAS
8049+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0
8050+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=__opencl_c_pipes -DHAS
8051+// expected-no-diagnostics
8052+
8053+#ifdef HAS
8054+ #ifndef __opencl_c_pipes
8055+ #error Feature should be defined
8056+ #endif
8057+#else
8058+ #ifdef __opencl_c_pipes
8059+ #error Feature should not be defined
8060+ #endif
8061+#endif
8062+
8063+kernel void foo() {}
8064diff --git a/clang/test/Sema/opencl-features.cl b/clang/test/Sema/opencl-features.cl
8065new file mode 100644
8066index 000000000000..aa432f6b60bf
8067--- /dev/null
8068+++ b/clang/test/Sema/opencl-features.cl
8069@@ -0,0 +1,128 @@
8070+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0
8071+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -cl-ext=-__opencl_c_device_enqueue,-__opencl_c_pipes,-__opencl_c_read_write_images
8072+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CLC++
8073+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0
8074+// expected-no-diagnostics
8075+
8076+#ifndef __opencl_c_int64
8077+ #error Feature __opencl_c_int64 shouldn't be defined
8078+#endif
8079+
8080+#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ == CL_VERSION_2_0)
8081+ #ifndef __opencl_c_3d_image_writes
8082+ #error Feature __opencl_c_3d_image_writes should be defined
8083+ #endif
8084+
8085+ #ifndef __opencl_c_atomic_order_acq_rel
8086+ #error Feature __opencl_c_atomic_order_acq_rel should be defined
8087+ #endif
8088+
8089+ #ifndef __opencl_c_atomic_order_seq_cst
8090+ #error Feature __opencl_c_atomic_order_seq_cst should be defined
8091+ #endif
8092+
8093+ #ifndef __opencl_c_atomic_scope_device
8094+ #error Feature __opencl_c_atomic_scope_device should be defined
8095+ #endif
8096+
8097+ #ifndef __opencl_c_atomic_scope_all_devices
8098+ #error Feature __opencl_c_atomic_scope_all_devices should be defined
8099+ #endif
8100+
8101+ #ifndef __opencl_c_device_enqueue
8102+ #error Feature __opencl_c_device_enqueue should be defined
8103+ #endif
8104+
8105+ #ifndef __opencl_c_generic_address_space
8106+ #error Feature __opencl_c_generic_address_space should be defined
8107+ #endif
8108+
8109+ #ifndef __opencl_c_pipes
8110+ #error Feature __opencl_c_pipes should be defined
8111+ #endif
8112+
8113+ #ifndef __opencl_c_program_scope_global_variables
8114+ #error Feature __opencl_c_program_scope_global_variables should be defined
8115+ #endif
8116+
8117+ #ifndef __opencl_c_read_write_images
8118+ #error Feature __opencl_c_read_write_images should be defined
8119+ #endif
8120+
8121+ #ifndef __opencl_c_subgroups
8122+ #error Feature __opencl_c_subgroups should be defined
8123+ #endif
8124+
8125+ #ifndef __opencl_c_work_group_collective_functions
8126+ #error Feature __opencl_c_work_group_collective_functions should be defined
8127+ #endif
8128+
8129+ #ifndef __opencl_c_fp64
8130+ #error Feature __opencl_c_fp64 should be defined
8131+ #endif
8132+
8133+ #ifndef __opencl_c_images
8134+ #error Feature __opencl_c_images should be defined
8135+ #endif
8136+#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
8137+
8138+
8139+#if __OPENCL_C_VERSION__ == CL_VERSION_3_0
8140+ #ifdef __opencl_c_3d_image_writes
8141+ #error Feature __opencl_c_3d_image_writes shouldn't be defined
8142+ #endif
8143+
8144+ #ifdef __opencl_c_atomic_order_acq_rel
8145+ #error Feature __opencl_c_atomic_order_acq_rel shouldn't be defined
8146+ #endif
8147+
8148+ #ifdef __opencl_c_atomic_order_seq_cst
8149+ #error Feature __opencl_c_atomic_order_seq_cst shouldn't be defined
8150+ #endif
8151+
8152+ #ifdef __opencl_c_atomic_scope_device
8153+ #error Feature __opencl_c_atomic_scope_device shouldn't be defined
8154+ #endif
8155+
8156+ #ifdef __opencl_c_atomic_scope_all_devices
8157+ #error Feature __opencl_c_atomic_scope_all_devices shouldn't be defined
8158+ #endif
8159+
8160+ #ifdef __opencl_c_device_enqueue
8161+ #error Feature __opencl_c_device_enqueue shouldn't be defined
8162+ #endif
8163+
8164+ #ifdef __opencl_c_generic_address_space
8165+ #error Feature __opencl_c_generic_address_space shouldn't be defined
8166+ #endif
8167+
8168+ #ifdef __opencl_c_pipes
8169+ #error Feature __opencl_c_pipes shouldn't be defined
8170+ #endif
8171+
8172+ #ifdef __opencl_c_program_scope_global_variables
8173+ #error Feature __opencl_c_program_scope_global_variables shouldn't be defined
8174+ #endif
8175+
8176+ #ifdef __opencl_c_read_write_images
8177+ #error Feature __opencl_c_read_write_images shouldn't be defined
8178+ #endif
8179+
8180+ #ifdef __opencl_c_subgroups
8181+ #error Feature __opencl_c_subgroups shouldn't be defined
8182+ #endif
8183+
8184+ #ifdef __opencl_c_work_group_collective_functions
8185+ #error Feature __opencl_c_work_group_collective_functions shouldn't be defined
8186+ #endif
8187+
8188+ #ifdef __opencl_c_fp64
8189+ #error Feature __opencl_c_fp64 shouldn't be defined
8190+ #endif
8191+
8192+ #ifdef __opencl_c_images
8193+ #error Feature __opencl_c_images shouldn't be defined
8194+ #endif
8195+#endif // __OPENCL_C_VERSION__ == CL_VERSION_3_0
8196+
8197+kernel void foo() {}
8198diff --git a/clang/test/Sema/pipe_builtins_feature.cl b/clang/test/Sema/pipe_builtins_feature.cl
8199new file mode 100644
8200index 000000000000..56fa94fc7705
8201--- /dev/null
8202+++ b/clang/test/Sema/pipe_builtins_feature.cl
8203@@ -0,0 +1,21 @@
8204+// RUN: %clang_cc1 -cl-std=CL2.0 -fsyntax-only -verify %s
8205+// RUN: %clang_cc1 -cl-std=CL3.0 -fsyntax-only -verify %s
8206+// RUN: %clang_cc1 -cl-std=CL3.0 -cl-ext=__opencl_c_pipes -fsyntax-only -verify %s
8207+
8208+#ifdef __opencl_c_pipes
8209+ #ifndef __opencl_c_generic_address_space
8210+ #error Generic address space feature must also be defined
8211+ #endif
8212+// CHECK: expected-no-diagnostics
8213+// check that pragma disable all doesn't touch feature support
8214+ #pragma OPENCL EXTENSION all : disable
8215+#endif
8216+
8217+void test(read_only pipe int p, global int *ptr) {
8218+ reserve_id_t rid;
8219+}
8220+
8221+#ifndef __opencl_c_pipes
8222+// expected-error@-5 {{expected parameter declarator}} expected-error@-5 {{expected ')'}} expected-note@-5 {{to match this '('}}
8223+// expected-error@-5 {{use of type 'reserve_id_t' requires __opencl_c_pipes extension to be enabled}}
8224+#endif
8225diff --git a/clang/test/SemaOpenCL/address-spaces-conversions-cl2.0.cl b/clang/test/SemaOpenCL/address-spaces-conversions-cl2.0.cl
8226index a5a838241347..dbdc5cffd073 100644
8227--- a/clang/test/SemaOpenCL/address-spaces-conversions-cl2.0.cl
8228+++ b/clang/test/SemaOpenCL/address-spaces-conversions-cl2.0.cl
8229@@ -1,6 +1,9 @@
8230 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DCONSTANT -cl-std=CL2.0
8231 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DGLOBAL -cl-std=CL2.0
8232 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DGENERIC -cl-std=CL2.0
8233+// RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DCONSTANT -cl-std=CL3.0 -cl-ext=__opencl_c_generic_address_space
8234+// RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DGLOBAL -cl-std=CL3.0 -cl-ext=__opencl_c_generic_address_space
8235+// RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DGENERIC -cl-std=CL3.0 -cl-ext=__opencl_c_generic_address_space
8236 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DCONSTANT -cl-std=clc++
8237 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DGLOBAL -cl-std=clc++
8238 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -DGENERIC -cl-std=clc++
8239diff --git a/clang/test/SemaOpenCL/address-spaces.cl b/clang/test/SemaOpenCL/address-spaces.cl
8240index e9825fd1682a..563f1e649a82 100644
8241--- a/clang/test/SemaOpenCL/address-spaces.cl
8242+++ b/clang/test/SemaOpenCL/address-spaces.cl
8243@@ -1,5 +1,6 @@
8244 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only
8245 // RUN: %clang_cc1 %s -cl-std=CL2.0 -verify -pedantic -fsyntax-only
8246+// RUN: %clang_cc1 %s -cl-std=CL3.0 -cl-ext=__opencl_c_generic_address_space -verify -pedantic -fsyntax-only
8247 // RUN: %clang_cc1 %s -cl-std=clc++ -verify -pedantic -fsyntax-only
8248
8249 __constant int ci = 1;
8250diff --git a/clang/test/SemaOpenCL/cl20-device-side-enqueue.cl b/clang/test/SemaOpenCL/cl20-device-side-enqueue.cl
8251index f63e2913c749..727141190a0b 100644
8252--- a/clang/test/SemaOpenCL/cl20-device-side-enqueue.cl
8253+++ b/clang/test/SemaOpenCL/cl20-device-side-enqueue.cl
8254@@ -2,6 +2,12 @@
8255 // RUN: %clang_cc1 %s -cl-std=CL2.0 -triple "spir-unknown-unknown" -verify -pedantic -fsyntax-only -DB32 -DQUALS="const volatile"
8256 // RUN: %clang_cc1 %s -cl-std=CL2.0 -triple "spir64-unknown-unknown" -verify -pedantic -fsyntax-only -Wconversion -DWCONV -DQUALS=
8257 // RUN: %clang_cc1 %s -cl-std=CL2.0 -triple "spir64-unknown-unknown" -verify -pedantic -fsyntax-only -Wconversion -DWCONV -DQUALS="const volatile"
8258+// RUN: %clang_cc1 %s -cl-std=CL3.0 -triple "spir-unknown-unknown" -cl-ext=__opencl_c_device_enqueue,__opencl_c_subgroups -verify -pedantic -fsyntax-only -DB32 -DQUALS=
8259+// RUN: %clang_cc1 %s -cl-std=CL3.0 -triple "spir-unknown-unknown" -cl-ext=__opencl_c_device_enqueue,__opencl_c_subgroups -verify -pedantic -fsyntax-only -DB32 -DQUALS="const volatile"
8260+// RUN: %clang_cc1 %s -cl-std=CL3.0 -triple "spir64-unknown-unknown" -cl-ext=__opencl_c_device_enqueue,__opencl_c_subgroups -verify -pedantic -fsyntax-only -Wconversion -DWCONV -DQUALS=
8261+// RUN: %clang_cc1 %s -cl-std=CL3.0 -triple "spir64-unknown-unknown" -cl-ext=__opencl_c_device_enqueue,__opencl_c_subgroups -verify -pedantic -fsyntax-only -Wconversion -DWCONV -DQUALS="const volatile"
8262+
8263+
8264
8265 typedef struct {int a;} ndrange_t;
8266 // Diagnostic tests for different overloads of enqueue_kernel from Table 6.13.17.1 of OpenCL 2.0 Spec.
8267@@ -235,11 +241,17 @@ kernel void bar(global unsigned int *buf)
8268 kernel void foo1(global unsigned int *buf)
8269 {
8270 ndrange_t n;
8271- buf[0] = get_kernel_max_sub_group_size_for_ndrange(n, ^(){}); // expected-error {{use of declaration 'get_kernel_max_sub_group_size_for_ndrange' requires cl_khr_subgroups extension to be enabled}}
8272+ buf[0] = get_kernel_max_sub_group_size_for_ndrange(n, ^(){});
8273+#if __OPENCL_C_VERSION__ < 300
8274+// expected-error@-2 {{use of declaration 'get_kernel_max_sub_group_size_for_ndrange' requires cl_khr_subgroups extension to be enabled}}
8275+#endif
8276 }
8277
8278 kernel void bar1(global unsigned int *buf)
8279 {
8280 ndrange_t n;
8281- buf[0] = get_kernel_sub_group_count_for_ndrange(n, ^(){}); // expected-error {{use of declaration 'get_kernel_sub_group_count_for_ndrange' requires cl_khr_subgroups extension to be enabled}}
8282+ buf[0] = get_kernel_sub_group_count_for_ndrange(n, ^(){});
8283+#if __OPENCL_C_VERSION__ < 300
8284+// expected-error@-2 {{use of declaration 'get_kernel_sub_group_count_for_ndrange' requires cl_khr_subgroups extension to be enabled}}
8285+#endif
8286 }
8287diff --git a/clang/test/SemaOpenCL/forget-unsupported-builtins.cl b/clang/test/SemaOpenCL/forget-unsupported-builtins.cl
8288new file mode 100644
8289index 000000000000..14dd03e2c7db
8290--- /dev/null
8291+++ b/clang/test/SemaOpenCL/forget-unsupported-builtins.cl
8292@@ -0,0 +1,22 @@
8293+// RUN: %clang_cc1 -cl-std=cl3.0 -fsyntax-only -verify %s -triple spir-unknown-unknown
8294+// RUN: %clang_cc1 -cl-std=cl3.0 -fsyntax-only -cl-ext=__opencl_c_pipes,__opencl_c_generic_address_space,__opencl_c_device_enqueue -verify %s -triple spir-unknown-unknown -DFEATURES
8295+
8296+#ifndef FEATURES
8297+ // expected-no-diagnostics
8298+#else
8299+ // expected-error@+10 {{cannot redeclare builtin function 'get_pipe_max_packets'}}
8300+ // expected-note@+9 {{'get_pipe_max_packets' is a builtin with type 'unsigned int ()'}}
8301+ // expected-error@+9 {{cannot redeclare builtin function 'to_local'}}
8302+ // expected-note@+8 {{'to_local' is a builtin with type 'void *(void *)'}}
8303+ // expected-error@+8 {{cannot redeclare builtin function 'to_global'}}
8304+ // expected-note@+7 {{'to_global' is a builtin with type 'void *(void *)'}}
8305+ // expected-error@+7 {{cannot redeclare builtin function 'get_kernel_work_group_size'}}
8306+ // expected-note@+6 {{'get_kernel_work_group_size' is a builtin with type 'unsigned int ()'}}
8307+#endif
8308+
8309+int get_pipe_max_packets(int);
8310+int to_local(int);
8311+int to_global(int);
8312+int get_kernel_work_group_size(int);
8313+
8314+kernel void test(global int *dst) {}
8315diff --git a/clang/test/SemaOpenCL/image-features.cl b/clang/test/SemaOpenCL/image-features.cl
8316new file mode 100644
8317index 000000000000..ace6913bb31e
8318--- /dev/null
8319+++ b/clang/test/SemaOpenCL/image-features.cl
8320@@ -0,0 +1,20 @@
8321+// RUN: %clang_cc1 -cl-std=cl2.0 -fsyntax-only -verify %s -triple spir-unknown-unknown
8322+// RUN: %clang_cc1 -cl-std=cl3.0 -cl-ext=__opencl_c_images -fsyntax-only -verify %s -triple spir-unknown-unknown
8323+// RUN: %clang_cc1 -cl-std=cl3.0 -cl-ext=__opencl_c_3d_image_writes -fsyntax-only -verify %s -triple spir-unknown-unknown
8324+// RUN: %clang_cc1 -cl-std=cl3.0 -cl-ext=__opencl_c_read_write_images -fsyntax-only -verify %s -triple spir-unknown-unknown
8325+
8326+#if defined(__opencl_c_read_write_images) && defined(__opencl_c_3d_image_writes)
8327+ // expected-no-diagnostics
8328+#endif
8329+
8330+__kernel void write_3d_image(__write_only image3d_t i) {}
8331+
8332+#ifndef __opencl_c_3d_image_writes
8333+ // expected-error@-3 {{use of type '__write_only image3d_t' requires __opencl_c_3d_image_writes extension to be enabled}}
8334+#endif
8335+
8336+__kernel void read_write_3d_image(__read_write image3d_t i) { }
8337+
8338+#ifndef __opencl_c_read_write_images
8339+ // expected-error@-3 {{use of type '__read_write image3d_t' requires __opencl_c_read_write_images extension to be enabled}}
8340+#endif
8341diff --git a/clang/test/SemaOpenCL/invalid-pipe-builtin-cl2.0.cl b/clang/test/SemaOpenCL/invalid-pipe-builtin-cl2.0.cl
8342index 36e76621d24a..38b0a04726e3 100644
8343--- a/clang/test/SemaOpenCL/invalid-pipe-builtin-cl2.0.cl
8344+++ b/clang/test/SemaOpenCL/invalid-pipe-builtin-cl2.0.cl
8345@@ -1,4 +1,5 @@
8346 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0 -cl-ext=+cl_khr_subgroups
8347+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=__opencl_c_subgroups,__opencl_c_pipes
8348
8349 #pragma OPENCL EXTENSION cl_khr_subgroups : enable
8350
8351diff --git a/clang/test/SemaOpenCL/storageclass-cl20.cl b/clang/test/SemaOpenCL/storageclass-cl20.cl
8352index 581701d2a6a5..469c526ebc30 100644
8353--- a/clang/test/SemaOpenCL/storageclass-cl20.cl
8354+++ b/clang/test/SemaOpenCL/storageclass-cl20.cl
8355@@ -1,4 +1,5 @@
8356 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0
8357+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL3.0 -cl-ext=__opencl_c_program_scope_global_variables,__opencl_c_generic_address_space
8358
8359 int G2 = 0;
8360 global int G3 = 0;
8361diff --git a/clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp b/clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp
8362index 7c63cf51ecfa..785ff93aaf85 100644
8363--- a/clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp
8364+++ b/clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp
8365@@ -56,6 +56,7 @@
8366 //===----------------------------------------------------------------------===//
8367
8368 #include "TableGenBackends.h"
8369+#include "clang/Basic/OpenCLOptions.h"
8370 #include "llvm/ADT/MapVector.h"
8371 #include "llvm/ADT/STLExtras.h"
8372 #include "llvm/ADT/SmallString.h"
8373@@ -69,6 +70,7 @@
8374 #include "llvm/TableGen/Record.h"
8375 #include "llvm/TableGen/StringMatcher.h"
8376 #include "llvm/TableGen/TableGenBackend.h"
8377+#include <numeric>
8378 #include <set>
8379
8380 using namespace llvm;
8381@@ -228,6 +230,10 @@ private:
8382 // The function "tan", having the same signatures, would be mapped to the
8383 // same entry (<I1, I2, I3>).
8384 MapVector<BuiltinIndexListTy *, BuiltinTableEntries> SignatureListMap;
8385+
8386+ // Encode all versions
8387+ unsigned short
8388+ EncodeBuiltinVersions(std::vector<Record *> BuiltinVersionsRecords) const;
8389 };
8390 } // namespace
8391
8392@@ -338,12 +344,10 @@ struct OpenCLBuiltinStruct {
8393 const bool IsConst : 1;
8394 // Function attribute __attribute__((convergent))
8395 const bool IsConv : 1;
8396+ // All opencl versions encoded
8397+ const unsigned char AllVersions : 5;
8398 // OpenCL extension(s) required for this overload.
8399 const unsigned short Extension;
8400- // First OpenCL version in which this overload was introduced (e.g. CL20).
8401- const unsigned short MinVersion;
8402- // First OpenCL version in which this overload was removed (e.g. CL20).
8403- const unsigned short MaxVersion;
8404 };
8405
8406 )";
8407@@ -510,11 +514,9 @@ void BuiltinNameEmitter::EmitBuiltinTable() {
8408 << (Overload.first->getValueAsBit("IsPure")) << ", "
8409 << (Overload.first->getValueAsBit("IsConst")) << ", "
8410 << (Overload.first->getValueAsBit("IsConv")) << ", "
8411- << FunctionExtensionIndex[ExtName] << ", "
8412- << Overload.first->getValueAsDef("MinVersion")->getValueAsInt("ID")
8413- << ", "
8414- << Overload.first->getValueAsDef("MaxVersion")->getValueAsInt("ID")
8415- << " },\n";
8416+ << EncodeBuiltinVersions(
8417+ Overload.first->getValueAsListOfDefs("Versions"))
8418+ << ", " << FunctionExtensionIndex[ExtName] << " },\n";
8419 Index++;
8420 }
8421 }
8422@@ -535,10 +537,8 @@ bool BuiltinNameEmitter::CanReuseSignature(
8423 if (Rec->getValueAsBit("IsPure") == Rec2->getValueAsBit("IsPure") &&
8424 Rec->getValueAsBit("IsConst") == Rec2->getValueAsBit("IsConst") &&
8425 Rec->getValueAsBit("IsConv") == Rec2->getValueAsBit("IsConv") &&
8426- Rec->getValueAsDef("MinVersion")->getValueAsInt("ID") ==
8427- Rec2->getValueAsDef("MinVersion")->getValueAsInt("ID") &&
8428- Rec->getValueAsDef("MaxVersion")->getValueAsInt("ID") ==
8429- Rec2->getValueAsDef("MaxVersion")->getValueAsInt("ID") &&
8430+ EncodeBuiltinVersions(Rec->getValueAsListOfDefs("Versions")) ==
8431+ EncodeBuiltinVersions(Rec2->getValueAsListOfDefs("Versions")) &&
8432 Rec->getValueAsDef("Extension")->getName() ==
8433 Rec2->getValueAsDef("Extension")->getName()) {
8434 return true;
8435@@ -814,6 +814,15 @@ static void OCL2Qual(ASTContext &Context, const OpenCLTypeStruct &Ty,
8436 OS << "\n} // OCL2Qual\n";
8437 }
8438
8439+unsigned short BuiltinNameEmitter::EncodeBuiltinVersions(
8440+ std::vector<Record *> BuiltinVersionsRecords) const {
8441+ return std::accumulate(
8442+ BuiltinVersionsRecords.begin(), BuiltinVersionsRecords.end(),
8443+ (unsigned short)0, [](unsigned short C, Record *R) {
8444+ return C |= clang::OpenCLOptions::EncodeVersion(R->getValueAsInt("ID"));
8445+ });
8446+}
8447+
8448 void clang::EmitClangOpenCLBuiltins(RecordKeeper &Records, raw_ostream &OS) {
8449 BuiltinNameEmitter NameChecker(Records, OS);
8450 NameChecker.Emit();
8451--
84522.17.1
8453
diff --git a/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm11-Remove-repo-name-in-LLVM-IR.patch b/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm11-Remove-repo-name-in-LLVM-IR.patch
deleted file mode 100644
index 09089432..00000000
--- a/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm11-Remove-repo-name-in-LLVM-IR.patch
+++ /dev/null
@@ -1,50 +0,0 @@
1From ff0a6da84b94c16c4519c649f1f7bed3cdf89bbb Mon Sep 17 00:00:00 2001
2From: Feng Zou <feng.zou@intel.com>
3Date: Tue, 20 Oct 2020 11:29:04 +0800
4Subject: [PATCH] Remove repo name in LLVM IR
5
6Upstream-Status: Backport [Taken from opencl-clang patches, https://github.com/intel/opencl-clang/blob/ocl-open-110/patches/llvm/0002-Remove-repo-name-in-LLVM-IR.patch]
7Signed-off-by: Feng Zou <feng.zou@intel.com>
8Signed-off-by: Naveen Saini <naveen.kumar.saini@intel.com>
9
10---
11 llvm/cmake/modules/VersionFromVCS.cmake | 23 ++++++++++++-----------
12 1 file changed, 12 insertions(+), 11 deletions(-)
13
14diff --git a/llvm/cmake/modules/VersionFromVCS.cmake b/llvm/cmake/modules/VersionFromVCS.cmake
15index 18edbeabe3e..2d965263478 100644
16--- a/llvm/cmake/modules/VersionFromVCS.cmake
17+++ b/llvm/cmake/modules/VersionFromVCS.cmake
18@@ -33,17 +33,18 @@ function(get_source_info path revision repository)
19 else()
20 set(remote "origin")
21 endif()
22- execute_process(COMMAND ${GIT_EXECUTABLE} remote get-url ${remote}
23- WORKING_DIRECTORY ${path}
24- RESULT_VARIABLE git_result
25- OUTPUT_VARIABLE git_output
26- ERROR_QUIET)
27- if(git_result EQUAL 0)
28- string(STRIP "${git_output}" git_output)
29- set(${repository} ${git_output} PARENT_SCOPE)
30- else()
31- set(${repository} ${path} PARENT_SCOPE)
32- endif()
33+ # Do not show repo name in IR
34+ # execute_process(COMMAND ${GIT_EXECUTABLE} remote get-url ${remote}
35+ # WORKING_DIRECTORY ${path}
36+ # RESULT_VARIABLE git_result
37+ # OUTPUT_VARIABLE git_output
38+ # ERROR_QUIET)
39+ # if(git_result EQUAL 0)
40+ # string(STRIP "${git_output}" git_output)
41+ # set(${repository} ${git_output} PARENT_SCOPE)
42+ # else()
43+ # set(${repository} ${path} PARENT_SCOPE)
44+ # endif()
45 endif()
46 else()
47 message(WARNING "Git not found. Version cannot be determined.")
48--
492.18.1
50
diff --git a/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm11-skip-building-tests.patch b/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm11-skip-building-tests.patch
deleted file mode 100644
index 011c09ee..00000000
--- a/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm11-skip-building-tests.patch
+++ /dev/null
@@ -1,51 +0,0 @@
1From d362652617c5e840089273df0c6623a9745c92a2 Mon Sep 17 00:00:00 2001
2From: Naveen Saini <naveen.kumar.saini@intel.com>
3Date: Wed, 21 Aug 2019 14:35:31 +0800
4Subject: [PATCH] llvm-spirv: skip building tests
5
6Some of these need clang to be built and since we're building this in-tree,
7that leads to problems when compiling libcxx, compiler-rt which aren't built
8in-tree.
9
10Instead of using SPIRV_SKIP_CLANG_BUILD to skip clang build and adding this to
11all components, disable the building of tests altogether.
12
13Upstream-Status: Inappropriate
14
15Signed-off-by: Anuj Mittal <anuj.mittal@intel.com>
16Signed-off-by: Naveen Saini <naveen.kumar.saini@intel.com>
17---
18 CMakeLists.txt | 10 ----------
19 1 file changed, 10 deletions(-)
20
21diff --git a/CMakeLists.txt b/CMakeLists.txt
22index ecebb4cb..578ca602 100644
23--- a/CMakeLists.txt
24+++ b/CMakeLists.txt
25@@ -25,13 +25,6 @@ if(LLVM_SPIRV_BUILD_EXTERNAL)
26 set(CMAKE_CXX_STANDARD 14)
27 set(CMAKE_CXX_STANDARD_REQUIRED ON)
28
29- if(LLVM_SPIRV_INCLUDE_TESTS)
30- set(LLVM_TEST_COMPONENTS
31- llvm-as
32- llvm-dis
33- )
34- endif(LLVM_SPIRV_INCLUDE_TESTS)
35-
36 find_package(LLVM ${BASE_LLVM_VERSION} REQUIRED
37 COMPONENTS
38 Analysis
39@@ -62,9 +55,6 @@ set(LLVM_SPIRV_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/include)
40
41 add_subdirectory(lib/SPIRV)
42 add_subdirectory(tools/llvm-spirv)
43-if(LLVM_SPIRV_INCLUDE_TESTS)
44- add_subdirectory(test)
45-endif(LLVM_SPIRV_INCLUDE_TESTS)
46
47 install(
48 FILES
49--
502.26.2
51
diff --git a/dynamic-layers/clang-layer/recipes-devtools/clang/llvm-project-source.bbappend b/dynamic-layers/clang-layer/recipes-devtools/clang/llvm-project-source.bbappend
deleted file mode 100644
index 4e2bc535..00000000
--- a/dynamic-layers/clang-layer/recipes-devtools/clang/llvm-project-source.bbappend
+++ /dev/null
@@ -1,35 +0,0 @@
1FILESEXTRAPATHS_prepend_intel-x86-common := "${THISDIR}/files:"
2
3SPIRV_BRANCH = "${@bb.utils.contains('LLVMVERSION', '10.0.1', 'llvm_release_100', 'llvm_release_110', d)}"
4
5SPIRV10_SRCREV = "576abae62cecd171992017a4a786e3831221ab8d"
6SPIRV11_SRCREV = "2a8c1e6c9778deaa720a23e08c293006dc5d56fd"
7
8SPIRV_SRCREV = "${@bb.utils.contains('LLVMVERSION', '10.0.1', '${SPIRV10_SRCREV}', '${SPIRV11_SRCREV}', d)}"
9
10SRC_URI_LLVM10 = " \
11 file://llvm10-skip-building-tests.patch;patchdir=llvm/projects/llvm-spirv \
12 file://fix-shared-libs.patch;patchdir=llvm/projects/llvm-spirv \
13 file://BasicBlockUtils-Add-metadata-fixing-in-SplitBlockPre.patch;patchdir=llvm \
14 file://IndVarSimplify-Do-not-use-SCEV-expander-for-IVCount-.patch;patchdir=llvm \
15 file://llvm10-OpenCL-3.0-support.patch \
16 file://0002-Add-cl_khr_extended_subgroup-extensions.patch \
17 file://0001-Memory-leak-fix-for-Managed-Static-Mutex.patch \
18 file://llvm10-Remove-repo-name-in-LLVM-IR.patch \
19 file://0001-Fix-debug-info-of-work-item-builtin-translation-745.patch;patchdir=llvm/projects/llvm-spirv \
20 "
21
22SRC_URI_LLVM11 = " \
23 file://llvm11-skip-building-tests.patch;patchdir=llvm/projects/llvm-spirv \
24 file://llvm11-OpenCL-3.0-support.patch \
25 file://0001-Memory-leak-fix-for-Managed-Static-Mutex.patch \
26 file://llvm11-Remove-repo-name-in-LLVM-IR.patch \
27 "
28
29SPIRV_LLVM_SRC_URI = "git://github.com/KhronosGroup/SPIRV-LLVM-Translator.git;protocol=https;branch=${SPIRV_BRANCH};destsuffix=git/llvm/projects/llvm-spirv;name=spirv"
30
31SPIRV_LLVM_PATCHES = "${@bb.utils.contains('LLVMVERSION', '10.0.1', '${SRC_URI_LLVM10}', '${SRC_URI_LLVM11}', d)}"
32
33
34SRC_URI_append_intel-x86-common = "${@bb.utils.contains('LLVMVERSION', '12.0.0', '', ' ${SPIRV_LLVM_SRC_URI} ${SPIRV_LLVM_PATCHES} ', d)}"
35SRCREV_spirv = "${@bb.utils.contains('LLVMVERSION', '12.0.0', '', '${SPIRV_SRCREV}', d)}"
generated by cgit v1.2.3-54-g00ecf (git 2.39.0) at 2024-05-15 18:47:02 +0000