diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -118,7 +118,8 @@
   "magnitude of floating-point constant too small for type %0; minimum is %1">,
   InGroup<LiteralRange>;
 def warn_double_const_requires_fp64 : Warning<
-  "double precision constant requires cl_khr_fp64, casting to single precision">;
+  "double precision constant requires %select{cl_khr_fp64|__opencl_c_fp64}0, "
+  "casting to single precision">;
 def err_half_const_requires_fp16 : Error<
   "half precision constant requires cl_khr_fp16">;
 
diff --git a/clang/include/clang/Basic/OpenCLOptions.h b/clang/include/clang/Basic/OpenCLOptions.h
--- a/clang/include/clang/Basic/OpenCLOptions.h
+++ b/clang/include/clang/Basic/OpenCLOptions.h
@@ -119,6 +119,8 @@
 
   bool isWithPragma(llvm::StringRef Ext) const;
 
+  bool isFP64Enabled(const LangOptions &LO) const;
+
   // Is supported as either an extension or an (optional) core feature for
   // OpenCL version \p LO.
   bool isSupported(llvm::StringRef Ext, const LangOptions &LO) const;
diff --git a/clang/lib/Basic/OpenCLOptions.cpp b/clang/lib/Basic/OpenCLOptions.cpp
--- a/clang/lib/Basic/OpenCLOptions.cpp
+++ b/clang/lib/Basic/OpenCLOptions.cpp
@@ -36,6 +36,12 @@
   return E != OptMap.end() && E->second.WithPragma;
 }
 
+bool OpenCLOptions::isFP64Enabled(const LangOptions &LO) const {
+  auto CLVer = LO.OpenCLCPlusPlus ? 200 : LO.OpenCLVersion;
+  return CLVer >= 300 ? isAvailableOption("__opencl_c_fp64", LO)
+                      : isAvailableOption("cl_khr_fp64", LO);
+}
+
 bool OpenCLOptions::isSupported(llvm::StringRef Ext,
                                 const LangOptions &LO) const {
   auto I = OptMap.find(Ext);
diff --git a/clang/lib/Basic/TargetInfo.cpp b/clang/lib/Basic/TargetInfo.cpp
--- a/clang/lib/Basic/TargetInfo.cpp
+++ b/clang/lib/Basic/TargetInfo.cpp
@@ -394,6 +394,14 @@
     HalfFormat = &llvm::APFloat::IEEEhalf();
     FloatFormat = &llvm::APFloat::IEEEsingle();
     LongDoubleFormat = &llvm::APFloat::IEEEquad();
+
+    // Set extensions simultaneosly with correspoding features
+    // for OpenCL C 3.0 and higher
+    auto CLVer = Opts.OpenCLCPlusPlus ? 200 : Opts.OpenCLVersion;
+    if (CLVer >= 300) {
+      auto &OCLOpts = getSupportedOpenCLOpts();
+      OCLOpts["cl_khr_fp64"] = OCLOpts["__opencl_c_fp64"];
+    }
   }
 
   if (Opts.DoubleSize) {
diff --git a/clang/lib/Basic/Targets/AMDGPU.h b/clang/lib/Basic/Targets/AMDGPU.h
--- a/clang/lib/Basic/Targets/AMDGPU.h
+++ b/clang/lib/Basic/Targets/AMDGPU.h
@@ -291,6 +291,7 @@
     bool IsAMDGCN = isAMDGCN(getTriple());
 
     Opts["cl_khr_fp64"] = hasFP64();
+    Opts["__opencl_c_fp64"] = hasFP64();
 
     if (IsAMDGCN || GPUKind >= llvm::AMDGPU::GK_CEDAR) {
       Opts["cl_khr_byte_addressable_store"] = true;
diff --git a/clang/lib/Basic/Targets/NVPTX.h b/clang/lib/Basic/Targets/NVPTX.h
--- a/clang/lib/Basic/Targets/NVPTX.h
+++ b/clang/lib/Basic/Targets/NVPTX.h
@@ -132,6 +132,7 @@
     Opts["__cl_clang_variadic_functions"] = true;
 
     Opts["cl_khr_fp64"] = true;
+    Opts["__opencl_c_fp64"] = true;
     Opts["cl_khr_byte_addressable_store"] = true;
     Opts["cl_khr_global_int32_base_atomics"] = true;
     Opts["cl_khr_global_int32_extended_atomics"] = true;
diff --git a/clang/lib/Headers/opencl-c-base.h b/clang/lib/Headers/opencl-c-base.h
--- a/clang/lib/Headers/opencl-c-base.h
+++ b/clang/lib/Headers/opencl-c-base.h
@@ -145,7 +145,7 @@
 typedef half half8 __attribute__((ext_vector_type(8)));
 typedef half half16 __attribute__((ext_vector_type(16)));
 #endif
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #if __OPENCL_C_VERSION__ < CL_VERSION_1_2
 #pragma OPENCL EXTENSION cl_khr_fp64 : enable
 #endif
@@ -527,14 +527,14 @@
 #define as_float8(x) __builtin_astype((x), float8)
 #define as_float16(x) __builtin_astype((x), float16)
 
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #define as_double(x) __builtin_astype((x), double)
 #define as_double2(x) __builtin_astype((x), double2)
 #define as_double3(x) __builtin_astype((x), double3)
 #define as_double4(x) __builtin_astype((x), double4)
 #define as_double8(x) __builtin_astype((x), double8)
 #define as_double16(x) __builtin_astype((x), double16)
-#endif // cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #ifdef cl_khr_fp16
 #define as_half(x) __builtin_astype((x), half)
diff --git a/clang/lib/Headers/opencl-c.h b/clang/lib/Headers/opencl-c.h
--- a/clang/lib/Headers/opencl-c.h
+++ b/clang/lib/Headers/opencl-c.h
@@ -4632,7 +4632,7 @@
 
 // Conversions with double data type parameters or return value.
 
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #pragma OPENCL EXTENSION cl_khr_fp64 : enable
 char __ovld __cnfn convert_char(double);
 char __ovld __cnfn convert_char_rte(double);
@@ -5453,7 +5453,7 @@
 double16 __ovld __cnfn convert_double16_rtz(uint16);
 double16 __ovld __cnfn convert_double16_rtz(ulong16);
 double16 __ovld __cnfn convert_double16_rtz(ushort16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #ifdef cl_khr_fp16
 #pragma OPENCL EXTENSION cl_khr_fp16 : enable
@@ -6272,7 +6272,7 @@
 half16 __ovld __cnfn convert_half16_rtz(half16);
 
 // Convert half types to double types.
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn convert_double(half);
 double __ovld __cnfn convert_double_rte(half);
 double __ovld __cnfn convert_double_rtp(half);
@@ -6335,7 +6335,7 @@
 half16 __ovld __cnfn convert_half16_rtp(double16);
 half16 __ovld __cnfn convert_half16_rtn(double16);
 half16 __ovld __cnfn convert_half16_rtz(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #endif // cl_khr_fp16
 
@@ -6441,14 +6441,14 @@
 float4 __ovld __cnfn acos(float4);
 float8 __ovld __cnfn acos(float8);
 float16 __ovld __cnfn acos(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn acos(double);
 double2 __ovld __cnfn acos(double2);
 double3 __ovld __cnfn acos(double3);
 double4 __ovld __cnfn acos(double4);
 double8 __ovld __cnfn acos(double8);
 double16 __ovld __cnfn acos(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn acos(half);
 half2 __ovld __cnfn acos(half2);
@@ -6467,14 +6467,14 @@
 float4 __ovld __cnfn acosh(float4);
 float8 __ovld __cnfn acosh(float8);
 float16 __ovld __cnfn acosh(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn acosh(double);
 double2 __ovld __cnfn acosh(double2);
 double3 __ovld __cnfn acosh(double3);
 double4 __ovld __cnfn acosh(double4);
 double8 __ovld __cnfn acosh(double8);
 double16 __ovld __cnfn acosh(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn acosh(half);
 half2 __ovld __cnfn acosh(half2);
@@ -6493,14 +6493,14 @@
 float4 __ovld __cnfn acospi(float4 x);
 float8 __ovld __cnfn acospi(float8 x);
 float16 __ovld __cnfn acospi(float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn acospi(double x);
 double2 __ovld __cnfn acospi(double2 x);
 double3 __ovld __cnfn acospi(double3 x);
 double4 __ovld __cnfn acospi(double4 x);
 double8 __ovld __cnfn acospi(double8 x);
 double16 __ovld __cnfn acospi(double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn acospi(half x);
 half2 __ovld __cnfn acospi(half2 x);
@@ -6519,14 +6519,14 @@
 float4 __ovld __cnfn asin(float4);
 float8 __ovld __cnfn asin(float8);
 float16 __ovld __cnfn asin(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn asin(double);
 double2 __ovld __cnfn asin(double2);
 double3 __ovld __cnfn asin(double3);
 double4 __ovld __cnfn asin(double4);
 double8 __ovld __cnfn asin(double8);
 double16 __ovld __cnfn asin(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn asin(half);
 half2 __ovld __cnfn asin(half2);
@@ -6545,14 +6545,14 @@
 float4 __ovld __cnfn asinh(float4);
 float8 __ovld __cnfn asinh(float8);
 float16 __ovld __cnfn asinh(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn asinh(double);
 double2 __ovld __cnfn asinh(double2);
 double3 __ovld __cnfn asinh(double3);
 double4 __ovld __cnfn asinh(double4);
 double8 __ovld __cnfn asinh(double8);
 double16 __ovld __cnfn asinh(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn asinh(half);
 half2 __ovld __cnfn asinh(half2);
@@ -6571,14 +6571,14 @@
 float4 __ovld __cnfn asinpi(float4 x);
 float8 __ovld __cnfn asinpi(float8 x);
 float16 __ovld __cnfn asinpi(float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn asinpi(double x);
 double2 __ovld __cnfn asinpi(double2 x);
 double3 __ovld __cnfn asinpi(double3 x);
 double4 __ovld __cnfn asinpi(double4 x);
 double8 __ovld __cnfn asinpi(double8 x);
 double16 __ovld __cnfn asinpi(double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn asinpi(half x);
 half2 __ovld __cnfn asinpi(half2 x);
@@ -6597,14 +6597,14 @@
 float4 __ovld __cnfn atan(float4 y_over_x);
 float8 __ovld __cnfn atan(float8 y_over_x);
 float16 __ovld __cnfn atan(float16 y_over_x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn atan(double y_over_x);
 double2 __ovld __cnfn atan(double2 y_over_x);
 double3 __ovld __cnfn atan(double3 y_over_x);
 double4 __ovld __cnfn atan(double4 y_over_x);
 double8 __ovld __cnfn atan(double8 y_over_x);
 double16 __ovld __cnfn atan(double16 y_over_x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn atan(half y_over_x);
 half2 __ovld __cnfn atan(half2 y_over_x);
@@ -6623,14 +6623,14 @@
 float4 __ovld __cnfn atan2(float4 y, float4 x);
 float8 __ovld __cnfn atan2(float8 y, float8 x);
 float16 __ovld __cnfn atan2(float16 y, float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn atan2(double y, double x);
 double2 __ovld __cnfn atan2(double2 y, double2 x);
 double3 __ovld __cnfn atan2(double3 y, double3 x);
 double4 __ovld __cnfn atan2(double4 y, double4 x);
 double8 __ovld __cnfn atan2(double8 y, double8 x);
 double16 __ovld __cnfn atan2(double16 y, double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn atan2(half y, half x);
 half2 __ovld __cnfn atan2(half2 y, half2 x);
@@ -6649,14 +6649,14 @@
 float4 __ovld __cnfn atanh(float4);
 float8 __ovld __cnfn atanh(float8);
 float16 __ovld __cnfn atanh(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn atanh(double);
 double2 __ovld __cnfn atanh(double2);
 double3 __ovld __cnfn atanh(double3);
 double4 __ovld __cnfn atanh(double4);
 double8 __ovld __cnfn atanh(double8);
 double16 __ovld __cnfn atanh(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn atanh(half);
 half2 __ovld __cnfn atanh(half2);
@@ -6675,14 +6675,14 @@
 float4 __ovld __cnfn atanpi(float4 x);
 float8 __ovld __cnfn atanpi(float8 x);
 float16 __ovld __cnfn atanpi(float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn atanpi(double x);
 double2 __ovld __cnfn atanpi(double2 x);
 double3 __ovld __cnfn atanpi(double3 x);
 double4 __ovld __cnfn atanpi(double4 x);
 double8 __ovld __cnfn atanpi(double8 x);
 double16 __ovld __cnfn atanpi(double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn atanpi(half x);
 half2 __ovld __cnfn atanpi(half2 x);
@@ -6701,14 +6701,14 @@
 float4 __ovld __cnfn atan2pi(float4 y, float4 x);
 float8 __ovld __cnfn atan2pi(float8 y, float8 x);
 float16 __ovld __cnfn atan2pi(float16 y, float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn atan2pi(double y, double x);
 double2 __ovld __cnfn atan2pi(double2 y, double2 x);
 double3 __ovld __cnfn atan2pi(double3 y, double3 x);
 double4 __ovld __cnfn atan2pi(double4 y, double4 x);
 double8 __ovld __cnfn atan2pi(double8 y, double8 x);
 double16 __ovld __cnfn atan2pi(double16 y, double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn atan2pi(half y, half x);
 half2 __ovld __cnfn atan2pi(half2 y, half2 x);
@@ -6727,14 +6727,14 @@
 float4 __ovld __cnfn cbrt(float4);
 float8 __ovld __cnfn cbrt(float8);
 float16 __ovld __cnfn cbrt(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn cbrt(double);
 double2 __ovld __cnfn cbrt(double2);
 double3 __ovld __cnfn cbrt(double3);
 double4 __ovld __cnfn cbrt(double4);
 double8 __ovld __cnfn cbrt(double8);
 double16 __ovld __cnfn cbrt(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn cbrt(half);
 half2 __ovld __cnfn cbrt(half2);
@@ -6754,14 +6754,14 @@
 float4 __ovld __cnfn ceil(float4);
 float8 __ovld __cnfn ceil(float8);
 float16 __ovld __cnfn ceil(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn ceil(double);
 double2 __ovld __cnfn ceil(double2);
 double3 __ovld __cnfn ceil(double3);
 double4 __ovld __cnfn ceil(double4);
 double8 __ovld __cnfn ceil(double8);
 double16 __ovld __cnfn ceil(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn ceil(half);
 half2 __ovld __cnfn ceil(half2);
@@ -6780,14 +6780,14 @@
 float4 __ovld __cnfn copysign(float4 x, float4 y);
 float8 __ovld __cnfn copysign(float8 x, float8 y);
 float16 __ovld __cnfn copysign(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn copysign(double x, double y);
 double2 __ovld __cnfn copysign(double2 x, double2 y);
 double3 __ovld __cnfn copysign(double3 x, double3 y);
 double4 __ovld __cnfn copysign(double4 x, double4 y);
 double8 __ovld __cnfn copysign(double8 x, double8 y);
 double16 __ovld __cnfn copysign(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn copysign(half x, half y);
 half2 __ovld __cnfn copysign(half2 x, half2 y);
@@ -6806,14 +6806,14 @@
 float4 __ovld __cnfn cos(float4);
 float8 __ovld __cnfn cos(float8);
 float16 __ovld __cnfn cos(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn cos(double);
 double2 __ovld __cnfn cos(double2);
 double3 __ovld __cnfn cos(double3);
 double4 __ovld __cnfn cos(double4);
 double8 __ovld __cnfn cos(double8);
 double16 __ovld __cnfn cos(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn cos(half);
 half2 __ovld __cnfn cos(half2);
@@ -6832,14 +6832,14 @@
 float4 __ovld __cnfn cosh(float4);
 float8 __ovld __cnfn cosh(float8);
 float16 __ovld __cnfn cosh(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn cosh(double);
 double2 __ovld __cnfn cosh(double2);
 double3 __ovld __cnfn cosh(double3);
 double4 __ovld __cnfn cosh(double4);
 double8 __ovld __cnfn cosh(double8);
 double16 __ovld __cnfn cosh(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn cosh(half);
 half2 __ovld __cnfn cosh(half2);
@@ -6858,14 +6858,14 @@
 float4 __ovld __cnfn cospi(float4 x);
 float8 __ovld __cnfn cospi(float8 x);
 float16 __ovld __cnfn cospi(float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn cospi(double x);
 double2 __ovld __cnfn cospi(double2 x);
 double3 __ovld __cnfn cospi(double3 x);
 double4 __ovld __cnfn cospi(double4 x);
 double8 __ovld __cnfn cospi(double8 x);
 double16 __ovld __cnfn cospi(double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn cospi(half x);
 half2 __ovld __cnfn cospi(half2 x);
@@ -6884,14 +6884,14 @@
 float4 __ovld __cnfn erfc(float4);
 float8 __ovld __cnfn erfc(float8);
 float16 __ovld __cnfn erfc(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn erfc(double);
 double2 __ovld __cnfn erfc(double2);
 double3 __ovld __cnfn erfc(double3);
 double4 __ovld __cnfn erfc(double4);
 double8 __ovld __cnfn erfc(double8);
 double16 __ovld __cnfn erfc(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn erfc(half);
 half2 __ovld __cnfn erfc(half2);
@@ -6911,14 +6911,14 @@
 float4 __ovld __cnfn erf(float4);
 float8 __ovld __cnfn erf(float8);
 float16 __ovld __cnfn erf(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn erf(double);
 double2 __ovld __cnfn erf(double2);
 double3 __ovld __cnfn erf(double3);
 double4 __ovld __cnfn erf(double4);
 double8 __ovld __cnfn erf(double8);
 double16 __ovld __cnfn erf(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn erf(half);
 half2 __ovld __cnfn erf(half2);
@@ -6937,14 +6937,14 @@
 float4 __ovld __cnfn exp(float4 x);
 float8 __ovld __cnfn exp(float8 x);
 float16 __ovld __cnfn exp(float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn exp(double x);
 double2 __ovld __cnfn exp(double2 x);
 double3 __ovld __cnfn exp(double3 x);
 double4 __ovld __cnfn exp(double4 x);
 double8 __ovld __cnfn exp(double8 x);
 double16 __ovld __cnfn exp(double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn exp(half x);
 half2 __ovld __cnfn exp(half2 x);
@@ -6963,14 +6963,14 @@
 float4 __ovld __cnfn exp2(float4);
 float8 __ovld __cnfn exp2(float8);
 float16 __ovld __cnfn exp2(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn exp2(double);
 double2 __ovld __cnfn exp2(double2);
 double3 __ovld __cnfn exp2(double3);
 double4 __ovld __cnfn exp2(double4);
 double8 __ovld __cnfn exp2(double8);
 double16 __ovld __cnfn exp2(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn exp2(half);
 half2 __ovld __cnfn exp2(half2);
@@ -6989,14 +6989,14 @@
 float4 __ovld __cnfn exp10(float4);
 float8 __ovld __cnfn exp10(float8);
 float16 __ovld __cnfn exp10(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn exp10(double);
 double2 __ovld __cnfn exp10(double2);
 double3 __ovld __cnfn exp10(double3);
 double4 __ovld __cnfn exp10(double4);
 double8 __ovld __cnfn exp10(double8);
 double16 __ovld __cnfn exp10(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn exp10(half);
 half2 __ovld __cnfn exp10(half2);
@@ -7015,14 +7015,14 @@
 float4 __ovld __cnfn expm1(float4 x);
 float8 __ovld __cnfn expm1(float8 x);
 float16 __ovld __cnfn expm1(float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn expm1(double x);
 double2 __ovld __cnfn expm1(double2 x);
 double3 __ovld __cnfn expm1(double3 x);
 double4 __ovld __cnfn expm1(double4 x);
 double8 __ovld __cnfn expm1(double8 x);
 double16 __ovld __cnfn expm1(double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn expm1(half x);
 half2 __ovld __cnfn expm1(half2 x);
@@ -7041,14 +7041,14 @@
 float4 __ovld __cnfn fabs(float4);
 float8 __ovld __cnfn fabs(float8);
 float16 __ovld __cnfn fabs(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn fabs(double);
 double2 __ovld __cnfn fabs(double2);
 double3 __ovld __cnfn fabs(double3);
 double4 __ovld __cnfn fabs(double4);
 double8 __ovld __cnfn fabs(double8);
 double16 __ovld __cnfn fabs(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn fabs(half);
 half2 __ovld __cnfn fabs(half2);
@@ -7067,14 +7067,14 @@
 float4 __ovld __cnfn fdim(float4 x, float4 y);
 float8 __ovld __cnfn fdim(float8 x, float8 y);
 float16 __ovld __cnfn fdim(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn fdim(double x, double y);
 double2 __ovld __cnfn fdim(double2 x, double2 y);
 double3 __ovld __cnfn fdim(double3 x, double3 y);
 double4 __ovld __cnfn fdim(double4 x, double4 y);
 double8 __ovld __cnfn fdim(double8 x, double8 y);
 double16 __ovld __cnfn fdim(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn fdim(half x, half y);
 half2 __ovld __cnfn fdim(half2 x, half2 y);
@@ -7094,14 +7094,14 @@
 float4 __ovld __cnfn floor(float4);
 float8 __ovld __cnfn floor(float8);
 float16 __ovld __cnfn floor(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn floor(double);
 double2 __ovld __cnfn floor(double2);
 double3 __ovld __cnfn floor(double3);
 double4 __ovld __cnfn floor(double4);
 double8 __ovld __cnfn floor(double8);
 double16 __ovld __cnfn floor(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn floor(half);
 half2 __ovld __cnfn floor(half2);
@@ -7124,14 +7124,14 @@
 float4 __ovld __cnfn fma(float4 a, float4 b, float4 c);
 float8 __ovld __cnfn fma(float8 a, float8 b, float8 c);
 float16 __ovld __cnfn fma(float16 a, float16 b, float16 c);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn fma(double a, double b, double c);
 double2 __ovld __cnfn fma(double2 a, double2 b, double2 c);
 double3 __ovld __cnfn fma(double3 a, double3 b, double3 c);
 double4 __ovld __cnfn fma(double4 a, double4 b, double4 c);
 double8 __ovld __cnfn fma(double8 a, double8 b, double8 c);
 double16 __ovld __cnfn fma(double16 a, double16 b, double16 c);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn fma(half a, half b, half c);
 half2 __ovld __cnfn fma(half2 a, half2 b, half2 c);
@@ -7158,7 +7158,7 @@
 float4 __ovld __cnfn fmax(float4 x, float y);
 float8 __ovld __cnfn fmax(float8 x, float y);
 float16 __ovld __cnfn fmax(float16 x, float y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn fmax(double x, double y);
 double2 __ovld __cnfn fmax(double2 x, double2 y);
 double3 __ovld __cnfn fmax(double3 x, double3 y);
@@ -7170,7 +7170,7 @@
 double4 __ovld __cnfn fmax(double4 x, double y);
 double8 __ovld __cnfn fmax(double8 x, double y);
 double16 __ovld __cnfn fmax(double16 x, double y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn fmax(half x, half y);
 half2 __ovld __cnfn fmax(half2 x, half2 y);
@@ -7202,7 +7202,7 @@
 float4 __ovld __cnfn fmin(float4 x, float y);
 float8 __ovld __cnfn fmin(float8 x, float y);
 float16 __ovld __cnfn fmin(float16 x, float y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn fmin(double x, double y);
 double2 __ovld __cnfn fmin(double2 x, double2 y);
 double3 __ovld __cnfn fmin(double3 x, double3 y);
@@ -7214,7 +7214,7 @@
 double4 __ovld __cnfn fmin(double4 x, double y);
 double8 __ovld __cnfn fmin(double8 x, double y);
 double16 __ovld __cnfn fmin(double16 x, double y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn fmin(half x, half y);
 half2 __ovld __cnfn fmin(half2 x, half2 y);
@@ -7238,14 +7238,14 @@
 float4 __ovld __cnfn fmod(float4 x, float4 y);
 float8 __ovld __cnfn fmod(float8 x, float8 y);
 float16 __ovld __cnfn fmod(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn fmod(double x, double y);
 double2 __ovld __cnfn fmod(double2 x, double2 y);
 double3 __ovld __cnfn fmod(double3 x, double3 y);
 double4 __ovld __cnfn fmod(double4 x, double4 y);
 double8 __ovld __cnfn fmod(double8 x, double8 y);
 double16 __ovld __cnfn fmod(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn fmod(half x, half y);
 half2 __ovld __cnfn fmod(half2 x, half2 y);
@@ -7266,14 +7266,14 @@
 float4 __ovld fract(float4 x, float4 *iptr);
 float8 __ovld fract(float8 x, float8 *iptr);
 float16 __ovld fract(float16 x, float16 *iptr);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld fract(double x, double *iptr);
 double2 __ovld fract(double2 x, double2 *iptr);
 double3 __ovld fract(double3 x, double3 *iptr);
 double4 __ovld fract(double4 x, double4 *iptr);
 double8 __ovld fract(double8 x, double8 *iptr);
 double16 __ovld fract(double16 x, double16 *iptr);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld fract(half x, half *iptr);
 half2 __ovld fract(half2 x, half2 *iptr);
@@ -7301,7 +7301,7 @@
 float4 __ovld fract(float4 x, __private float4 *iptr);
 float8 __ovld fract(float8 x, __private float8 *iptr);
 float16 __ovld fract(float16 x, __private float16 *iptr);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld fract(double x, __global double *iptr);
 double2 __ovld fract(double2 x, __global double2 *iptr);
 double3 __ovld fract(double3 x, __global double3 *iptr);
@@ -7320,7 +7320,7 @@
 double4 __ovld fract(double4 x, __private double4 *iptr);
 double8 __ovld fract(double8 x, __private double8 *iptr);
 double16 __ovld fract(double16 x, __private double16 *iptr);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld fract(half x, __global half *iptr);
 half2 __ovld fract(half2 x, __global half2 *iptr);
@@ -7356,14 +7356,14 @@
 float4 __ovld frexp(float4 x, int4 *exp);
 float8 __ovld frexp(float8 x, int8 *exp);
 float16 __ovld frexp(float16 x, int16 *exp);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld frexp(double x, int *exp);
 double2 __ovld frexp(double2 x, int2 *exp);
 double3 __ovld frexp(double3 x, int3 *exp);
 double4 __ovld frexp(double4 x, int4 *exp);
 double8 __ovld frexp(double8 x, int8 *exp);
 double16 __ovld frexp(double16 x, int16 *exp);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld frexp(half x, int *exp);
 half2 __ovld frexp(half2 x, int2 *exp);
@@ -7391,7 +7391,7 @@
 float4 __ovld frexp(float4 x, __private int4 *exp);
 float8 __ovld frexp(float8 x, __private int8 *exp);
 float16 __ovld frexp(float16 x, __private int16 *exp);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld frexp(double x, __global int *exp);
 double2 __ovld frexp(double2 x, __global int2 *exp);
 double3 __ovld frexp(double3 x, __global int3 *exp);
@@ -7410,7 +7410,7 @@
 double4 __ovld frexp(double4 x, __private int4 *exp);
 double8 __ovld frexp(double8 x, __private int8 *exp);
 double16 __ovld frexp(double16 x, __private int16 *exp);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld frexp(half x, __global int *exp);
 half2 __ovld frexp(half2 x, __global int2 *exp);
@@ -7443,14 +7443,14 @@
 float4 __ovld __cnfn hypot(float4 x, float4 y);
 float8 __ovld __cnfn hypot(float8 x, float8 y);
 float16 __ovld __cnfn hypot(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn hypot(double x, double y);
 double2 __ovld __cnfn hypot(double2 x, double2 y);
 double3 __ovld __cnfn hypot(double3 x, double3 y);
 double4 __ovld __cnfn hypot(double4 x, double4 y);
 double8 __ovld __cnfn hypot(double8 x, double8 y);
 double16 __ovld __cnfn hypot(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn hypot(half x, half y);
 half2 __ovld __cnfn hypot(half2 x, half2 y);
@@ -7469,14 +7469,14 @@
 int4 __ovld __cnfn ilogb(float4 x);
 int8 __ovld __cnfn ilogb(float8 x);
 int16 __ovld __cnfn ilogb(float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 int __ovld __cnfn ilogb(double x);
 int2 __ovld __cnfn ilogb(double2 x);
 int3 __ovld __cnfn ilogb(double3 x);
 int4 __ovld __cnfn ilogb(double4 x);
 int8 __ovld __cnfn ilogb(double8 x);
 int16 __ovld __cnfn ilogb(double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 int __ovld __cnfn ilogb(half x);
 int2 __ovld __cnfn ilogb(half2 x);
@@ -7500,7 +7500,7 @@
 float4 __ovld __cnfn ldexp(float4 x, int n);
 float8 __ovld __cnfn ldexp(float8 x, int n);
 float16 __ovld __cnfn ldexp(float16 x, int n);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn ldexp(double x, int n);
 double2 __ovld __cnfn ldexp(double2 x, int2 n);
 double3 __ovld __cnfn ldexp(double3 x, int3 n);
@@ -7512,7 +7512,7 @@
 double4 __ovld __cnfn ldexp(double4 x, int n);
 double8 __ovld __cnfn ldexp(double8 x, int n);
 double16 __ovld __cnfn ldexp(double16 x, int n);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn ldexp(half x, int n);
 half2 __ovld __cnfn ldexp(half2 x, int2 n);
@@ -7539,14 +7539,14 @@
 float4 __ovld __cnfn lgamma(float4 x);
 float8 __ovld __cnfn lgamma(float8 x);
 float16 __ovld __cnfn lgamma(float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn lgamma(double x);
 double2 __ovld __cnfn lgamma(double2 x);
 double3 __ovld __cnfn lgamma(double3 x);
 double4 __ovld __cnfn lgamma(double4 x);
 double8 __ovld __cnfn lgamma(double8 x);
 double16 __ovld __cnfn lgamma(double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn lgamma(half x);
 half2 __ovld __cnfn lgamma(half2 x);
@@ -7563,14 +7563,14 @@
 float4 __ovld lgamma_r(float4 x, int4 *signp);
 float8 __ovld lgamma_r(float8 x, int8 *signp);
 float16 __ovld lgamma_r(float16 x, int16 *signp);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld lgamma_r(double x, int *signp);
 double2 __ovld lgamma_r(double2 x, int2 *signp);
 double3 __ovld lgamma_r(double3 x, int3 *signp);
 double4 __ovld lgamma_r(double4 x, int4 *signp);
 double8 __ovld lgamma_r(double8 x, int8 *signp);
 double16 __ovld lgamma_r(double16 x, int16 *signp);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld lgamma_r(half x, int *signp);
 half2 __ovld lgamma_r(half2 x, int2 *signp);
@@ -7598,7 +7598,7 @@
 float4 __ovld lgamma_r(float4 x, __private int4 *signp);
 float8 __ovld lgamma_r(float8 x, __private int8 *signp);
 float16 __ovld lgamma_r(float16 x, __private int16 *signp);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld lgamma_r(double x, __global int *signp);
 double2 __ovld lgamma_r(double2 x, __global int2 *signp);
 double3 __ovld lgamma_r(double3 x, __global int3 *signp);
@@ -7617,7 +7617,7 @@
 double4 __ovld lgamma_r(double4 x, __private int4 *signp);
 double8 __ovld lgamma_r(double8 x, __private int8 *signp);
 double16 __ovld lgamma_r(double16 x, __private int16 *signp);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld lgamma_r(half x, __global int *signp);
 half2 __ovld lgamma_r(half2 x, __global int2 *signp);
@@ -7649,14 +7649,14 @@
 float4 __ovld __cnfn log(float4);
 float8 __ovld __cnfn log(float8);
 float16 __ovld __cnfn log(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn log(double);
 double2 __ovld __cnfn log(double2);
 double3 __ovld __cnfn log(double3);
 double4 __ovld __cnfn log(double4);
 double8 __ovld __cnfn log(double8);
 double16 __ovld __cnfn log(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn log(half);
 half2 __ovld __cnfn log(half2);
@@ -7675,14 +7675,14 @@
 float4 __ovld __cnfn log2(float4);
 float8 __ovld __cnfn log2(float8);
 float16 __ovld __cnfn log2(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn log2(double);
 double2 __ovld __cnfn log2(double2);
 double3 __ovld __cnfn log2(double3);
 double4 __ovld __cnfn log2(double4);
 double8 __ovld __cnfn log2(double8);
 double16 __ovld __cnfn log2(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn log2(half);
 half2 __ovld __cnfn log2(half2);
@@ -7701,14 +7701,14 @@
 float4 __ovld __cnfn log10(float4);
 float8 __ovld __cnfn log10(float8);
 float16 __ovld __cnfn log10(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn log10(double);
 double2 __ovld __cnfn log10(double2);
 double3 __ovld __cnfn log10(double3);
 double4 __ovld __cnfn log10(double4);
 double8 __ovld __cnfn log10(double8);
 double16 __ovld __cnfn log10(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn log10(half);
 half2 __ovld __cnfn log10(half2);
@@ -7727,14 +7727,14 @@
 float4 __ovld __cnfn log1p(float4 x);
 float8 __ovld __cnfn log1p(float8 x);
 float16 __ovld __cnfn log1p(float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn log1p(double x);
 double2 __ovld __cnfn log1p(double2 x);
 double3 __ovld __cnfn log1p(double3 x);
 double4 __ovld __cnfn log1p(double4 x);
 double8 __ovld __cnfn log1p(double8 x);
 double16 __ovld __cnfn log1p(double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn log1p(half x);
 half2 __ovld __cnfn log1p(half2 x);
@@ -7754,14 +7754,14 @@
 float4 __ovld __cnfn logb(float4 x);
 float8 __ovld __cnfn logb(float8 x);
 float16 __ovld __cnfn logb(float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn logb(double x);
 double2 __ovld __cnfn logb(double2 x);
 double3 __ovld __cnfn logb(double3 x);
 double4 __ovld __cnfn logb(double4 x);
 double8 __ovld __cnfn logb(double8 x);
 double16 __ovld __cnfn logb(double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn logb(half x);
 half2 __ovld __cnfn logb(half2 x);
@@ -7784,14 +7784,14 @@
 float4 __ovld __cnfn mad(float4 a, float4 b, float4 c);
 float8 __ovld __cnfn mad(float8 a, float8 b, float8 c);
 float16 __ovld __cnfn mad(float16 a, float16 b, float16 c);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn mad(double a, double b, double c);
 double2 __ovld __cnfn mad(double2 a, double2 b, double2 c);
 double3 __ovld __cnfn mad(double3 a, double3 b, double3 c);
 double4 __ovld __cnfn mad(double4 a, double4 b, double4 c);
 double8 __ovld __cnfn mad(double8 a, double8 b, double8 c);
 double16 __ovld __cnfn mad(double16 a, double16 b, double16 c);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn mad(half a, half b, half c);
 half2 __ovld __cnfn mad(half2 a, half2 b, half2 c);
@@ -7811,14 +7811,14 @@
 float4 __ovld __cnfn maxmag(float4 x, float4 y);
 float8 __ovld __cnfn maxmag(float8 x, float8 y);
 float16 __ovld __cnfn maxmag(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn maxmag(double x, double y);
 double2 __ovld __cnfn maxmag(double2 x, double2 y);
 double3 __ovld __cnfn maxmag(double3 x, double3 y);
 double4 __ovld __cnfn maxmag(double4 x, double4 y);
 double8 __ovld __cnfn maxmag(double8 x, double8 y);
 double16 __ovld __cnfn maxmag(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn maxmag(half x, half y);
 half2 __ovld __cnfn maxmag(half2 x, half2 y);
@@ -7838,14 +7838,14 @@
 float4 __ovld __cnfn minmag(float4 x, float4 y);
 float8 __ovld __cnfn minmag(float8 x, float8 y);
 float16 __ovld __cnfn minmag(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn minmag(double x, double y);
 double2 __ovld __cnfn minmag(double2 x, double2 y);
 double3 __ovld __cnfn minmag(double3 x, double3 y);
 double4 __ovld __cnfn minmag(double4 x, double4 y);
 double8 __ovld __cnfn minmag(double8 x, double8 y);
 double16 __ovld __cnfn minmag(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn minmag(half x, half y);
 half2 __ovld __cnfn minmag(half2 x, half2 y);
@@ -7869,14 +7869,14 @@
 float4 __ovld modf(float4 x, float4 *iptr);
 float8 __ovld modf(float8 x, float8 *iptr);
 float16 __ovld modf(float16 x, float16 *iptr);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld modf(double x, double *iptr);
 double2 __ovld modf(double2 x, double2 *iptr);
 double3 __ovld modf(double3 x, double3 *iptr);
 double4 __ovld modf(double4 x, double4 *iptr);
 double8 __ovld modf(double8 x, double8 *iptr);
 double16 __ovld modf(double16 x, double16 *iptr);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld modf(half x, half *iptr);
 half2 __ovld modf(half2 x, half2 *iptr);
@@ -7904,7 +7904,7 @@
 float4 __ovld modf(float4 x, __private float4 *iptr);
 float8 __ovld modf(float8 x, __private float8 *iptr);
 float16 __ovld modf(float16 x, __private float16 *iptr);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld modf(double x, __global double *iptr);
 double2 __ovld modf(double2 x, __global double2 *iptr);
 double3 __ovld modf(double3 x, __global double3 *iptr);
@@ -7923,7 +7923,7 @@
 double4 __ovld modf(double4 x, __private double4 *iptr);
 double8 __ovld modf(double8 x, __private double8 *iptr);
 double16 __ovld modf(double16 x, __private double16 *iptr);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld modf(half x, __global half *iptr);
 half2 __ovld modf(half2 x, __global half2 *iptr);
@@ -7956,14 +7956,14 @@
 float4 __ovld __cnfn nan(uint4 nancode);
 float8 __ovld __cnfn nan(uint8 nancode);
 float16 __ovld __cnfn nan(uint16 nancode);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn nan(ulong nancode);
 double2 __ovld __cnfn nan(ulong2 nancode);
 double3 __ovld __cnfn nan(ulong3 nancode);
 double4 __ovld __cnfn nan(ulong4 nancode);
 double8 __ovld __cnfn nan(ulong8 nancode);
 double16 __ovld __cnfn nan(ulong16 nancode);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn nan(ushort nancode);
 half2 __ovld __cnfn nan(ushort2 nancode);
@@ -7986,14 +7986,14 @@
 float4 __ovld __cnfn nextafter(float4 x, float4 y);
 float8 __ovld __cnfn nextafter(float8 x, float8 y);
 float16 __ovld __cnfn nextafter(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn nextafter(double x, double y);
 double2 __ovld __cnfn nextafter(double2 x, double2 y);
 double3 __ovld __cnfn nextafter(double3 x, double3 y);
 double4 __ovld __cnfn nextafter(double4 x, double4 y);
 double8 __ovld __cnfn nextafter(double8 x, double8 y);
 double16 __ovld __cnfn nextafter(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn nextafter(half x, half y);
 half2 __ovld __cnfn nextafter(half2 x, half2 y);
@@ -8012,14 +8012,14 @@
 float4 __ovld __cnfn pow(float4 x, float4 y);
 float8 __ovld __cnfn pow(float8 x, float8 y);
 float16 __ovld __cnfn pow(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn pow(double x, double y);
 double2 __ovld __cnfn pow(double2 x, double2 y);
 double3 __ovld __cnfn pow(double3 x, double3 y);
 double4 __ovld __cnfn pow(double4 x, double4 y);
 double8 __ovld __cnfn pow(double8 x, double8 y);
 double16 __ovld __cnfn pow(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn pow(half x, half y);
 half2 __ovld __cnfn pow(half2 x, half2 y);
@@ -8038,14 +8038,14 @@
 float4 __ovld __cnfn pown(float4 x, int4 y);
 float8 __ovld __cnfn pown(float8 x, int8 y);
 float16 __ovld __cnfn pown(float16 x, int16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn pown(double x, int y);
 double2 __ovld __cnfn pown(double2 x, int2 y);
 double3 __ovld __cnfn pown(double3 x, int3 y);
 double4 __ovld __cnfn pown(double4 x, int4 y);
 double8 __ovld __cnfn pown(double8 x, int8 y);
 double16 __ovld __cnfn pown(double16 x, int16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn pown(half x, int y);
 half2 __ovld __cnfn pown(half2 x, int2 y);
@@ -8064,14 +8064,14 @@
 float4 __ovld __cnfn powr(float4 x, float4 y);
 float8 __ovld __cnfn powr(float8 x, float8 y);
 float16 __ovld __cnfn powr(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn powr(double x, double y);
 double2 __ovld __cnfn powr(double2 x, double2 y);
 double3 __ovld __cnfn powr(double3 x, double3 y);
 double4 __ovld __cnfn powr(double4 x, double4 y);
 double8 __ovld __cnfn powr(double8 x, double8 y);
 double16 __ovld __cnfn powr(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn powr(half x, half y);
 half2 __ovld __cnfn powr(half2 x, half2 y);
@@ -8093,14 +8093,14 @@
 float4 __ovld __cnfn remainder(float4 x, float4 y);
 float8 __ovld __cnfn remainder(float8 x, float8 y);
 float16 __ovld __cnfn remainder(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn remainder(double x, double y);
 double2 __ovld __cnfn remainder(double2 x, double2 y);
 double3 __ovld __cnfn remainder(double3 x, double3 y);
 double4 __ovld __cnfn remainder(double4 x, double4 y);
 double8 __ovld __cnfn remainder(double8 x, double8 y);
 double16 __ovld __cnfn remainder(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn remainder(half x, half y);
 half2 __ovld __cnfn remainder(half2 x, half2 y);
@@ -8129,14 +8129,14 @@
 float4 __ovld remquo(float4 x, float4 y, int4 *quo);
 float8 __ovld remquo(float8 x, float8 y, int8 *quo);
 float16 __ovld remquo(float16 x, float16 y, int16 *quo);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld remquo(double x, double y, int *quo);
 double2 __ovld remquo(double2 x, double2 y, int2 *quo);
 double3 __ovld remquo(double3 x, double3 y, int3 *quo);
 double4 __ovld remquo(double4 x, double4 y, int4 *quo);
 double8 __ovld remquo(double8 x, double8 y, int8 *quo);
 double16 __ovld remquo(double16 x, double16 y, int16 *quo);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld remquo(half x, half y, int *quo);
 half2 __ovld remquo(half2 x, half2 y, int2 *quo);
@@ -8165,7 +8165,7 @@
 float4 __ovld remquo(float4 x, float4 y, __private int4 *quo);
 float8 __ovld remquo(float8 x, float8 y, __private int8 *quo);
 float16 __ovld remquo(float16 x, float16 y, __private int16 *quo);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld remquo(double x, double y, __global int *quo);
 double2 __ovld remquo(double2 x, double2 y, __global int2 *quo);
 double3 __ovld remquo(double3 x, double3 y, __global int3 *quo);
@@ -8184,7 +8184,7 @@
 double4 __ovld remquo(double4 x, double4 y, __private int4 *quo);
 double8 __ovld remquo(double8 x, double8 y, __private int8 *quo);
 double16 __ovld remquo(double16 x, double16 y, __private int16 *quo);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld remquo(half x, half y, __global int *quo);
 half2 __ovld remquo(half2 x, half2 y, __global int2 *quo);
@@ -8218,14 +8218,14 @@
 float4 __ovld __cnfn rint(float4);
 float8 __ovld __cnfn rint(float8);
 float16 __ovld __cnfn rint(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn rint(double);
 double2 __ovld __cnfn rint(double2);
 double3 __ovld __cnfn rint(double3);
 double4 __ovld __cnfn rint(double4);
 double8 __ovld __cnfn rint(double8);
 double16 __ovld __cnfn rint(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn rint(half);
 half2 __ovld __cnfn rint(half2);
@@ -8244,14 +8244,14 @@
 float4 __ovld __cnfn rootn(float4 x, int4 y);
 float8 __ovld __cnfn rootn(float8 x, int8 y);
 float16 __ovld __cnfn rootn(float16 x, int16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn rootn(double x, int y);
 double2 __ovld __cnfn rootn(double2 x, int2 y);
 double3 __ovld __cnfn rootn(double3 x, int3 y);
 double4 __ovld __cnfn rootn(double4 x, int4 y);
 double8 __ovld __cnfn rootn(double8 x, int8 y);
 double16 __ovld __cnfn rootn(double16 x, int16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn rootn(half x, int y);
 half2 __ovld __cnfn rootn(half2 x, int2 y);
@@ -8272,14 +8272,14 @@
 float4 __ovld __cnfn round(float4 x);
 float8 __ovld __cnfn round(float8 x);
 float16 __ovld __cnfn round(float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn round(double x);
 double2 __ovld __cnfn round(double2 x);
 double3 __ovld __cnfn round(double3 x);
 double4 __ovld __cnfn round(double4 x);
 double8 __ovld __cnfn round(double8 x);
 double16 __ovld __cnfn round(double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn round(half x);
 half2 __ovld __cnfn round(half2 x);
@@ -8298,14 +8298,14 @@
 float4 __ovld __cnfn rsqrt(float4);
 float8 __ovld __cnfn rsqrt(float8);
 float16 __ovld __cnfn rsqrt(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn rsqrt(double);
 double2 __ovld __cnfn rsqrt(double2);
 double3 __ovld __cnfn rsqrt(double3);
 double4 __ovld __cnfn rsqrt(double4);
 double8 __ovld __cnfn rsqrt(double8);
 double16 __ovld __cnfn rsqrt(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn rsqrt(half);
 half2 __ovld __cnfn rsqrt(half2);
@@ -8324,14 +8324,14 @@
 float4 __ovld __cnfn sin(float4);
 float8 __ovld __cnfn sin(float8);
 float16 __ovld __cnfn sin(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn sin(double);
 double2 __ovld __cnfn sin(double2);
 double3 __ovld __cnfn sin(double3);
 double4 __ovld __cnfn sin(double4);
 double8 __ovld __cnfn sin(double8);
 double16 __ovld __cnfn sin(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn sin(half);
 half2 __ovld __cnfn sin(half2);
@@ -8353,14 +8353,14 @@
 float4 __ovld sincos(float4 x, float4 *cosval);
 float8 __ovld sincos(float8 x, float8 *cosval);
 float16 __ovld sincos(float16 x, float16 *cosval);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld sincos(double x, double *cosval);
 double2 __ovld sincos(double2 x, double2 *cosval);
 double3 __ovld sincos(double3 x, double3 *cosval);
 double4 __ovld sincos(double4 x, double4 *cosval);
 double8 __ovld sincos(double8 x, double8 *cosval);
 double16 __ovld sincos(double16 x, double16 *cosval);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld sincos(half x, half *cosval);
 half2 __ovld sincos(half2 x, half2 *cosval);
@@ -8388,7 +8388,7 @@
 float4 __ovld sincos(float4 x, __private float4 *cosval);
 float8 __ovld sincos(float8 x, __private float8 *cosval);
 float16 __ovld sincos(float16 x, __private float16 *cosval);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld sincos(double x, __global double *cosval);
 double2 __ovld sincos(double2 x, __global double2 *cosval);
 double3 __ovld sincos(double3 x, __global double3 *cosval);
@@ -8407,7 +8407,7 @@
 double4 __ovld sincos(double4 x, __private double4 *cosval);
 double8 __ovld sincos(double8 x, __private double8 *cosval);
 double16 __ovld sincos(double16 x, __private double16 *cosval);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld sincos(half x, __global half *cosval);
 half2 __ovld sincos(half2 x, __global half2 *cosval);
@@ -8439,14 +8439,14 @@
 float4 __ovld __cnfn sinh(float4);
 float8 __ovld __cnfn sinh(float8);
 float16 __ovld __cnfn sinh(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn sinh(double);
 double2 __ovld __cnfn sinh(double2);
 double3 __ovld __cnfn sinh(double3);
 double4 __ovld __cnfn sinh(double4);
 double8 __ovld __cnfn sinh(double8);
 double16 __ovld __cnfn sinh(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn sinh(half);
 half2 __ovld __cnfn sinh(half2);
@@ -8465,14 +8465,14 @@
 float4 __ovld __cnfn sinpi(float4 x);
 float8 __ovld __cnfn sinpi(float8 x);
 float16 __ovld __cnfn sinpi(float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn sinpi(double x);
 double2 __ovld __cnfn sinpi(double2 x);
 double3 __ovld __cnfn sinpi(double3 x);
 double4 __ovld __cnfn sinpi(double4 x);
 double8 __ovld __cnfn sinpi(double8 x);
 double16 __ovld __cnfn sinpi(double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn sinpi(half x);
 half2 __ovld __cnfn sinpi(half2 x);
@@ -8491,14 +8491,14 @@
 float4 __ovld __cnfn sqrt(float4);
 float8 __ovld __cnfn sqrt(float8);
 float16 __ovld __cnfn sqrt(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn sqrt(double);
 double2 __ovld __cnfn sqrt(double2);
 double3 __ovld __cnfn sqrt(double3);
 double4 __ovld __cnfn sqrt(double4);
 double8 __ovld __cnfn sqrt(double8);
 double16 __ovld __cnfn sqrt(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn sqrt(half);
 half2 __ovld __cnfn sqrt(half2);
@@ -8517,14 +8517,14 @@
 float4 __ovld __cnfn tan(float4);
 float8 __ovld __cnfn tan(float8);
 float16 __ovld __cnfn tan(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn tan(double);
 double2 __ovld __cnfn tan(double2);
 double3 __ovld __cnfn tan(double3);
 double4 __ovld __cnfn tan(double4);
 double8 __ovld __cnfn tan(double8);
 double16 __ovld __cnfn tan(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn tan(half);
 half2 __ovld __cnfn tan(half2);
@@ -8543,14 +8543,14 @@
 float4 __ovld __cnfn tanh(float4);
 float8 __ovld __cnfn tanh(float8);
 float16 __ovld __cnfn tanh(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn tanh(double);
 double2 __ovld __cnfn tanh(double2);
 double3 __ovld __cnfn tanh(double3);
 double4 __ovld __cnfn tanh(double4);
 double8 __ovld __cnfn tanh(double8);
 double16 __ovld __cnfn tanh(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn tanh(half);
 half2 __ovld __cnfn tanh(half2);
@@ -8569,14 +8569,14 @@
 float4 __ovld __cnfn tanpi(float4 x);
 float8 __ovld __cnfn tanpi(float8 x);
 float16 __ovld __cnfn tanpi(float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn tanpi(double x);
 double2 __ovld __cnfn tanpi(double2 x);
 double3 __ovld __cnfn tanpi(double3 x);
 double4 __ovld __cnfn tanpi(double4 x);
 double8 __ovld __cnfn tanpi(double8 x);
 double16 __ovld __cnfn tanpi(double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn tanpi(half x);
 half2 __ovld __cnfn tanpi(half2 x);
@@ -8595,14 +8595,14 @@
 float4 __ovld __cnfn tgamma(float4);
 float8 __ovld __cnfn tgamma(float8);
 float16 __ovld __cnfn tgamma(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn tgamma(double);
 double2 __ovld __cnfn tgamma(double2);
 double3 __ovld __cnfn tgamma(double3);
 double4 __ovld __cnfn tgamma(double4);
 double8 __ovld __cnfn tgamma(double8);
 double16 __ovld __cnfn tgamma(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn tgamma(half);
 half2 __ovld __cnfn tgamma(half2);
@@ -8622,14 +8622,14 @@
 float4 __ovld __cnfn trunc(float4);
 float8 __ovld __cnfn trunc(float8);
 float16 __ovld __cnfn trunc(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn trunc(double);
 double2 __ovld __cnfn trunc(double2);
 double3 __ovld __cnfn trunc(double3);
 double4 __ovld __cnfn trunc(double4);
 double8 __ovld __cnfn trunc(double8);
 double16 __ovld __cnfn trunc(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn trunc(half);
 half2 __ovld __cnfn trunc(half2);
@@ -10017,7 +10017,7 @@
 float4 __ovld __cnfn clamp(float4 x, float minval, float maxval);
 float8 __ovld __cnfn clamp(float8 x, float minval, float maxval);
 float16 __ovld __cnfn clamp(float16 x, float minval, float maxval);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn clamp(double x, double minval, double maxval);
 double2 __ovld __cnfn clamp(double2 x, double2 minval, double2 maxval);
 double3 __ovld __cnfn clamp(double3 x, double3 minval, double3 maxval);
@@ -10029,7 +10029,7 @@
 double4 __ovld __cnfn clamp(double4 x, double minval, double maxval);
 double8 __ovld __cnfn clamp(double8 x, double minval, double maxval);
 double16 __ovld __cnfn clamp(double16 x, double minval, double maxval);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn clamp(half x, half minval, half maxval);
 half2 __ovld __cnfn clamp(half2 x, half2 minval, half2 maxval);
@@ -10054,14 +10054,14 @@
 float4 __ovld __cnfn degrees(float4 radians);
 float8 __ovld __cnfn degrees(float8 radians);
 float16 __ovld __cnfn degrees(float16 radians);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn degrees(double radians);
 double2 __ovld __cnfn degrees(double2 radians);
 double3 __ovld __cnfn degrees(double3 radians);
 double4 __ovld __cnfn degrees(double4 radians);
 double8 __ovld __cnfn degrees(double8 radians);
 double16 __ovld __cnfn degrees(double16 radians);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn degrees(half radians);
 half2 __ovld __cnfn degrees(half2 radians);
@@ -10086,7 +10086,7 @@
 float4 __ovld __cnfn max(float4 x, float y);
 float8 __ovld __cnfn max(float8 x, float y);
 float16 __ovld __cnfn max(float16 x, float y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn max(double x, double y);
 double2 __ovld __cnfn max(double2 x, double2 y);
 double3 __ovld __cnfn max(double3 x, double3 y);
@@ -10098,7 +10098,7 @@
 double4 __ovld __cnfn max(double4 x, double y);
 double8 __ovld __cnfn max(double8 x, double y);
 double16 __ovld __cnfn max(double16 x, double y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn max(half x, half y);
 half2 __ovld __cnfn max(half2 x, half2 y);
@@ -10128,7 +10128,7 @@
 float4 __ovld __cnfn min(float4 x, float y);
 float8 __ovld __cnfn min(float8 x, float y);
 float16 __ovld __cnfn min(float16 x, float y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn min(double x, double y);
 double2 __ovld __cnfn min(double2 x, double2 y);
 double3 __ovld __cnfn min(double3 x, double3 y);
@@ -10140,7 +10140,7 @@
 double4 __ovld __cnfn min(double4 x, double y);
 double8 __ovld __cnfn min(double8 x, double y);
 double16 __ovld __cnfn min(double16 x, double y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn min(half x, half y);
 half2 __ovld __cnfn min(half2 x, half2 y);
@@ -10173,7 +10173,7 @@
 float4 __ovld __cnfn mix(float4 x, float4 y, float a);
 float8 __ovld __cnfn mix(float8 x, float8 y, float a);
 float16 __ovld __cnfn mix(float16 x, float16 y, float a);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn mix(double x, double y, double a);
 double2 __ovld __cnfn mix(double2 x, double2 y, double2 a);
 double3 __ovld __cnfn mix(double3 x, double3 y, double3 a);
@@ -10185,7 +10185,7 @@
 double4 __ovld __cnfn mix(double4 x, double4 y, double a);
 double8 __ovld __cnfn mix(double8 x, double8 y, double a);
 double16 __ovld __cnfn mix(double16 x, double16 y, double a);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn mix(half x, half y, half a);
 half2 __ovld __cnfn mix(half2 x, half2 y, half2 a);
@@ -10210,14 +10210,14 @@
 float4 __ovld __cnfn radians(float4 degrees);
 float8 __ovld __cnfn radians(float8 degrees);
 float16 __ovld __cnfn radians(float16 degrees);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn radians(double degrees);
 double2 __ovld __cnfn radians(double2 degrees);
 double3 __ovld __cnfn radians(double3 degrees);
 double4 __ovld __cnfn radians(double4 degrees);
 double8 __ovld __cnfn radians(double8 degrees);
 double16 __ovld __cnfn radians(double16 degrees);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn radians(half degrees);
 half2 __ovld __cnfn radians(half2 degrees);
@@ -10241,7 +10241,7 @@
 float4 __ovld __cnfn step(float edge, float4 x);
 float8 __ovld __cnfn step(float edge, float8 x);
 float16 __ovld __cnfn step(float edge, float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn step(double edge, double x);
 double2 __ovld __cnfn step(double2 edge, double2 x);
 double3 __ovld __cnfn step(double3 edge, double3 x);
@@ -10253,7 +10253,7 @@
 double4 __ovld __cnfn step(double edge, double4 x);
 double8 __ovld __cnfn step(double edge, double8 x);
 double16 __ovld __cnfn step(double edge, double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn step(half edge, half x);
 half2 __ovld __cnfn step(half2 edge, half2 x);
@@ -10292,7 +10292,7 @@
 float4 __ovld __cnfn smoothstep(float edge0, float edge1, float4 x);
 float8 __ovld __cnfn smoothstep(float edge0, float edge1, float8 x);
 float16 __ovld __cnfn smoothstep(float edge0, float edge1, float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn smoothstep(double edge0, double edge1, double x);
 double2 __ovld __cnfn smoothstep(double2 edge0, double2 edge1, double2 x);
 double3 __ovld __cnfn smoothstep(double3 edge0, double3 edge1, double3 x);
@@ -10304,7 +10304,7 @@
 double4 __ovld __cnfn smoothstep(double edge0, double edge1, double4 x);
 double8 __ovld __cnfn smoothstep(double edge0, double edge1, double8 x);
 double16 __ovld __cnfn smoothstep(double edge0, double edge1, double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn smoothstep(half edge0, half edge1, half x);
 half2 __ovld __cnfn smoothstep(half2 edge0, half2 edge1, half2 x);
@@ -10329,14 +10329,14 @@
 float4 __ovld __cnfn sign(float4 x);
 float8 __ovld __cnfn sign(float8 x);
 float16 __ovld __cnfn sign(float16 x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn sign(double x);
 double2 __ovld __cnfn sign(double2 x);
 double3 __ovld __cnfn sign(double3 x);
 double4 __ovld __cnfn sign(double4 x);
 double8 __ovld __cnfn sign(double8 x);
 double16 __ovld __cnfn sign(double16 x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn sign(half x);
 half2 __ovld __cnfn sign(half2 x);
@@ -10354,10 +10354,10 @@
  */
 float4 __ovld __cnfn cross(float4 p0, float4 p1);
 float3 __ovld __cnfn cross(float3 p0, float3 p1);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double4 __ovld __cnfn cross(double4 p0, double4 p1);
 double3 __ovld __cnfn cross(double3 p0, double3 p1);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half4 __ovld __cnfn cross(half4 p0, half4 p1);
 half3 __ovld __cnfn cross(half3 p0, half3 p1);
@@ -10370,12 +10370,12 @@
 float __ovld __cnfn dot(float2 p0, float2 p1);
 float __ovld __cnfn dot(float3 p0, float3 p1);
 float __ovld __cnfn dot(float4 p0, float4 p1);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn dot(double p0, double p1);
 double __ovld __cnfn dot(double2 p0, double2 p1);
 double __ovld __cnfn dot(double3 p0, double3 p1);
 double __ovld __cnfn dot(double4 p0, double4 p1);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn dot(half p0, half p1);
 half __ovld __cnfn dot(half2 p0, half2 p1);
@@ -10391,12 +10391,12 @@
 float __ovld __cnfn distance(float2 p0, float2 p1);
 float __ovld __cnfn distance(float3 p0, float3 p1);
 float __ovld __cnfn distance(float4 p0, float4 p1);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn distance(double p0, double p1);
 double __ovld __cnfn distance(double2 p0, double2 p1);
 double __ovld __cnfn distance(double3 p0, double3 p1);
 double __ovld __cnfn distance(double4 p0, double4 p1);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn distance(half p0, half p1);
 half __ovld __cnfn distance(half2 p0, half2 p1);
@@ -10412,12 +10412,12 @@
 float __ovld __cnfn length(float2 p);
 float __ovld __cnfn length(float3 p);
 float __ovld __cnfn length(float4 p);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn length(double p);
 double __ovld __cnfn length(double2 p);
 double __ovld __cnfn length(double3 p);
 double __ovld __cnfn length(double4 p);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn length(half p);
 half __ovld __cnfn length(half2 p);
@@ -10433,12 +10433,12 @@
 float2 __ovld __cnfn normalize(float2 p);
 float3 __ovld __cnfn normalize(float3 p);
 float4 __ovld __cnfn normalize(float4 p);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn normalize(double p);
 double2 __ovld __cnfn normalize(double2 p);
 double3 __ovld __cnfn normalize(double3 p);
 double4 __ovld __cnfn normalize(double4 p);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn normalize(half p);
 half2 __ovld __cnfn normalize(half2 p);
@@ -10519,14 +10519,14 @@
 int4 __ovld __cnfn isequal(float4 x, float4 y);
 int8 __ovld __cnfn isequal(float8 x, float8 y);
 int16 __ovld __cnfn isequal(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 int __ovld __cnfn isequal(double x, double y);
 long2 __ovld __cnfn isequal(double2 x, double2 y);
 long3 __ovld __cnfn isequal(double3 x, double3 y);
 long4 __ovld __cnfn isequal(double4 x, double4 y);
 long8 __ovld __cnfn isequal(double8 x, double8 y);
 long16 __ovld __cnfn isequal(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 int __ovld __cnfn isequal(half x, half y);
 short2 __ovld __cnfn isequal(half2 x, half2 y);
@@ -10545,14 +10545,14 @@
 int4 __ovld __cnfn isnotequal(float4 x, float4 y);
 int8 __ovld __cnfn isnotequal(float8 x, float8 y);
 int16 __ovld __cnfn isnotequal(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 int __ovld __cnfn isnotequal(double x, double y);
 long2 __ovld __cnfn isnotequal(double2 x, double2 y);
 long3 __ovld __cnfn isnotequal(double3 x, double3 y);
 long4 __ovld __cnfn isnotequal(double4 x, double4 y);
 long8 __ovld __cnfn isnotequal(double8 x, double8 y);
 long16 __ovld __cnfn isnotequal(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 int __ovld __cnfn isnotequal(half x, half y);
 short2 __ovld __cnfn isnotequal(half2 x, half2 y);
@@ -10571,14 +10571,14 @@
 int4 __ovld __cnfn isgreater(float4 x, float4 y);
 int8 __ovld __cnfn isgreater(float8 x, float8 y);
 int16 __ovld __cnfn isgreater(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 int __ovld __cnfn isgreater(double x, double y);
 long2 __ovld __cnfn isgreater(double2 x, double2 y);
 long3 __ovld __cnfn isgreater(double3 x, double3 y);
 long4 __ovld __cnfn isgreater(double4 x, double4 y);
 long8 __ovld __cnfn isgreater(double8 x, double8 y);
 long16 __ovld __cnfn isgreater(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 int __ovld __cnfn isgreater(half x, half y);
 short2 __ovld __cnfn isgreater(half2 x, half2 y);
@@ -10597,14 +10597,14 @@
 int4 __ovld __cnfn isgreaterequal(float4 x, float4 y);
 int8 __ovld __cnfn isgreaterequal(float8 x, float8 y);
 int16 __ovld __cnfn isgreaterequal(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 int __ovld __cnfn isgreaterequal(double x, double y);
 long2 __ovld __cnfn isgreaterequal(double2 x, double2 y);
 long3 __ovld __cnfn isgreaterequal(double3 x, double3 y);
 long4 __ovld __cnfn isgreaterequal(double4 x, double4 y);
 long8 __ovld __cnfn isgreaterequal(double8 x, double8 y);
 long16 __ovld __cnfn isgreaterequal(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 int __ovld __cnfn isgreaterequal(half x, half y);
 short2 __ovld __cnfn isgreaterequal(half2 x, half2 y);
@@ -10623,14 +10623,14 @@
 int4 __ovld __cnfn isless(float4 x, float4 y);
 int8 __ovld __cnfn isless(float8 x, float8 y);
 int16 __ovld __cnfn isless(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 int __ovld __cnfn isless(double x, double y);
 long2 __ovld __cnfn isless(double2 x, double2 y);
 long3 __ovld __cnfn isless(double3 x, double3 y);
 long4 __ovld __cnfn isless(double4 x, double4 y);
 long8 __ovld __cnfn isless(double8 x, double8 y);
 long16 __ovld __cnfn isless(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 int __ovld __cnfn isless(half x, half y);
 short2 __ovld __cnfn isless(half2 x, half2 y);
@@ -10649,14 +10649,14 @@
 int4 __ovld __cnfn islessequal(float4 x, float4 y);
 int8 __ovld __cnfn islessequal(float8 x, float8 y);
 int16 __ovld __cnfn islessequal(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 int __ovld __cnfn islessequal(double x, double y);
 long2 __ovld __cnfn islessequal(double2 x, double2 y);
 long3 __ovld __cnfn islessequal(double3 x, double3 y);
 long4 __ovld __cnfn islessequal(double4 x, double4 y);
 long8 __ovld __cnfn islessequal(double8 x, double8 y);
 long16 __ovld __cnfn islessequal(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 int __ovld __cnfn islessequal(half x, half y);
 short2 __ovld __cnfn islessequal(half2 x, half2 y);
@@ -10676,14 +10676,14 @@
 int4 __ovld __cnfn islessgreater(float4 x, float4 y);
 int8 __ovld __cnfn islessgreater(float8 x, float8 y);
 int16 __ovld __cnfn islessgreater(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 int __ovld __cnfn islessgreater(double x, double y);
 long2 __ovld __cnfn islessgreater(double2 x, double2 y);
 long3 __ovld __cnfn islessgreater(double3 x, double3 y);
 long4 __ovld __cnfn islessgreater(double4 x, double4 y);
 long8 __ovld __cnfn islessgreater(double8 x, double8 y);
 long16 __ovld __cnfn islessgreater(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 int __ovld __cnfn islessgreater(half x, half y);
 short2 __ovld __cnfn islessgreater(half2 x, half2 y);
@@ -10702,14 +10702,14 @@
 int4 __ovld __cnfn isfinite(float4);
 int8 __ovld __cnfn isfinite(float8);
 int16 __ovld __cnfn isfinite(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 int __ovld __cnfn isfinite(double);
 long2 __ovld __cnfn isfinite(double2);
 long3 __ovld __cnfn isfinite(double3);
 long4 __ovld __cnfn isfinite(double4);
 long8 __ovld __cnfn isfinite(double8);
 long16 __ovld __cnfn isfinite(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 int __ovld __cnfn isfinite(half);
 short2 __ovld __cnfn isfinite(half2);
@@ -10728,14 +10728,14 @@
 int4 __ovld __cnfn isinf(float4);
 int8 __ovld __cnfn isinf(float8);
 int16 __ovld __cnfn isinf(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 int __ovld __cnfn isinf(double);
 long2 __ovld __cnfn isinf(double2);
 long3 __ovld __cnfn isinf(double3);
 long4 __ovld __cnfn isinf(double4);
 long8 __ovld __cnfn isinf(double8);
 long16 __ovld __cnfn isinf(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 int __ovld __cnfn isinf(half);
 short2 __ovld __cnfn isinf(half2);
@@ -10754,14 +10754,14 @@
 int4 __ovld __cnfn isnan(float4);
 int8 __ovld __cnfn isnan(float8);
 int16 __ovld __cnfn isnan(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 int __ovld __cnfn isnan(double);
 long2 __ovld __cnfn isnan(double2);
 long3 __ovld __cnfn isnan(double3);
 long4 __ovld __cnfn isnan(double4);
 long8 __ovld __cnfn isnan(double8);
 long16 __ovld __cnfn isnan(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 int __ovld __cnfn isnan(half);
 short2 __ovld __cnfn isnan(half2);
@@ -10780,14 +10780,14 @@
 int4 __ovld __cnfn isnormal(float4);
 int8 __ovld __cnfn isnormal(float8);
 int16 __ovld __cnfn isnormal(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 int __ovld __cnfn isnormal(double);
 long2 __ovld __cnfn isnormal(double2);
 long3 __ovld __cnfn isnormal(double3);
 long4 __ovld __cnfn isnormal(double4);
 long8 __ovld __cnfn isnormal(double8);
 long16 __ovld __cnfn isnormal(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 int __ovld __cnfn isnormal(half);
 short2 __ovld __cnfn isnormal(half2);
@@ -10808,14 +10808,14 @@
 int4 __ovld __cnfn isordered(float4 x, float4 y);
 int8 __ovld __cnfn isordered(float8 x, float8 y);
 int16 __ovld __cnfn isordered(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 int __ovld __cnfn isordered(double x, double y);
 long2 __ovld __cnfn isordered(double2 x, double2 y);
 long3 __ovld __cnfn isordered(double3 x, double3 y);
 long4 __ovld __cnfn isordered(double4 x, double4 y);
 long8 __ovld __cnfn isordered(double8 x, double8 y);
 long16 __ovld __cnfn isordered(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 int __ovld __cnfn isordered(half x, half y);
 short2 __ovld __cnfn isordered(half2 x, half2 y);
@@ -10836,14 +10836,14 @@
 int4 __ovld __cnfn isunordered(float4 x, float4 y);
 int8 __ovld __cnfn isunordered(float8 x, float8 y);
 int16 __ovld __cnfn isunordered(float16 x, float16 y);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 int __ovld __cnfn isunordered(double x, double y);
 long2 __ovld __cnfn isunordered(double2 x, double2 y);
 long3 __ovld __cnfn isunordered(double3 x, double3 y);
 long4 __ovld __cnfn isunordered(double4 x, double4 y);
 long8 __ovld __cnfn isunordered(double8 x, double8 y);
 long16 __ovld __cnfn isunordered(double16 x, double16 y);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 int __ovld __cnfn isunordered(half x, half y);
 short2 __ovld __cnfn isunordered(half2 x, half2 y);
@@ -10866,14 +10866,14 @@
 int4 __ovld __cnfn signbit(float4);
 int8 __ovld __cnfn signbit(float8);
 int16 __ovld __cnfn signbit(float16);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 int __ovld __cnfn signbit(double);
 long2 __ovld __cnfn signbit(double2);
 long3 __ovld __cnfn signbit(double3);
 long4 __ovld __cnfn signbit(double4);
 long8 __ovld __cnfn signbit(double8);
 long16 __ovld __cnfn signbit(double16);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 int __ovld __cnfn signbit(half);
 short2 __ovld __cnfn signbit(half2);
@@ -11000,14 +11000,14 @@
 float4 __ovld __cnfn bitselect(float4 a, float4 b, float4 c);
 float8 __ovld __cnfn bitselect(float8 a, float8 b, float8 c);
 float16 __ovld __cnfn bitselect(float16 a, float16 b, float16 c);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn bitselect(double a, double b, double c);
 double2 __ovld __cnfn bitselect(double2 a, double2 b, double2 c);
 double3 __ovld __cnfn bitselect(double3 a, double3 b, double3 c);
 double4 __ovld __cnfn bitselect(double4 a, double4 b, double4 c);
 double8 __ovld __cnfn bitselect(double8 a, double8 b, double8 c);
 double16 __ovld __cnfn bitselect(double16 a, double16 b, double16 c);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn bitselect(half a, half b, half c);
 half2 __ovld __cnfn bitselect(half2 a, half2 b, half2 c);
@@ -11140,7 +11140,7 @@
 long16 __ovld __cnfn select(long16 a, long16 b, ulong16 c);
 ulong16 __ovld __cnfn select(ulong16 a, ulong16 b, ulong16 c);
 
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __cnfn select(double a, double b, long c);
 double2 __ovld __cnfn select(double2 a, double2 b, long2 c);
 double3 __ovld __cnfn select(double3 a, double3 b, long3 c);
@@ -11153,7 +11153,7 @@
 double4 __ovld __cnfn select(double4 a, double4 b, ulong4 c);
 double8 __ovld __cnfn select(double8 a, double8 b, ulong8 c);
 double16 __ovld __cnfn select(double16 a, double16 b, ulong16 c);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 half __ovld __cnfn select(half a, half b, short c);
 half2 __ovld __cnfn select(half2 a, half2 b, short2 c);
@@ -11232,13 +11232,13 @@
 long16 __ovld vload16(size_t offset, const __constant long *p);
 ulong16 __ovld vload16(size_t offset, const __constant ulong *p);
 float16 __ovld vload16(size_t offset, const __constant float *p);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double2 __ovld vload2(size_t offset, const __constant double *p);
 double3 __ovld vload3(size_t offset, const __constant double *p);
 double4 __ovld vload4(size_t offset, const __constant double *p);
 double8 __ovld vload8(size_t offset, const __constant double *p);
 double16 __ovld vload16(size_t offset, const __constant double *p);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #ifdef cl_khr_fp16
 half __ovld vload(size_t offset, const __constant half *p);
@@ -11296,13 +11296,13 @@
 ulong16 __ovld vload16(size_t offset, const ulong *p);
 float16 __ovld vload16(size_t offset, const float *p);
 
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double2 __ovld vload2(size_t offset, const double *p);
 double3 __ovld vload3(size_t offset, const double *p);
 double4 __ovld vload4(size_t offset, const double *p);
 double8 __ovld vload8(size_t offset, const double *p);
 double16 __ovld vload16(size_t offset, const double *p);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #ifdef cl_khr_fp16
 half __ovld vload(size_t offset, const half *p);
@@ -11449,7 +11449,7 @@
 ulong16 __ovld vload16(size_t offset, const __private ulong *p);
 float16 __ovld vload16(size_t offset, const __private float *p);
 
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double2 __ovld vload2(size_t offset, const __global double *p);
 double3 __ovld vload3(size_t offset, const __global double *p);
 double4 __ovld vload4(size_t offset, const __global double *p);
@@ -11465,7 +11465,7 @@
 double4 __ovld vload4(size_t offset, const __private double *p);
 double8 __ovld vload8(size_t offset, const __private double *p);
 double16 __ovld vload16(size_t offset, const __private double *p);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #ifdef cl_khr_fp16
 half __ovld vload(size_t offset, const __global half *p);
@@ -11535,13 +11535,13 @@
 void __ovld vstore16(long16 data, size_t offset, long *p);
 void __ovld vstore16(ulong16 data, size_t offset, ulong *p);
 void __ovld vstore16(float16 data, size_t offset, float *p);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 void __ovld vstore2(double2 data, size_t offset, double *p);
 void __ovld vstore3(double3 data, size_t offset, double *p);
 void __ovld vstore4(double4 data, size_t offset, double *p);
 void __ovld vstore8(double8 data, size_t offset, double *p);
 void __ovld vstore16(double16 data, size_t offset, double *p);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 void __ovld vstore(half data, size_t offset, half *p);
 void __ovld vstore2(half2 data, size_t offset, half *p);
@@ -11686,7 +11686,7 @@
 void __ovld vstore16(long16 data, size_t offset, __private long *p);
 void __ovld vstore16(ulong16 data, size_t offset, __private ulong *p);
 void __ovld vstore16(float16 data, size_t offset, __private float *p);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 void __ovld vstore2(double2 data, size_t offset, __global double *p);
 void __ovld vstore3(double3 data, size_t offset, __global double *p);
 void __ovld vstore4(double4 data, size_t offset, __global double *p);
@@ -11702,7 +11702,7 @@
 void __ovld vstore4(double4 data, size_t offset, __private double *p);
 void __ovld vstore8(double8 data, size_t offset, __private double *p);
 void __ovld vstore16(double16 data, size_t offset, __private double *p);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 void __ovld vstore(half data, size_t offset, __global half *p);
 void __ovld vstore2(half2 data, size_t offset, __global half *p);
@@ -11796,13 +11796,13 @@
 void __ovld vstore_half_rtz(float data, size_t offset, half *p);
 void __ovld vstore_half_rtp(float data, size_t offset, half *p);
 void __ovld vstore_half_rtn(float data, size_t offset, half *p);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 void __ovld vstore_half(double data, size_t offset, half *p);
 void __ovld vstore_half_rte(double data, size_t offset, half *p);
 void __ovld vstore_half_rtz(double data, size_t offset, half *p);
 void __ovld vstore_half_rtp(double data, size_t offset, half *p);
 void __ovld vstore_half_rtn(double data, size_t offset, half *p);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #else
 void __ovld vstore_half(float data, size_t offset, __global half *p);
 void __ovld vstore_half_rte(float data, size_t offset, __global half *p);
@@ -11819,7 +11819,7 @@
 void __ovld vstore_half_rtz(float data, size_t offset, __private half *p);
 void __ovld vstore_half_rtp(float data, size_t offset, __private half *p);
 void __ovld vstore_half_rtn(float data, size_t offset, __private half *p);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 void __ovld vstore_half(double data, size_t offset, __global half *p);
 void __ovld vstore_half_rte(double data, size_t offset, __global half *p);
 void __ovld vstore_half_rtz(double data, size_t offset, __global half *p);
@@ -11835,7 +11835,7 @@
 void __ovld vstore_half_rtz(double data, size_t offset, __private half *p);
 void __ovld vstore_half_rtp(double data, size_t offset, __private half *p);
 void __ovld vstore_half_rtn(double data, size_t offset, __private half *p);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 
 /**
@@ -11875,7 +11875,7 @@
 void __ovld vstore_half4_rtn(float4 data, size_t offset, half *p);
 void __ovld vstore_half8_rtn(float8 data, size_t offset, half *p);
 void __ovld vstore_half16_rtn(float16 data, size_t offset, half *p);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 void __ovld vstore_half2(double2 data, size_t offset, half *p);
 void __ovld vstore_half3(double3 data, size_t offset, half *p);
 void __ovld vstore_half4(double4 data, size_t offset, half *p);
@@ -11901,7 +11901,7 @@
 void __ovld vstore_half4_rtn(double4 data, size_t offset, half *p);
 void __ovld vstore_half8_rtn(double8 data, size_t offset, half *p);
 void __ovld vstore_half16_rtn(double16 data, size_t offset, half *p);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #else
 void __ovld vstore_half2(float2 data, size_t offset, __global half *p);
 void __ovld vstore_half3(float3 data, size_t offset, __global half *p);
@@ -11978,7 +11978,7 @@
 void __ovld vstore_half4_rtn(float4 data, size_t offset, __private half *p);
 void __ovld vstore_half8_rtn(float8 data, size_t offset, __private half *p);
 void __ovld vstore_half16_rtn(float16 data, size_t offset, __private half *p);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 void __ovld vstore_half2(double2 data, size_t offset, __global half *p);
 void __ovld vstore_half3(double3 data, size_t offset, __global half *p);
 void __ovld vstore_half4(double4 data, size_t offset, __global half *p);
@@ -12054,7 +12054,7 @@
 void __ovld vstore_half4_rtn(double4 data, size_t offset, __private half *p);
 void __ovld vstore_half8_rtn(double8 data, size_t offset, __private half *p);
 void __ovld vstore_half16_rtn(double16 data, size_t offset, __private half *p);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 
 /**
@@ -12156,7 +12156,7 @@
 void __ovld vstorea_half8_rtn(float8 data, size_t offset, half *p);
 void __ovld vstorea_half16_rtn(float16 data, size_t offset, half *p);
 
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 void __ovld vstorea_half(double data, size_t offset, half *p);
 void __ovld vstorea_half2(double2 data, size_t offset, half *p);
 void __ovld vstorea_half3(double3 data, size_t offset, half *p);
@@ -12191,7 +12191,7 @@
 void __ovld vstorea_half4_rtn(double4 data, size_t offset, half *p);
 void __ovld vstorea_half8_rtn(double8 data, size_t offset, half *p);
 void __ovld vstorea_half16_rtn(double16 data, size_t offset, half *p);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #else
 void __ovld vstorea_half(float data, size_t offset, __global half *p);
@@ -12299,7 +12299,7 @@
 void __ovld vstorea_half8_rtn(float8 data, size_t offset, __private half *p);
 void __ovld vstorea_half16_rtn(float16 data, size_t offset, __private half *p);
 
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 void __ovld vstorea_half(double data, size_t offset, __global half *p);
 void __ovld vstorea_half2(double2 data, size_t offset, __global half *p);
 void __ovld vstorea_half3(double3 data, size_t offset, __global half *p);
@@ -12404,7 +12404,7 @@
 void __ovld vstorea_half4_rtn(double4 data,size_t offset, __private half *p);
 void __ovld vstorea_half8_rtn(double8 data,size_t offset, __private half *p);
 void __ovld vstorea_half16_rtn(double16 data,size_t offset, __private half *p);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 
 // OpenCL v1.1 s6.11.8, v1.2 s6.12.8, v2.0 s6.13.8 - Synchronization Functions
@@ -12639,7 +12639,7 @@
 event_t __ovld async_work_group_copy(__global long16 *dst, const __local long16 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__global ulong16 *dst, const __local ulong16 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__global float16 *dst, const __local float16 *src, size_t num_elements, event_t event);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 event_t __ovld async_work_group_copy(__local double *dst, const __global double *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__local double2 *dst, const __global double2 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__local double3 *dst, const __global double3 *src, size_t num_elements, event_t event);
@@ -12652,7 +12652,7 @@
 event_t __ovld async_work_group_copy(__global double4 *dst, const __local double4 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__global double8 *dst, const __local double8 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__global double16 *dst, const __local double16 *src, size_t num_elements, event_t event);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 event_t __ovld async_work_group_copy(__local half *dst, const __global half *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__local half2 *dst, const __global half2 *src, size_t num_elements, event_t event);
@@ -12802,7 +12802,7 @@
 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);
 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);
 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);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 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);
 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);
 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);
@@ -12815,7 +12815,7 @@
 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);
 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);
 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);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 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);
 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);
@@ -12905,14 +12905,14 @@
 void __ovld prefetch(const __global long16 *p, size_t num_elements);
 void __ovld prefetch(const __global ulong16 *p, size_t num_elements);
 void __ovld prefetch(const __global float16 *p, size_t num_elements);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 void __ovld prefetch(const __global double *p, size_t num_elements);
 void __ovld prefetch(const __global double2 *p, size_t num_elements);
 void __ovld prefetch(const __global double3 *p, size_t num_elements);
 void __ovld prefetch(const __global double4 *p, size_t num_elements);
 void __ovld prefetch(const __global double8 *p, size_t num_elements);
 void __ovld prefetch(const __global double16 *p, size_t num_elements);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #ifdef cl_khr_fp16
 void __ovld prefetch(const __global half *p, size_t num_elements);
 void __ovld prefetch(const __global half2 *p, size_t num_elements);
@@ -13295,9 +13295,9 @@
 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
 void __ovld atomic_init(volatile atomic_long *object, long value);
 void __ovld atomic_init(volatile atomic_ulong *object, ulong value);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 void __ovld atomic_init(volatile atomic_double *object, double value);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 #endif
 
 // atomic_work_item_fence()
@@ -13417,11 +13417,11 @@
 void __ovld atomic_store_explicit(volatile atomic_float *object, float desired, memory_order order);
 void __ovld atomic_store_explicit(volatile atomic_float *object, float desired, memory_order order, memory_scope scope);
 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 void __ovld atomic_store(volatile atomic_double *object, double desired);
 void __ovld atomic_store_explicit(volatile atomic_double *object, double desired, memory_order order);
 void __ovld atomic_store_explicit(volatile atomic_double *object, double desired, memory_order order, memory_scope scope);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 void __ovld atomic_store(volatile atomic_long *object, long desired);
 void __ovld atomic_store_explicit(volatile atomic_long *object, long desired, memory_order order);
 void __ovld atomic_store_explicit(volatile atomic_long *object, long desired, memory_order order, memory_scope scope);
@@ -13442,11 +13442,11 @@
 float __ovld atomic_load_explicit(volatile atomic_float *object, memory_order order);
 float __ovld atomic_load_explicit(volatile atomic_float *object, memory_order order, memory_scope scope);
 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld atomic_load(volatile atomic_double *object);
 double __ovld atomic_load_explicit(volatile atomic_double *object, memory_order order);
 double __ovld atomic_load_explicit(volatile atomic_double *object, memory_order order, memory_scope scope);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 long __ovld atomic_load(volatile atomic_long *object);
 long __ovld atomic_load_explicit(volatile atomic_long *object, memory_order order);
 long __ovld atomic_load_explicit(volatile atomic_long *object, memory_order order, memory_scope scope);
@@ -13467,11 +13467,11 @@
 float __ovld atomic_exchange_explicit(volatile atomic_float *object, float desired, memory_order order);
 float __ovld atomic_exchange_explicit(volatile atomic_float *object, float desired, memory_order order, memory_scope scope);
 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld atomic_exchange(volatile atomic_double *object, double desired);
 double __ovld atomic_exchange_explicit(volatile atomic_double *object, double desired, memory_order order);
 double __ovld atomic_exchange_explicit(volatile atomic_double *object, double desired, memory_order order, memory_scope scope);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 long __ovld atomic_exchange(volatile atomic_long *object, long desired);
 long __ovld atomic_exchange_explicit(volatile atomic_long *object, long desired, memory_order order);
 long __ovld atomic_exchange_explicit(volatile atomic_long *object, long desired, memory_order order, memory_scope scope);
@@ -13513,7 +13513,7 @@
 bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_float *object, float *expected,
                                                                                  float desired, memory_order success, memory_order failure, memory_scope scope);
 #if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 bool __ovld atomic_compare_exchange_strong(volatile atomic_double *object, double *expected, double desired);
 bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_double *object, double *expected,
                                                                                  double desired, memory_order success, memory_order failure);
@@ -13524,7 +13524,7 @@
                                                                                  double desired, memory_order success, memory_order failure);
 bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_double *object, double *expected,
                                                                                  double desired, memory_order success, memory_order failure, memory_scope scope);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 bool __ovld atomic_compare_exchange_strong(volatile atomic_long *object, long *expected, long desired);
 bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_long *object, long *expected,
                                                                                  long desired, memory_order success, memory_order failure);
@@ -13782,7 +13782,7 @@
 float16 __ovld __cnfn shuffle(float8 x, uint16 mask);
 float16 __ovld __cnfn shuffle(float16 x, uint16 mask);
 
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double2 __ovld __cnfn shuffle(double2 x, ulong2 mask);
 double2 __ovld __cnfn shuffle(double4 x, ulong2 mask);
 double2 __ovld __cnfn shuffle(double8 x, ulong2 mask);
@@ -13802,7 +13802,7 @@
 double16 __ovld __cnfn shuffle(double4 x, ulong16 mask);
 double16 __ovld __cnfn shuffle(double8 x, ulong16 mask);
 double16 __ovld __cnfn shuffle(double16 x, ulong16 mask);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #ifdef cl_khr_fp16
 half2 __ovld __cnfn shuffle(half2 x, ushort2 mask);
@@ -14006,7 +14006,7 @@
 float16 __ovld __cnfn shuffle2(float8 x, float8 y, uint16 mask);
 float16 __ovld __cnfn shuffle2(float16 x, float16 y, uint16 mask);
 
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double2 __ovld __cnfn shuffle2(double2 x, double2 y, ulong2 mask);
 double2 __ovld __cnfn shuffle2(double4 x, double4 y, ulong2 mask);
 double2 __ovld __cnfn shuffle2(double8 x, double8 y, ulong2 mask);
@@ -14026,7 +14026,7 @@
 double16 __ovld __cnfn shuffle2(double4 x, double4 y, ulong16 mask);
 double16 __ovld __cnfn shuffle2(double8 x, double8 y, ulong16 mask);
 double16 __ovld __cnfn shuffle2(double16 x, double16 y, ulong16 mask);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #ifdef cl_khr_fp16
 half2 __ovld __cnfn shuffle2(half2 x, half2 y, ushort2 mask);
@@ -15113,11 +15113,11 @@
 float __ovld __conv work_group_broadcast(float a, size_t local_id);
 float __ovld __conv work_group_broadcast(float a, size_t x, size_t y);
 float __ovld __conv work_group_broadcast(float a, size_t x, size_t y, size_t z);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __conv work_group_broadcast(double a, size_t local_id);
 double __ovld __conv work_group_broadcast(double a, size_t x, size_t y);
 double __ovld __conv work_group_broadcast(double a, size_t x, size_t y, size_t z);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #ifdef cl_khr_fp16
 half __ovld __conv work_group_reduce_add(half x);
@@ -15175,7 +15175,7 @@
 float __ovld __conv work_group_scan_inclusive_add(float x);
 float __ovld __conv work_group_scan_inclusive_min(float x);
 float __ovld __conv work_group_scan_inclusive_max(float x);
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double __ovld __conv work_group_reduce_add(double x);
 double __ovld __conv work_group_reduce_min(double x);
 double __ovld __conv work_group_reduce_max(double x);
@@ -15185,7 +15185,7 @@
 double __ovld __conv work_group_scan_inclusive_add(double x);
 double __ovld __conv work_group_scan_inclusive_min(double x);
 double __ovld __conv work_group_scan_inclusive_max(double x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 
@@ -15315,7 +15315,7 @@
 half    __ovld __conv sub_group_scan_inclusive_max(half x);
 #endif //cl_khr_fp16
 
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double  __ovld __conv sub_group_broadcast(double x, uint sub_group_local_id);
 double  __ovld __conv sub_group_reduce_add(double x);
 double  __ovld __conv sub_group_reduce_min(double x);
@@ -15326,7 +15326,7 @@
 double  __ovld __conv sub_group_scan_inclusive_add(double x);
 double  __ovld __conv sub_group_scan_inclusive_min(double x);
 double  __ovld __conv sub_group_scan_inclusive_max(double x);
-#endif //cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #endif //cl_khr_subgroups cl_intel_subgroups
 
@@ -15448,14 +15448,14 @@
 half16 __ovld __conv sub_group_broadcast( half16 value, uint index );
 #endif  // cl_khr_fp16
 
-#if defined(cl_khr_fp64)
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 // scalar double broadcast is part of cl_khr_subgroups
 double2 __ovld __conv sub_group_broadcast( double2 value, uint index );
 double3 __ovld __conv sub_group_broadcast( double3 value, uint index );
 double4 __ovld __conv sub_group_broadcast( double4 value, uint index );
 double8 __ovld __conv sub_group_broadcast( double8 value, uint index );
 double16 __ovld __conv sub_group_broadcast( double16 value, uint index );
-#endif  // cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #endif  // cl_khr_subgroup_extended_types
 
@@ -15478,9 +15478,9 @@
 int     __ovld sub_group_non_uniform_all_equal( half value );
 #endif // cl_khr_fp16
 
-#if defined(cl_khr_fp64)
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 int     __ovld sub_group_non_uniform_all_equal( double value );
-#endif // cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #endif // cl_khr_subgroup_non_uniform_vote
 
@@ -15585,7 +15585,7 @@
 half    __ovld sub_group_broadcast_first( half value );
 #endif // cl_khr_fp16
 
-#if defined(cl_khr_fp64)
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double   __ovld sub_group_non_uniform_broadcast( double value, uint index );
 double2  __ovld sub_group_non_uniform_broadcast( double2 value, uint index );
 double3  __ovld sub_group_non_uniform_broadcast( double3 value, uint index );
@@ -15594,7 +15594,7 @@
 double16 __ovld sub_group_non_uniform_broadcast( double16 value, uint index );
 
 double   __ovld sub_group_broadcast_first( double value );
-#endif // cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #endif // cl_khr_subgroup_ballot
 
@@ -15827,7 +15827,7 @@
 half    __ovld sub_group_non_uniform_scan_exclusive_max( half value );
 #endif // cl_khr_fp16
 
-#if defined(cl_khr_fp64)
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double  __ovld sub_group_non_uniform_reduce_add( double value );
 double  __ovld sub_group_non_uniform_reduce_mul( double value );
 double  __ovld sub_group_non_uniform_reduce_min( double value );
@@ -15840,7 +15840,7 @@
 double  __ovld sub_group_non_uniform_scan_exclusive_mul( double value );
 double  __ovld sub_group_non_uniform_scan_exclusive_min( double value );
 double  __ovld sub_group_non_uniform_scan_exclusive_max( double value );
-#endif // cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #endif // cl_khr_subgroup_non_uniform_arithmetic
 
@@ -15870,10 +15870,10 @@
 half    __ovld sub_group_shuffle_xor( half value, uint mask );
 #endif // cl_khr_fp16
 
-#if defined(cl_khr_fp64)
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double  __ovld sub_group_shuffle( double value, uint index );
 double  __ovld sub_group_shuffle_xor( double value, uint mask );
-#endif // cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #endif // cl_khr_subgroup_shuffle
 
@@ -15903,10 +15903,10 @@
 half    __ovld sub_group_shuffle_down( half value, uint delta );
 #endif // cl_khr_fp16
 
-#if defined(cl_khr_fp64)
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double  __ovld sub_group_shuffle_up( double value, uint delta );
 double  __ovld sub_group_shuffle_down( double value, uint delta );
-#endif // cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #endif // cl_khr_subgroup_shuffle_relative
 
@@ -15989,12 +15989,12 @@
 half    __ovld sub_group_clustered_reduce_max( half value, uint clustersize );
 #endif // cl_khr_fp16
 
-#if defined(cl_khr_fp64)
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double  __ovld sub_group_clustered_reduce_add( double value, uint clustersize );
 double  __ovld sub_group_clustered_reduce_mul( double value, uint clustersize );
 double  __ovld sub_group_clustered_reduce_min( double value, uint clustersize );
 double  __ovld sub_group_clustered_reduce_max( double value, uint clustersize );
-#endif // cl_khr_fp64
+#endif // defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 
 #endif // cl_khr_subgroup_clustered_reduce
 
@@ -16137,7 +16137,7 @@
 half    __ovld __conv intel_sub_group_shuffle_xor( half x, uint c );
 #endif
 
-#if defined(cl_khr_fp64)
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 double  __ovld __conv intel_sub_group_shuffle( double x, uint c );
 double  __ovld __conv intel_sub_group_shuffle_down( double prev, double cur, uint c );
 double  __ovld __conv intel_sub_group_shuffle_up( double prev, double cur, uint c );
diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp
--- a/clang/lib/Sema/Sema.cpp
+++ b/clang/lib/Sema/Sema.cpp
@@ -301,6 +301,8 @@
         Context.getTargetInfo().getSupportedOpenCLOpts(), getLangOpts());
     addImplicitTypedef("sampler_t", Context.OCLSamplerTy);
     addImplicitTypedef("event_t", Context.OCLEventTy);
+    llvm::StringRef FP64Feature(
+        getLangOpts().OpenCLVersion >= 300 ? "__opencl_c_fp64" : "cl_khr_fp64");
     if (getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) {
       addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);
       addImplicitTypedef("queue_t", Context.OCLQueueTy);
@@ -332,10 +334,10 @@
                                          getLangOpts()) &&
           getOpenCLOptions().isSupported("cl_khr_int64_extended_atomics",
                                          getLangOpts())) {
-        if (getOpenCLOptions().isSupported("cl_khr_fp64", getLangOpts())) {
+        if (getOpenCLOptions().isSupported(FP64Feature, getLangOpts())) {
           auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy);
           addImplicitTypedef("atomic_double", AtomicDoubleT);
-          setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64");
+          setOpenCLExtensionForType(AtomicDoubleT, FP64Feature);
           Atomic64BitTypes.push_back(AtomicDoubleT);
         }
         auto AtomicLongT = Context.getAtomicType(Context.LongTy);
@@ -366,7 +368,7 @@
             "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics");
     }
 
-    setOpenCLExtensionForType(Context.DoubleTy, "cl_khr_fp64");
+    setOpenCLExtensionForType(Context.DoubleTy, FP64Feature);
 
 #define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \
     setOpenCLExtensionForType(Context.Id, Ext);
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -831,7 +831,7 @@
   if (BTy && (BTy->getKind() == BuiltinType::Half ||
               BTy->getKind() == BuiltinType::Float)) {
     if (getLangOpts().OpenCL &&
-        !getOpenCLOptions().isAvailableOption("cl_khr_fp64", getLangOpts())) {
+        !getOpenCLOptions().isFP64Enabled(getLangOpts())) {
       if (BTy->getKind() == BuiltinType::Half) {
         E = ImpCastExprToType(E, Context.FloatTy, CK_FloatingCast).get();
       }
@@ -3845,10 +3845,11 @@
         if (Ty->castAs<BuiltinType>()->getKind() != BuiltinType::Float) {
           Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get();
         }
-      } else if (getLangOpts().OpenCL && !getOpenCLOptions().isAvailableOption(
-                                             "cl_khr_fp64", getLangOpts())) {
+      } else if (getLangOpts().OpenCL &&
+                 !getOpenCLOptions().isFP64Enabled(getLangOpts())) {
         // Impose single-precision float type when cl_khr_fp64 is not enabled.
-        Diag(Tok.getLocation(), diag::warn_double_const_requires_fp64);
+        Diag(Tok.getLocation(), diag::warn_double_const_requires_fp64)
+            << (getLangOpts().OpenCLVersion >= 300);
         Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get();
       }
     }
diff --git a/clang/test/CodeGenOpenCL/printf.cl b/clang/test/CodeGenOpenCL/printf.cl
--- a/clang/test/CodeGenOpenCL/printf.cl
+++ b/clang/test/CodeGenOpenCL/printf.cl
@@ -1,10 +1,12 @@
 // 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
 // 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
+// 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
+// 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=NOFP64,ALL %s
 
 typedef __attribute__((ext_vector_type(2))) float float2;
 typedef __attribute__((ext_vector_type(2))) half half2;
 
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 typedef __attribute__((ext_vector_type(2))) double double2;
 #endif
 
@@ -28,7 +30,7 @@
   printf("%v2hf", arg);
 }
 
-#ifdef cl_khr_fp64
+#if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
 // FP64-LABEL: @test_printf_double2(
 // FP64: call spir_func i32 (i8 addrspace(2)*, ...) @printf(i8 addrspace(2)* getelementptr inbounds ([6 x i8], [6 x i8] addrspace(2)* @.str.2, i32 0, i32 0), <2 x double> %0)
 kernel void test_printf_double2(double2 arg) {
diff --git a/clang/test/SemaOpenCL/extensions.cl b/clang/test/SemaOpenCL/fp64-fp16-options.cl
rename from clang/test/SemaOpenCL/extensions.cl
rename to clang/test/SemaOpenCL/fp64-fp16-options.cl
--- a/clang/test/SemaOpenCL/extensions.cl
+++ b/clang/test/SemaOpenCL/fp64-fp16-options.cl
@@ -4,6 +4,7 @@
 
 // Test with a target not supporting fp64.
 // RUN: %clang_cc1 %s -triple r600-unknown-unknown -target-cpu r600 -verify -pedantic -fsyntax-only -DNOFP64 -DNOFP16
+// RUN: %clang_cc1 -cl-std=CL3.0 %s -triple r600-unknown-unknown -target-cpu r600 -verify -pedantic -fsyntax-only -DNOFP64 -DNOFP16
 
 // Test with some extensions enabled or disabled by cmd-line args
 //
@@ -15,12 +16,18 @@
 // RUN: %clang_cc1 %s -triple r600-unknown-unknown -target-cpu r600 -verify -pedantic -fsyntax-only -cl-ext=+all
 // RUN: %clang_cc1 %s -triple r600-unknown-unknown -target-cpu r600 -verify -pedantic -fsyntax-only -cl-ext=+all,-cl_khr_fp64 -DNOFP64
 // RUN: %clang_cc1 %s -triple r600-unknown-unknown -target-cpu r600 -verify -pedantic -fsyntax-only -cl-ext=-all,+cl_khr_fp64 -DNOFP16
+// RUN: %clang_cc1 -cl-std=CL3.0 %s -triple spir-unknown-unknown -verify -pedantic -fsyntax-only -cl-ext=-all -DNOFP64 -DNOFP16
+// RUN: %clang_cc1 -cl-std=CL3.0 %s -triple r600-unknown-unknown -target-cpu r600 -verify -pedantic -fsyntax-only -cl-ext=+all -DFP64
+// RUN: %clang_cc1 -cl-std=CL3.0 %s -triple r600-unknown-unknown -target-cpu r600 -verify -pedantic -fsyntax-only -cl-ext=+all,-__opencl_c_fp64 -DNOFP64
 //
 // Concatenating
 // RUN: %clang_cc1 %s -triple spir-unknown-unknown -verify -pedantic -fsyntax-only -cl-ext=-cl_khr_fp64 -cl-ext=+cl_khr_fp64
 // RUN: %clang_cc1 %s -triple spir-unknown-unknown -verify -pedantic -fsyntax-only -cl-ext=-cl_khr_fp64,+cl_khr_fp64
 // RUN: %clang_cc1 %s -triple spir-unknown-unknown -verify -pedantic -fsyntax-only -cl-ext=-all -cl-ext=+cl_khr_fp64 -cl-ext=+cl_khr_fp16 -cl-ext=-cl_khr_fp64 -DNOFP64
 // RUN: %clang_cc1 %s -triple spir-unknown-unknown -verify -pedantic -fsyntax-only -cl-ext=-all -cl-ext=+cl_khr_fp64,-cl_khr_fp64,+cl_khr_fp16 -DNOFP64
+// RUN: %clang_cc1 -cl-std=CL3.0 %s -triple spir-unknown-unknown -verify -pedantic -fsyntax-only -cl-ext=-__opencl_c_fp64 -cl-ext=+__opencl_c_fp64 -DFP64
+// RUN: %clang_cc1 -cl-std=CL3.0 %s -triple spir-unknown-unknown -verify -pedantic -fsyntax-only -cl-ext=-__opencl_c_fp64,+__opencl_c_fp64 -DFP64
+// RUN: %clang_cc1 -cl-std=CL3.0 %s -triple spir-unknown-unknown -verify -pedantic -fsyntax-only -cl-ext=-__opencl_c_fp64,+cl_khr_fp64 -DNOFP64
 
 // Test with -finclude-default-header, which includes opencl-c.h. opencl-c.h
 // disables all extensions by default, but supported core extensions for a
@@ -72,20 +79,20 @@
 void f2(void) {
   double d;
 #ifdef NOFP64
-// expected-error@-2{{use of type 'double' requires cl_khr_fp64 support}}
+// expected-error-re@-2{{use of type 'double' requires {{cl_khr_fp64|__opencl_c_fp64}} support}}
 #endif
 
   typedef double double4 __attribute__((ext_vector_type(4)));
   double4 d4 = {0.0f, 2.0f, 3.0f, 1.0f};
 #ifdef NOFP64
-// expected-error@-3 {{use of type 'double' requires cl_khr_fp64 support}}
-// expected-error@-3 {{use of type 'double4' (vector of 4 'double' values) requires cl_khr_fp64 support}}
+// expected-error-re@-3 {{use of type 'double' requires {{cl_khr_fp64|__opencl_c_fp64}} support}}
+// expected-error-re@-3 {{use of type 'double4' (vector of 4 'double' values) requires {{cl_khr_fp64|__opencl_c_fp64}} support}}
 #endif
 
   (void) 1.0;
 
 #ifdef NOFP64
-// expected-warning@-3{{double precision constant requires cl_khr_fp64, casting to single precision}}
+// expected-warning-re@-3{{double precision constant requires {{cl_khr_fp64|__opencl_c_fp64}}, casting to single precision}}
 #endif
 }