summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorNaveen Saini <naveen.kumar.saini@intel.com>2021-04-08 11:02:31 +0800
committerAnuj Mittal <anuj.mittal@intel.com>2021-04-08 10:56:20 +0800
commitbdae07eceb51a038115f45a3aee2dd27323dd7b4 (patch)
treee4571fc8fee50d3eb59c1a00d7259d9798e059d3
parent01cfc99a8f960917433a8a46b41bb4febb5b1993 (diff)
downloadmeta-intel-bdae07eceb51a038115f45a3aee2dd27323dd7b4.tar.gz
llvm-project-source: backport OpenCL recommended patches
Updating SPIRV-LLVM-Translator srcrev to latest commits for * llvm_releae_100 * llvm_release_110 Backport opencl-clang recommended llvm/clang patches. llvm-10: https://github.com/intel/opencl-clang/tree/ocl-open-100/patches llvm-11: https://github.com/intel/opencl-clang/tree/ocl-open-110/patches Signed-off-by: Naveen Saini <naveen.kumar.saini@intel.com> Signed-off-by: Anuj Mittal <anuj.mittal@intel.com>
Diffstat
-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/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/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/llvm-project-source.bbappend12
8 files changed, 17788 insertions, 2 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
new file mode 100644
index 00000000..923b871f
--- /dev/null
+++ b/dynamic-layers/clang-layer/recipes-devtools/clang/files/0001-Fix-debug-info-of-work-item-builtin-translation-745.patch
@@ -0,0 +1,119 @@
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
new file mode 100644
index 00000000..103dad5e
--- /dev/null
+++ b/dynamic-layers/clang-layer/recipes-devtools/clang/files/0001-Memory-leak-fix-for-Managed-Static-Mutex.patch
@@ -0,0 +1,35 @@
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
new file mode 100644
index 00000000..cbe492c4
--- /dev/null
+++ b/dynamic-layers/clang-layer/recipes-devtools/clang/files/0002-Add-cl_khr_extended_subgroup-extensions.patch
@@ -0,0 +1,812 @@
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/llvm10-OpenCL-3.0-support.patch b/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm10-OpenCL-3.0-support.patch
new file mode 100644
index 00000000..53395ea0
--- /dev/null
+++ b/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm10-OpenCL-3.0-support.patch
@@ -0,0 +1,8259 @@
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
new file mode 100644
index 00000000..232ae063
--- /dev/null
+++ b/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm10-Remove-repo-name-in-LLVM-IR.patch
@@ -0,0 +1,50 @@
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/llvm11-OpenCL-3.0-support.patch b/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm11-OpenCL-3.0-support.patch
new file mode 100644
index 00000000..98545db0
--- /dev/null
+++ b/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm11-OpenCL-3.0-support.patch
@@ -0,0 +1,8453 @@
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
new file mode 100644
index 00000000..09089432
--- /dev/null
+++ b/dynamic-layers/clang-layer/recipes-devtools/clang/files/llvm11-Remove-repo-name-in-LLVM-IR.patch
@@ -0,0 +1,50 @@
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/llvm-project-source.bbappend b/dynamic-layers/clang-layer/recipes-devtools/clang/llvm-project-source.bbappend
index 17e991ab..4e2bc535 100644
--- a/dynamic-layers/clang-layer/recipes-devtools/clang/llvm-project-source.bbappend
+++ b/dynamic-layers/clang-layer/recipes-devtools/clang/llvm-project-source.bbappend
@@ -2,8 +2,8 @@ FILESEXTRAPATHS_prepend_intel-x86-common := "${THISDIR}/files:"
2 2
3SPIRV_BRANCH = "${@bb.utils.contains('LLVMVERSION', '10.0.1', 'llvm_release_100', 'llvm_release_110', d)}" 3SPIRV_BRANCH = "${@bb.utils.contains('LLVMVERSION', '10.0.1', 'llvm_release_100', 'llvm_release_110', d)}"
4 4
5SPIRV10_SRCREV = "4d43f68a30a510b4e7607351caab3df8e7426a6b" 5SPIRV10_SRCREV = "576abae62cecd171992017a4a786e3831221ab8d"
6SPIRV11_SRCREV = "93032d36d2fe17befb7994714c07c67ea68efbea" 6SPIRV11_SRCREV = "2a8c1e6c9778deaa720a23e08c293006dc5d56fd"
7 7
8SPIRV_SRCREV = "${@bb.utils.contains('LLVMVERSION', '10.0.1', '${SPIRV10_SRCREV}', '${SPIRV11_SRCREV}', d)}" 8SPIRV_SRCREV = "${@bb.utils.contains('LLVMVERSION', '10.0.1', '${SPIRV10_SRCREV}', '${SPIRV11_SRCREV}', d)}"
9 9
@@ -12,10 +12,18 @@ SRC_URI_LLVM10 = " \
12 file://fix-shared-libs.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 \ 13 file://BasicBlockUtils-Add-metadata-fixing-in-SplitBlockPre.patch;patchdir=llvm \
14 file://IndVarSimplify-Do-not-use-SCEV-expander-for-IVCount-.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 \
15 " 20 "
16 21
17SRC_URI_LLVM11 = " \ 22SRC_URI_LLVM11 = " \
18 file://llvm11-skip-building-tests.patch;patchdir=llvm/projects/llvm-spirv \ 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 \
19 " 27 "
20 28
21SPIRV_LLVM_SRC_URI = "git://github.com/KhronosGroup/SPIRV-LLVM-Translator.git;protocol=https;branch=${SPIRV_BRANCH};destsuffix=git/llvm/projects/llvm-spirv;name=spirv" 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"
generated by cgit v1.2.3-54-g00ecf (git 2.39.0) at 2024-04-25 02:18:48 +0000