[OpenCL] Add support of OpenCL C 3.0 __opencl_c_fp64

[azabaznov]

Summary

There already exists cl_khr_fp64 extension. So OpenCL C 3.0
and higher should use the feature, earlier versions still
use the extension. OpenCL C 3.0 API spec states that extension
will be not described in the option string if corresponding
optional functionality is not supported (see 4.2. Querying Devices).
Due to that fact the usage of features for OpenCL C 3.0 must
be as follows:

$ clang -Xclang -cl-ext=+cl_khr_fp64,+__opencl_c_fp64 ...

$ clang -Xclang -cl-ext=-cl_khr_fp64,-__opencl_c_fp64 ...

e.g. the feature and the equivalent extension (if exists)
must be set to the same values

[svenvh]

clang/include/clang/Basic/OpenCLOptions.h

157

The argument "Ext" suggests "Extension", so perhaps rename if this is about features? (also in the definition in the .cpp file)

clang/lib/Basic/TargetInfo.cpp

395

simultaneosly -> simultaneously
correspoding -> corresponding

clang/lib/Headers/opencl-c.h

4635

Wondering if we need a similar change in clang/lib/Headers/opencl-c-base.h to guard the double<N> vector types?

[Anastasia]

clang/include/clang/Basic/DiagnosticSemaKinds.td

9899

We shouldn't require enabling the features besides features and extensions are conceptually the same, let's avoid adding too much complexity due to the unfortunate differences in the spec wording.

I suggest changing this to something like:

use of %select{type|declaration}0 %1 requires %2 support

FYI I would also be happy if we don't guard the types by the pragma at all and just allow using the type freely if the extensions is supported. This already happens for the functions so it is not clear why functions and types should be different. The benefit of the pragma guarding hasn't been found after more than a year of investigations.

clang/lib/Basic/OpenCLOptions.cpp

24

We should at least be checking for isSupported("__opencl_c_fp64"), but frankly I would prefer to check for supported and not for enabled for cl_khr_fp64 too. Note that we don't break backward compatibility if we change this because the existing kernels will still be valid and it makes things easier for writing new kernels too.

clang/lib/Basic/TargetInfo.cpp

398

I suggest we move this onto OpenCLOptions::addSupport.

clang/lib/Headers/opencl-c.h

4635

Instead of growing the guard condition, I suggest we only check for one for example the feature macro and then make sure the feature macro is defined in opencl-c-base.h if the extensions that aliases to the feature is supported. However, it would also be ok to do the opposite since the extensions and the corresponding features should both be available.

FYI, something similar was done in https://reviews.llvm.org/D92004.

This will also help to propagate the functionality into Tablegen header because we won't need to extend it to work with multiple extensions but we might still need to do the rename.

clang/lib/Sema/Sema.cpp

356

I think we should just guard

addImplicitTypedef("atomic_double", AtomicDoubleT);

by the feature support instead...

Or alternatively, we could also just change this entire diagnostic set up to check for extensions and features being supported and not enabled.

Frankly, I would prefer the first solution because this aligns with C/C++ concept. It is not possible for the compiler to know all possible types and functions that are added via the libraries so this diagnostic only worked for some cases (that are added to the compiler) but not all cases. However, I don't think we need to expose to the developer where and how features are implemented. This will avoid unnessasary questions - why in some cases they get one diagnostic and in the other case they get another diagnostic. It will allow us to change the implementation without the developers to notice. And considering that this doesn't break backward compatibility it is a pretty reasonable direction in my opinion.

clang/test/SemaOpenCL/opencl-fp64-feature.cl

1

I suggest we merge this with extensions.cl that has similar functionality. As it mainly tests doubles I don't mind if you prefer to rename it then.

[azabaznov]

clang/include/clang/Basic/OpenCLOptions.h

157

Sure, thanks. I was going to rename 'extensions' to other concept which will represent extensions and features, but this will be done in a separate commit

clang/lib/Basic/OpenCLOptions.cpp

24

I think everything fine with this for now because OpenCLOptions::enableSupportedCore is called to set all supported core or optional core features to enabled state. So you suggest to removing this method at all too?

I think with your approach things will be unobvious in code: for some extensions there will be check for isSupported for some other there will be check for isEnabled. I think we should stay consistent here and check availability of all options in the same manner.

clang/lib/Basic/TargetInfo.cpp

395

Sure, thanks

398

This should stay here to control simultaneous macro definitions

clang/lib/Headers/opencl-c.h

4635

Yeah, I overlooked this place... Thanks!

4635

I don't think that growing of this condition will hurt in some cases... Note, that unifying condition check makes sense if some features are unconditionally supported for OpenCL C 2.0, such as generic address space for example. In other cases (such as fp64, 3d image writes, subgroups) we should use OR in guard condition.

Your approach will require extra checks in clang such as, for example, to make sure that extension macro is not predefined if the feature macro is defined, because there will be redefinition since extension macro is defined in header.

clang/lib/Sema/Sema.cpp

356

I think we should just guard

Hmm, I've never though of it but is sounds like a good idea. I'll double-check that and see how it will work!

clang/test/SemaOpenCL/opencl-fp64-feature.cl

1

Sure, I'll try that. At first, I just didn't want to modify test's  guard checks as it will become messy:

#if __OPENCL_C_VERSION__ >= 300
// expected-error@-2{{use of type 'double' requires __opencl_c_fp64 feature to be enabled}}
#else
// expected-error@-4{{use of type 'double' requires cl_khr_fp64 feature to be enabled}}
#endif

I see if I can avoid that. Maybe also try to unify the diagnostic for that case?

[Anastasia]

clang/lib/Basic/OpenCLOptions.cpp

24

I think everything fine with this for now because OpenCLOptions::enableSupportedCore is called to set all supported core or optional core features to enabled state. So you suggest to removing this method at all too?

Yes, I find it redundant somehow. Maybe it's best to indeed remove enabling functionality for features since we definitely don't plan to use pragmas for those? However, I appreciate it might be better to do as a separate change.

I think with your approach things will be unobvious in code: for some extensions there will be check for isSupported for some other there will be check for isEnabled. I think we should stay consistent here and check availability of all options in the same manner.

That's right, we might get some inconsistency at the start. But I think we should drive towards checking isSupported rather than isEnabled. I don't think we will have many cases for isEnabled at the end.

clang/lib/Basic/TargetInfo.cpp

398

Could we leave this bit out? These are set correctly by the targets already... and I think targets do need to set those explicitly indeed. I don't see big value in this functionality right now.

clang/lib/Headers/opencl-c.h

4635

I think using one macro for everything is just simpler and cleaner.

Your approach will require extra checks in clang such as, for example, to make sure that extension macro is not predefined if the feature macro is defined, because there will be redefinition since extension macro is defined in header.

I think we should handle this in the headers instead and we should definitely define the macros conditionally to avoid redefinitions.

clang/test/SemaOpenCL/opencl-fp64-feature.cl

1

I agree, perhaps regular expressions in the diagnostics could help too i.e. expected-error-re.

[azabaznov]

clang/lib/Basic/OpenCLOptions.cpp

24

Thanks for feedback. I did some refactoring needed for this patch to proceed: https://reviews.llvm.org/D97058. AFAIU it doesn't conflict with the one you did (https://reviews.llvm.org/D97052).

[azabaznov]

Addressed comments, rebased after refactoring: https://reviews.llvm.org/D97058

[azabaznov]

clang/lib/Basic/TargetInfo.cpp

398

There are 2 reasons why it should be here

1. Simultaneous macro definition

2. Correct option processing: we need to remove cl_khr_fp64 macro if -cl-ext=-__opencl_c_fp64 specified

[azabaznov]

Remove unrelated change, fixed error in test to check only cl_khr_fp64 for OpenCL C < 1.2

[Anastasia]

I would prefer if we try to take a slightly different route i.e. if two features are identical (e.g. cl_khr_fp64 and __opencl_c_fp64) we make sure that they are both set identical in Target options or command-line interface using early check and a diagnostic in the driver. This could be done at the end of the frontend options setup. Then for the rest of the compilation including header parsing, we can confidently keep checking only one of them because we know that they are both set consistently and that they are indeed identical. If you stick to checking for cl_khr_fp64 you can avoid most of the modifications completely.

I have added more details in the code comments. :)

clang/lib/Basic/OpenCLOptions.cpp

24

btw since cl_khr_fp64 is available in all versions could we not just check only for it?

clang/lib/Basic/TargetInfo.cpp

398

Ok as I said I would prefer to stick to an explicit interface though, i.e. every feature should be set explicitly
-cl-ext=-__opencl_c_fp64,-cl_khr_fp64
as the interface gets too messy otherwise...

I believe we won't have that many of those case - is it just fp64, fp16 and images?

If you are worried about the inconsistent uses (which is a valid concern!) how about we just add a check with a diagnostic in clang driver about the consistency of the setup between the language, command-line options and the target. We already discussed such check in other use cases - to help avoid using incorrect language versions that the target has no support.

I think this route will be easier than keeping consistency automatically and silently overriding the options i.e. we already had bad experiences with bugs due to such logic. A diagnostic would be very helpful both to application developers and tooling developers and help to avoid extra complexity in clang too.

clang/lib/Headers/opencl-c-base.h

530 ↗

(On Diff #336434)

Let's only use one macro as they signal the same. I don't mind which one you choose perhaps __opencl_c_fp64 could be used since we can freely define it in the earliest versions or we can continue using cl_khr_fp64 then no changes are needed other then making sure it is defined when __opencl_c_fp64 is defined which can be done at the top of this header btw.

clang/lib/Headers/opencl-c.h

4635

Do you still plan to address this? FYI this comment is the same as in opencl-c-base.h.

clang/lib/Sema/Sema.cpp

305

But cl_khr_fp64 is also available if __opencl_c_fp64 is available. If anything it should be even more available for backward compatibility. I don't see the point in checking the same thing twice or checking it differently.

If you are worried you could add some comment/documentation to clarify that they both have to be set or unset simultaneously and a check in the Clang driver initialization verifying the consistency in the settings.

[azabaznov]

My main idea was to provide an interface which will not make users to specify -cl-ext=+__opencl_c_fp64,+cl_khr_fp64/ -cl-ext=-__opencl_c_fp64,-cl_khr_fp64 if they need to enable/disable functionality in OpenCL C 3.0 because I believe that is not a right thing to do: why anyone should care about those extensions if there are features already? Also, this may lead to confusions since, for example, __opencl_c_subgroups and cl_khr_subgroups are not the same (subgroup independent forward progress is required in extension while it is optional in OpenCL C 3.0, thus implementation may support the extension but not the feature).

To be clear: I'm OK with providing a validation of correct option settings (__opencl_c_fp64/cl_khr_fp64 and __opencl_c_3d_image_writes/cl_khr_3d_image_writes should both be set to the same value). Also, it makes sense to unify a check within header and clang to the only macro, I'm OK with that too. But I would prefer to keep the option interface without redundant mentioning of extension.

[Anastasia]

In D96524#2691428, @azabaznov wrote:

My main idea was to provide an interface which will not make users to specify -cl-ext=+__opencl_c_fp64,+cl_khr_fp64/ -cl-ext=-__opencl_c_fp64,-cl_khr_fp64 if they need to enable/disable functionality in OpenCL C 3.0 because I believe that is not a right thing to do: why anyone should care about those extensions if there are features already? Also, this may lead to confusions since, for example, __opencl_c_subgroups and cl_khr_subgroups are not the same (subgroup independent forward progress is required in extension while it is optional in OpenCL C 3.0, thus implementation may support the extension but not the feature).

To be clear: I'm OK with providing a validation of correct option settings (__opencl_c_fp64/cl_khr_fp64 and __opencl_c_3d_image_writes/cl_khr_3d_image_writes should both be set to the same value). Also, it makes sense to unify a check within header and clang to the only macro, I'm OK with that too. But I would prefer to keep the option interface without redundant mentioning of extension.

Ok, let's implement both - we can add an early check of consistency of options and therefore will only need to use one for checking during the parsing and let's simplify the interface of -cl-ext. Since it is a frontend option and new functionality doesn't cause backward compatibility issues i.e. only affects OpenCL 3.0 onwards, so I see no risk. Could you please update the help documentation of the option explaining the new behavior? Then let's concentrate the whole logic for setting the options and keeping the consistency between the equivalent ones in TargetInfo::setCommandLineOpenCLOpts directly? This will provide cleaner flow due to encapsulation and will make it clear where the use case comes from. Does it make sense?

[azabaznov]

In D96524#2692376, @Anastasia wrote:

In D96524#2691428, @azabaznov wrote:

My main idea was to provide an interface which will not make users to specify -cl-ext=+__opencl_c_fp64,+cl_khr_fp64/ -cl-ext=-__opencl_c_fp64,-cl_khr_fp64 if they need to enable/disable functionality in OpenCL C 3.0 because I believe that is not a right thing to do: why anyone should care about those extensions if there are features already? Also, this may lead to confusions since, for example, __opencl_c_subgroups and cl_khr_subgroups are not the same (subgroup independent forward progress is required in extension while it is optional in OpenCL C 3.0, thus implementation may support the extension but not the feature).

To be clear: I'm OK with providing a validation of correct option settings (__opencl_c_fp64/cl_khr_fp64 and __opencl_c_3d_image_writes/cl_khr_3d_image_writes should both be set to the same value). Also, it makes sense to unify a check within header and clang to the only macro, I'm OK with that too. But I would prefer to keep the option interface without redundant mentioning of extension.

Ok, let's implement both - we can add an early check of consistency of options and therefore will only need to use one for checking during the parsing and let's simplify the interface of -cl-ext. Since it is a frontend option and new functionality doesn't cause backward compatibility issues i.e. only affects OpenCL 3.0 onwards, so I see no risk. Could you please update the help documentation of the option explaining the new behavior? Then let's concentrate the whole logic for setting the options and keeping the consistency between the equivalent ones in TargetInfo::setCommandLineOpenCLOpts directly? This will provide cleaner flow due to encapsulation and will make it clear where the use case comes from. Does it make sense?

Sure, agree. FYI I'm looking to a proper way of validating a target already. There already exists TargetInfo::validateTarget. I wanted to reuse that (just don't want to introduce yet another interface for OpenCL in Target), but I'm again bumping into some problems because of our special OpenCL options settings: a target should be immutable once created; and language options are not used to create a target. I'm just wondering if there is some more refactoring is needed...

[Anastasia]

In D96524#2705192, @azabaznov wrote:

In D96524#2692376, @Anastasia wrote:

In D96524#2691428, @azabaznov wrote:

My main idea was to provide an interface which will not make users to specify -cl-ext=+__opencl_c_fp64,+cl_khr_fp64/ -cl-ext=-__opencl_c_fp64,-cl_khr_fp64 if they need to enable/disable functionality in OpenCL C 3.0 because I believe that is not a right thing to do: why anyone should care about those extensions if there are features already? Also, this may lead to confusions since, for example, __opencl_c_subgroups and cl_khr_subgroups are not the same (subgroup independent forward progress is required in extension while it is optional in OpenCL C 3.0, thus implementation may support the extension but not the feature).

To be clear: I'm OK with providing a validation of correct option settings (__opencl_c_fp64/cl_khr_fp64 and __opencl_c_3d_image_writes/cl_khr_3d_image_writes should both be set to the same value). Also, it makes sense to unify a check within header and clang to the only macro, I'm OK with that too. But I would prefer to keep the option interface without redundant mentioning of extension.

Ok, let's implement both - we can add an early check of consistency of options and therefore will only need to use one for checking during the parsing and let's simplify the interface of -cl-ext. Since it is a frontend option and new functionality doesn't cause backward compatibility issues i.e. only affects OpenCL 3.0 onwards, so I see no risk. Could you please update the help documentation of the option explaining the new behavior? Then let's concentrate the whole logic for setting the options and keeping the consistency between the equivalent ones in TargetInfo::setCommandLineOpenCLOpts directly? This will provide cleaner flow due to encapsulation and will make it clear where the use case comes from. Does it make sense?

Sure, agree. FYI I'm looking to a proper way of validating a target already. There already exists TargetInfo::validateTarget. I wanted to reuse that (just don't want to introduce yet another interface for OpenCL in Target), but I'm again bumping into some problems because of our special OpenCL options settings: a target should be immutable once created; and language options are not used to create a target. I'm just wondering if there is some more refactoring is needed...

I see, if you need any help feel free to provide more details and we can discuss it further. :)

[azabaznov]

Please see https://reviews.llvm.org/D101087.

I think unifying with target features requires more effort than it seemed because target features are declared in LLVM (see for example AMDGPUFeatureKV in AMDGPUGenSubtargetInfo.inc, llvm/lib/Target/AMDGPU/AMDGPU.td)

[azabaznov]

Rebased to use ::validateOpenCLTarget. Decided to use explicit simulatneous extensions/feature disabling in command line due to API spec limitations:

clGetDeviceInfo: Will not describe support for the cl_khr_3d_image_writes extension if device does not support writing to 3D image objects.

Will update docs.

[Anastasia]

clang/include/clang/Basic/DiagnosticCommonKinds.td

369 ↗

(On Diff #343417)

We don't normally start from the upper case:

Options -> options

I am thinking we could drop "which is illegal in OpenCL C 3.0" because the fact that compiler gives an error indicates that it is illegal. So I find it a bit redundant.

clang/include/clang/Basic/DiagnosticSemaKinds.td

121–122

I am thinking that in OpenCL 3 both cl_khr_fp64 and __opencl_c_fp64 are required. Maybe we should re-word this as follows?

clang/lib/Sema/Sema.cpp

306

Technically both "__opencl_c_fp64" and "cl_khr_fp64" are required in OpenCL, perhaps we should report both in OpenCL 3?

[azabaznov]

clang/lib/Sema/Sema.cpp

306

Even better, can we merge this first https://reviews.llvm.org/D100976? This is needed to completely remove such check for fp64.

[Anastasia]

clang/lib/Sema/Sema.cpp

306

Sure I have committed it now: https://reviews.llvm.org/rG769cc335e6e63e5eac0c0ac849de44714326e20b

Btw, I will also commit https://reviews.llvm.org/D101043 soon. That should hopefully remove the remianing confusions around pragmas.

[azabaznov]

Rebase after https://reviews.llvm.org/D100976; addressed review comments and updated docs.

[Anastasia]

LGTM! Thanks!

clang/lib/Sema/Sema.cpp

304

I suggest to drop changes in this file since they are formatting only.

clang/test/CodeGenOpenCL/printf.cl

9

I think we don't technically need this change?

[azabaznov]

Drop formatting changes from Sema.cpp

[azabaznov]

Drop one more formatting change from Sema.cpp

[azabaznov]

clang/test/CodeGenOpenCL/printf.cl

9

To be honest I am not sure. I think per OpenCL C spec extension feature macros should be used exactly as follows:

...
if defined(cl_khr_fp64) || defined(__opencl_c_fp64)
...

So I think this is OK to have such checks in tests as soon as we have functionality for simultaneous support (opencl-c-3.0.incorrect_options.cl). If we decide to change that behaviour - this test will fail.

clang/include/clang/Basic/DiagnosticSemaKinds.td

def ext_predef_outside_function : Warning<
   InGroup<DiagGroup<"predefined-identifier-outside-function">>;
 def warn_float_overflow : Warning<
   "magnitude of floating-point constant too large for type %0; maximum is %1">,
    InGroup<LiteralRange>;
 def warn_float_underflow : Warning<
   "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">;
 
 // C99 variable-length arrays
 def ext_vla : Extension<"variable length arrays are a C99 feature">,
   InGroup<VLAExtension>;
 def warn_vla_used : Warning<"variable length array used">,
   InGroup<VLA>, DefaultIgnore;

 def err_opencl_type_can_only_be_used_as_function_parameter : Error <
   "type %0 can only be used as a function parameter in OpenCL">;
 def warn_opencl_attr_deprecated_ignored : Warning <
   "%0 attribute is deprecated and ignored in OpenCL version %1">,
   InGroup<IgnoredAttributes>;
 def err_opencl_variadic_function : Error<
   "invalid prototype, variadic arguments are not allowed in OpenCL">;
 def err_opencl_requires_extension : Error<
-  "use of %select{type|declaration}0 %1 requires %2 extension to be enabled">;
+  "use of %select{type|declaration}0 %1 requires %2 %select{extension|feature}3 to be enabled">;
 def warn_opencl_generic_address_space_arg : Warning<
   "passing non-generic address space pointer to %0"
   " may cause dynamic conversion affecting performance">,
   InGroup<Conversion>, DefaultIgnore;
 
 // OpenCL v2.0 s6.13.6 -- Builtin Pipe Functions
 def err_opencl_builtin_pipe_first_arg : Error<
   "first argument to %0 must be a pipe type">;

clang/include/clang/Basic/OpenCLOptions.h

bool isOptionalCoreIn(const LangOptions &LO) const {
       return isAvailableIn(LO) && isOpenCLVersionIsContainedInMask(LO, Opt);
     }
   };
 
   bool isKnown(llvm::StringRef Ext) const;
 
   bool isEnabled(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;
 
   // Is supported OpenCL core feature for OpenCL version \p LO.
   // For supported extension, return false.
   bool isSupportedCore(llvm::StringRef Ext, const LangOptions &LO) const;
 
void addSupport(const llvm::StringMap<bool> &FeaturesMap,
                   const LangOptions &Opts);
 
   // Disable all extensions
   void disableAll();
 
   // Enable supported core and optional core features
   void enableSupportedCore(const LangOptions &LO);
 
+  // Is OpenCL C feature (OpenCL C 3.0, 6.2.1. Features)
+  bool isFeature(llvm::StringRef Ext) const;
+
   friend class ASTWriter;
   friend class ASTReader;
 
   using OpenCLOptionInfoMap = llvm::StringMap<OpenCLOptionInfo>;
 
 private:
   OpenCLOptionInfoMap OptMap;
 };
 
 } // end namespace clang
 
 #endif

clang/lib/Basic/OpenCLOptions.cpp

bool OpenCLOptions::isKnown(llvm::StringRef Ext) const {
   return OptMap.find(Ext) != OptMap.end();
 }
 
 bool OpenCLOptions::isEnabled(llvm::StringRef Ext) const {
   auto E = OptMap.find(Ext);
   return E != OptMap.end() && E->second.Enabled;
 }
 
+bool OpenCLOptions::isFP64Enabled(const LangOptions &LO) const {
+  auto CLVer = LO.OpenCLCPlusPlus ? 200 : LO.OpenCLVersion;
+  return CLVer >= 300 ? isEnabled("__opencl_c_fp64") : isEnabled("cl_khr_fp64");
+}
+
 bool OpenCLOptions::isSupported(llvm::StringRef Ext,
                                 const LangOptions &LO) const {
   auto E = OptMap.find(Ext);
   if (E == OptMap.end()) {
     return false;
   }
   auto I = OptMap.find(Ext)->getValue();
   return I.Supported && I.isAvailableIn(LO);

 }
 
 void OpenCLOptions::enableSupportedCore(const LangOptions &LO) {
   for (auto &Opt : OptMap)
     if (isSupportedCoreOrOptionalCore(Opt.getKey(), LO))
       Opt.getValue().Enabled = true;
 }
 
+bool OpenCLOptions::isFeature(llvm::StringRef Ext) const {
+  auto E = OptMap.find(Ext);
+  if (E == OptMap.end())
+    return false;
+  return Ext.startswith("__opencl_c") &&
+         (E->getValue().isCore() || E->getValue().isOptionalCore());
+}
+
 } // end namespace clang

clang/lib/Basic/TargetInfo.cpp

if (Opts.OpenCL) {
     IntPtrType = Is32BitArch ? SignedInt : SignedLong;
 
     IntMaxType = SignedLongLong;
     Int64Type = SignedLong;
 
     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) {
     if (Opts.DoubleSize == 32) {
       DoubleWidth = 32;
       LongDoubleWidth = 32;
       DoubleFormat = &llvm::APFloat::IEEEsingle();
       LongDoubleFormat = &llvm::APFloat::IEEEsingle();

clang/lib/Basic/Targets/AMDGPU.h

void setSupportedOpenCLOpts() override {
     auto &Opts = getSupportedOpenCLOpts();
     Opts["cl_clang_storage_class_specifiers"] = true;
     Opts["__cl_clang_variadic_functions"] = true;
     Opts["__cl_clang_function_pointers"] = true;
 
     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;
       Opts["cl_khr_global_int32_base_atomics"] = true;
       Opts["cl_khr_global_int32_extended_atomics"] = true;
       Opts["cl_khr_local_int32_base_atomics"] = true;
       Opts["cl_khr_local_int32_extended_atomics"] = true;
     }

clang/lib/Basic/Targets/NVPTX.h

public:
 
   void setSupportedOpenCLOpts() override {
     auto &Opts = getSupportedOpenCLOpts();
     Opts["cl_clang_storage_class_specifiers"] = true;
     Opts["__cl_clang_function_pointers"] = true;
     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;
     Opts["cl_khr_local_int32_base_atomics"] = true;
     Opts["cl_khr_local_int32_extended_atomics"] = true;
   }
 
   /// \returns If a target requires an address within a target specific address

clang/lib/Headers/opencl-c.h

 float16 __ovld __cnfn convert_float16_rte(float16);
 float16 __ovld __cnfn convert_float16_rtz(float16);
 float16 __ovld __cnfn convert_float16_rtp(float16);
 float16 __ovld __cnfn convert_float16_rtn(float16);
 float16 __ovld __cnfn convert_float16(float16);
 
 // 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);
 char __ovld __cnfn convert_char_rtn(double);
 char __ovld __cnfn convert_char_rtp(double);
 char __ovld __cnfn convert_char_rtz(double);
 char __ovld __cnfn convert_char_sat(double);
 char __ovld __cnfn convert_char_sat_rte(double);

 double16 __ovld __cnfn convert_double16_rtz(float16);
 double16 __ovld __cnfn convert_double16_rtz(int16);
 double16 __ovld __cnfn convert_double16_rtz(long16);
 double16 __ovld __cnfn convert_double16_rtz(short16);
 double16 __ovld __cnfn convert_double16_rtz(uchar16);
 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
 // Convert half types to non-double types.
 uchar __ovld __cnfn convert_uchar(half);
 uchar __ovld __cnfn convert_uchar_rte(half);
 uchar __ovld __cnfn convert_uchar_rtp(half);
 uchar __ovld __cnfn convert_uchar_rtn(half);

 half16 __ovld __cnfn convert_half16_rtz(int16);
 half16 __ovld __cnfn convert_half16_rtz(uint16);
 half16 __ovld __cnfn convert_half16_rtz(long16);
 half16 __ovld __cnfn convert_half16_rtz(ulong16);
 half16 __ovld __cnfn convert_half16_rtz(float16);
 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);
 double __ovld __cnfn convert_double_rtn(half);
 double __ovld __cnfn convert_double_rtz(half);
 double2 __ovld __cnfn convert_double2(half2);
 double2 __ovld __cnfn convert_double2_rte(half2);
 double2 __ovld __cnfn convert_double2_rtp(half2);

 half8 __ovld __cnfn convert_half8_rtp(double8);
 half8 __ovld __cnfn convert_half8_rtn(double8);
 half8 __ovld __cnfn convert_half8_rtz(double8);
 half16 __ovld __cnfn convert_half16(double16);
 half16 __ovld __cnfn convert_half16_rte(double16);
 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
 
 /**
  * OpenCL v1.1/1.2/2.0 s6.2.4.2 - as_type operators
  * Reinterprets a data type as another data type of the same size
  */
 #define as_char(x) __builtin_astype((x),   char)

 
 #define as_float(x) __builtin_astype((x),   float)
 #define as_float2(x) __builtin_astype((x),  float2)
 #define as_float3(x) __builtin_astype((x),  float3)
 #define as_float4(x) __builtin_astype((x),  float4)
 #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)
 #define as_half2(x) __builtin_astype((x),  half2)
 #define as_half3(x) __builtin_astype((x),  half3)
 #define as_half4(x) __builtin_astype((x),  half4)
 #define as_half8(x) __builtin_astype((x),  half8)
 #define as_half16(x) __builtin_astype((x), half16)

  * Arc cosine function.
  */
 float __ovld __cnfn acos(float);
 float2 __ovld __cnfn acos(float2);
 float3 __ovld __cnfn acos(float3);
 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);
 half3 __ovld __cnfn acos(half3);
 half4 __ovld __cnfn acos(half4);
 half8 __ovld __cnfn acos(half8);
 half16 __ovld __cnfn acos(half16);
 #endif //cl_khr_fp16
 
 /**
  * Inverse hyperbolic cosine.
  */
 float __ovld __cnfn acosh(float);
 float2 __ovld __cnfn acosh(float2);
 float3 __ovld __cnfn acosh(float3);
 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);
 half3 __ovld __cnfn acosh(half3);
 half4 __ovld __cnfn acosh(half4);
 half8 __ovld __cnfn acosh(half8);
 half16 __ovld __cnfn acosh(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute acos (x) / PI.
  */
 float __ovld __cnfn acospi(float x);
 float2 __ovld __cnfn acospi(float2 x);
 float3 __ovld __cnfn acospi(float3 x);
 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);
 half3 __ovld __cnfn acospi(half3 x);
 half4 __ovld __cnfn acospi(half4 x);
 half8 __ovld __cnfn acospi(half8 x);
 half16 __ovld __cnfn acospi(half16 x);
 #endif //cl_khr_fp16
 
 /**
  * Arc sine function.
  */
 float __ovld __cnfn asin(float);
 float2 __ovld __cnfn asin(float2);
 float3 __ovld __cnfn asin(float3);
 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);
 half3 __ovld __cnfn asin(half3);
 half4 __ovld __cnfn asin(half4);
 half8 __ovld __cnfn asin(half8);
 half16 __ovld __cnfn asin(half16);
 #endif //cl_khr_fp16
 
 /**
  * Inverse hyperbolic sine.
  */
 float __ovld __cnfn asinh(float);
 float2 __ovld __cnfn asinh(float2);
 float3 __ovld __cnfn asinh(float3);
 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);
 half3 __ovld __cnfn asinh(half3);
 half4 __ovld __cnfn asinh(half4);
 half8 __ovld __cnfn asinh(half8);
 half16 __ovld __cnfn asinh(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute asin (x) / PI.
  */
 float __ovld __cnfn asinpi(float x);
 float2 __ovld __cnfn asinpi(float2 x);
 float3 __ovld __cnfn asinpi(float3 x);
 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);
 half3 __ovld __cnfn asinpi(half3 x);
 half4 __ovld __cnfn asinpi(half4 x);
 half8 __ovld __cnfn asinpi(half8 x);
 half16 __ovld __cnfn asinpi(half16 x);
 #endif //cl_khr_fp16
 
 /**
  * Arc tangent function.
  */
 float __ovld __cnfn atan(float y_over_x);
 float2 __ovld __cnfn atan(float2 y_over_x);
 float3 __ovld __cnfn atan(float3 y_over_x);
 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);
 half3 __ovld __cnfn atan(half3 y_over_x);
 half4 __ovld __cnfn atan(half4 y_over_x);
 half8 __ovld __cnfn atan(half8 y_over_x);
 half16 __ovld __cnfn atan(half16 y_over_x);
 #endif //cl_khr_fp16
 
 /**
  * Arc tangent of y / x.
  */
 float __ovld __cnfn atan2(float y, float x);
 float2 __ovld __cnfn atan2(float2 y, float2 x);
 float3 __ovld __cnfn atan2(float3 y, float3 x);
 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);
 half3 __ovld __cnfn atan2(half3 y, half3 x);
 half4 __ovld __cnfn atan2(half4 y, half4 x);
 half8 __ovld __cnfn atan2(half8 y, half8 x);
 half16 __ovld __cnfn atan2(half16 y, half16 x);
 #endif //cl_khr_fp16
 
 /**
  * Hyperbolic arc tangent.
  */
 float __ovld __cnfn atanh(float);
 float2 __ovld __cnfn atanh(float2);
 float3 __ovld __cnfn atanh(float3);
 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);
 half3 __ovld __cnfn atanh(half3);
 half4 __ovld __cnfn atanh(half4);
 half8 __ovld __cnfn atanh(half8);
 half16 __ovld __cnfn atanh(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute atan (x) / PI.
  */
 float __ovld __cnfn atanpi(float x);
 float2 __ovld __cnfn atanpi(float2 x);
 float3 __ovld __cnfn atanpi(float3 x);
 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);
 half3 __ovld __cnfn atanpi(half3 x);
 half4 __ovld __cnfn atanpi(half4 x);
 half8 __ovld __cnfn atanpi(half8 x);
 half16 __ovld __cnfn atanpi(half16 x);
 #endif //cl_khr_fp16
 
 /**
  * Compute atan2 (y, x) / PI.
  */
 float __ovld __cnfn atan2pi(float y, float x);
 float2 __ovld __cnfn atan2pi(float2 y, float2 x);
 float3 __ovld __cnfn atan2pi(float3 y, float3 x);
 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);
 half3 __ovld __cnfn atan2pi(half3 y, half3 x);
 half4 __ovld __cnfn atan2pi(half4 y, half4 x);
 half8 __ovld __cnfn atan2pi(half8 y, half8 x);
 half16 __ovld __cnfn atan2pi(half16 y, half16 x);
 #endif //cl_khr_fp16
 
 /**
  * Compute cube-root.
  */
 float __ovld __cnfn cbrt(float);
 float2 __ovld __cnfn cbrt(float2);
 float3 __ovld __cnfn cbrt(float3);
 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);
 half3 __ovld __cnfn cbrt(half3);
 half4 __ovld __cnfn cbrt(half4);
 half8 __ovld __cnfn cbrt(half8);
 half16 __ovld __cnfn cbrt(half16);
 #endif //cl_khr_fp16
 
 /**
  * Round to integral value using the round to positive
  * infinity rounding mode.
  */
 float __ovld __cnfn ceil(float);
 float2 __ovld __cnfn ceil(float2);
 float3 __ovld __cnfn ceil(float3);
 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);
 half3 __ovld __cnfn ceil(half3);
 half4 __ovld __cnfn ceil(half4);
 half8 __ovld __cnfn ceil(half8);
 half16 __ovld __cnfn ceil(half16);
 #endif //cl_khr_fp16
 
 /**
  * Returns x with its sign changed to match the sign of y.
  */
 float __ovld __cnfn copysign(float x, float y);
 float2 __ovld __cnfn copysign(float2 x, float2 y);
 float3 __ovld __cnfn copysign(float3 x, float3 y);
 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);
 half3 __ovld __cnfn copysign(half3 x, half3 y);
 half4 __ovld __cnfn copysign(half4 x, half4 y);
 half8 __ovld __cnfn copysign(half8 x, half8 y);
 half16 __ovld __cnfn copysign(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Compute cosine.
  */
 float __ovld __cnfn cos(float);
 float2 __ovld __cnfn cos(float2);
 float3 __ovld __cnfn cos(float3);
 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);
 half3 __ovld __cnfn cos(half3);
 half4 __ovld __cnfn cos(half4);
 half8 __ovld __cnfn cos(half8);
 half16 __ovld __cnfn cos(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute hyperbolic cosine.
  */
 float __ovld __cnfn cosh(float);
 float2 __ovld __cnfn cosh(float2);
 float3 __ovld __cnfn cosh(float3);
 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);
 half3 __ovld __cnfn cosh(half3);
 half4 __ovld __cnfn cosh(half4);
 half8 __ovld __cnfn cosh(half8);
 half16 __ovld __cnfn cosh(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute cos (PI * x).
  */
 float __ovld __cnfn cospi(float x);
 float2 __ovld __cnfn cospi(float2 x);
 float3 __ovld __cnfn cospi(float3 x);
 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);
 half3 __ovld __cnfn cospi(half3 x);
 half4 __ovld __cnfn cospi(half4 x);
 half8 __ovld __cnfn cospi(half8 x);
 half16 __ovld __cnfn cospi(half16 x);
 #endif //cl_khr_fp16
 
 /**
  * Complementary error function.
  */
 float __ovld __cnfn erfc(float);
 float2 __ovld __cnfn erfc(float2);
 float3 __ovld __cnfn erfc(float3);
 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);
 half3 __ovld __cnfn erfc(half3);
 half4 __ovld __cnfn erfc(half4);
 half8 __ovld __cnfn erfc(half8);
 half16 __ovld __cnfn erfc(half16);
 #endif //cl_khr_fp16
 
 /**
  * Error function encountered in integrating the
  * normal distribution.
  */
 float __ovld __cnfn erf(float);
 float2 __ovld __cnfn erf(float2);
 float3 __ovld __cnfn erf(float3);
 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);
 half3 __ovld __cnfn erf(half3);
 half4 __ovld __cnfn erf(half4);
 half8 __ovld __cnfn erf(half8);
 half16 __ovld __cnfn erf(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute the base e exponential function of x.
  */
 float __ovld __cnfn exp(float x);
 float2 __ovld __cnfn exp(float2 x);
 float3 __ovld __cnfn exp(float3 x);
 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);
 half3 __ovld __cnfn exp(half3 x);
 half4 __ovld __cnfn exp(half4 x);
 half8 __ovld __cnfn exp(half8 x);
 half16 __ovld __cnfn exp(half16 x);
 #endif //cl_khr_fp16
 
 /**
  * Exponential base 2 function.
  */
 float __ovld __cnfn exp2(float);
 float2 __ovld __cnfn exp2(float2);
 float3 __ovld __cnfn exp2(float3);
 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);
 half3 __ovld __cnfn exp2(half3);
 half4 __ovld __cnfn exp2(half4);
 half8 __ovld __cnfn exp2(half8);
 half16 __ovld __cnfn exp2(half16);
 #endif //cl_khr_fp16
 
 /**
  * Exponential base 10 function.
  */
 float __ovld __cnfn exp10(float);
 float2 __ovld __cnfn exp10(float2);
 float3 __ovld __cnfn exp10(float3);
 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);
 half3 __ovld __cnfn exp10(half3);
 half4 __ovld __cnfn exp10(half4);
 half8 __ovld __cnfn exp10(half8);
 half16 __ovld __cnfn exp10(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute e^x- 1.0.
  */
 float __ovld __cnfn expm1(float x);
 float2 __ovld __cnfn expm1(float2 x);
 float3 __ovld __cnfn expm1(float3 x);
 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);
 half3 __ovld __cnfn expm1(half3 x);
 half4 __ovld __cnfn expm1(half4 x);
 half8 __ovld __cnfn expm1(half8 x);
 half16 __ovld __cnfn expm1(half16 x);
 #endif //cl_khr_fp16
 
 /**
  * Compute absolute value of a floating-point number.
  */
 float __ovld __cnfn fabs(float);
 float2 __ovld __cnfn fabs(float2);
 float3 __ovld __cnfn fabs(float3);
 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);
 half3 __ovld __cnfn fabs(half3);
 half4 __ovld __cnfn fabs(half4);
 half8 __ovld __cnfn fabs(half8);
 half16 __ovld __cnfn fabs(half16);
 #endif //cl_khr_fp16
 
 /**
  * x - y if x > y, +0 if x is less than or equal to y.
  */
 float __ovld __cnfn fdim(float x, float y);
 float2 __ovld __cnfn fdim(float2 x, float2 y);
 float3 __ovld __cnfn fdim(float3 x, float3 y);
 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);
 half3 __ovld __cnfn fdim(half3 x, half3 y);
 half4 __ovld __cnfn fdim(half4 x, half4 y);
 half8 __ovld __cnfn fdim(half8 x, half8 y);
 half16 __ovld __cnfn fdim(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Round to integral value using the round to -ve
  * infinity rounding mode.
  */
 float __ovld __cnfn floor(float);
 float2 __ovld __cnfn floor(float2);
 float3 __ovld __cnfn floor(float3);
 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);
 half3 __ovld __cnfn floor(half3);
 half4 __ovld __cnfn floor(half4);
 half8 __ovld __cnfn floor(half8);
 half16 __ovld __cnfn floor(half16);
 #endif //cl_khr_fp16
 
 /**
  * Returns the correctly rounded floating-point
  * representation of the sum of c with the infinitely
  * precise product of a and b. Rounding of
  * intermediate products shall not occur. Edge case
  * behavior is per the IEEE 754-2008 standard.
  */
 float __ovld __cnfn fma(float a, float b, float c);
 float2 __ovld __cnfn fma(float2 a, float2 b, float2 c);
 float3 __ovld __cnfn fma(float3 a, float3 b, float3 c);
 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);
 half3 __ovld __cnfn fma(half3 a, half3 b, half3 c);
 half4 __ovld __cnfn fma(half4 a, half4 b, half4 c);
 half8 __ovld __cnfn fma(half8 a, half8 b, half8 c);
 half16 __ovld __cnfn fma(half16 a, half16 b, half16 c);
 #endif //cl_khr_fp16

 float4 __ovld __cnfn fmax(float4 x, float4 y);
 float8 __ovld __cnfn fmax(float8 x, float8 y);
 float16 __ovld __cnfn fmax(float16 x, float16 y);
 float2 __ovld __cnfn fmax(float2 x, float y);
 float3 __ovld __cnfn fmax(float3 x, float y);
 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);
 double4 __ovld __cnfn fmax(double4 x, double4 y);
 double8 __ovld __cnfn fmax(double8 x, double8 y);
 double16 __ovld __cnfn fmax(double16 x, double16 y);
 double2 __ovld __cnfn fmax(double2 x, double y);
 double3 __ovld __cnfn fmax(double3 x, double y);
 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);
 half3 __ovld __cnfn fmax(half3 x, half3 y);
 half4 __ovld __cnfn fmax(half4 x, half4 y);
 half8 __ovld __cnfn fmax(half8 x, half8 y);
 half16 __ovld __cnfn fmax(half16 x, half16 y);
 half2 __ovld __cnfn fmax(half2 x, half y);

 float4 __ovld __cnfn fmin(float4 x, float4 y);
 float8 __ovld __cnfn fmin(float8 x, float8 y);
 float16 __ovld __cnfn fmin(float16 x, float16 y);
 float2 __ovld __cnfn fmin(float2 x, float y);
 float3 __ovld __cnfn fmin(float3 x, float y);
 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);
 double4 __ovld __cnfn fmin(double4 x, double4 y);
 double8 __ovld __cnfn fmin(double8 x, double8 y);
 double16 __ovld __cnfn fmin(double16 x, double16 y);
 double2 __ovld __cnfn fmin(double2 x, double y);
 double3 __ovld __cnfn fmin(double3 x, double y);
 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);
 half3 __ovld __cnfn fmin(half3 x, half3 y);
 half4 __ovld __cnfn fmin(half4 x, half4 y);
 half8 __ovld __cnfn fmin(half8 x, half8 y);
 half16 __ovld __cnfn fmin(half16 x, half16 y);
 half2 __ovld __cnfn fmin(half2 x, half y);
 half3 __ovld __cnfn fmin(half3 x, half y);
 half4 __ovld __cnfn fmin(half4 x, half y);
 half8 __ovld __cnfn fmin(half8 x, half y);
 half16 __ovld __cnfn fmin(half16 x, half y);
 #endif //cl_khr_fp16
 
 /**
  * Modulus. Returns x - y * trunc (x/y).
  */
 float __ovld __cnfn fmod(float x, float y);
 float2 __ovld __cnfn fmod(float2 x, float2 y);
 float3 __ovld __cnfn fmod(float3 x, float3 y);
 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);
 half3 __ovld __cnfn fmod(half3 x, half3 y);
 half4 __ovld __cnfn fmod(half4 x, half4 y);
 half8 __ovld __cnfn fmod(half8 x, half8 y);
 half16 __ovld __cnfn fmod(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Returns fmin(x - floor (x), 0x1.fffffep-1f ).
  * floor(x) is returned in iptr.
  */
 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 float __ovld fract(float x, float *iptr);
 float2 __ovld fract(float2 x, float2 *iptr);
 float3 __ovld fract(float3 x, float3 *iptr);
 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);
 half3 __ovld fract(half3 x, half3 *iptr);
 half4 __ovld fract(half4 x, half4 *iptr);
 half8 __ovld fract(half8 x, half8 *iptr);
 half16 __ovld fract(half16 x, half16 *iptr);
 #endif //cl_khr_fp16

 float8 __ovld fract(float8 x, __local float8 *iptr);
 float16 __ovld fract(float16 x, __local float16 *iptr);
 float __ovld fract(float x, __private float *iptr);
 float2 __ovld fract(float2 x, __private float2 *iptr);
 float3 __ovld fract(float3 x, __private float3 *iptr);
 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);
 double4 __ovld fract(double4 x, __global double4 *iptr);
 double8 __ovld fract(double8 x, __global double8 *iptr);
 double16 __ovld fract(double16 x, __global double16 *iptr);
 double __ovld fract(double x, __local double *iptr);
 double2 __ovld fract(double2 x, __local double2 *iptr);
 double3 __ovld fract(double3 x, __local double3 *iptr);
 double4 __ovld fract(double4 x, __local double4 *iptr);
 double8 __ovld fract(double8 x, __local double8 *iptr);
 double16 __ovld fract(double16 x, __local double16 *iptr);
 double __ovld fract(double x, __private double *iptr);
 double2 __ovld fract(double2 x, __private double2 *iptr);
 double3 __ovld fract(double3 x, __private double3 *iptr);
 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);
 half3 __ovld fract(half3 x, __global half3 *iptr);
 half4 __ovld fract(half4 x, __global half4 *iptr);
 half8 __ovld fract(half8 x, __global half8 *iptr);
 half16 __ovld fract(half16 x, __global half16 *iptr);
 half __ovld fract(half x, __local half *iptr);

  */
 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 float __ovld frexp(float x, int *exp);
 float2 __ovld frexp(float2 x, int2 *exp);
 float3 __ovld frexp(float3 x, int3 *exp);
 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);
 half3 __ovld frexp(half3 x, int3 *exp);
 half4 __ovld frexp(half4 x, int4 *exp);
 half8 __ovld frexp(half8 x, int8 *exp);
 half16 __ovld frexp(half16 x, int16 *exp);
 #endif //cl_khr_fp16

 float8 __ovld frexp(float8 x, __local int8 *exp);
 float16 __ovld frexp(float16 x, __local int16 *exp);
 float __ovld frexp(float x, __private int *exp);
 float2 __ovld frexp(float2 x, __private int2 *exp);
 float3 __ovld frexp(float3 x, __private int3 *exp);
 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);
 double4 __ovld frexp(double4 x, __global int4 *exp);
 double8 __ovld frexp(double8 x, __global int8 *exp);
 double16 __ovld frexp(double16 x, __global int16 *exp);
 double __ovld frexp(double x, __local int *exp);
 double2 __ovld frexp(double2 x, __local int2 *exp);
 double3 __ovld frexp(double3 x, __local int3 *exp);
 double4 __ovld frexp(double4 x, __local int4 *exp);
 double8 __ovld frexp(double8 x, __local int8 *exp);
 double16 __ovld frexp(double16 x, __local int16 *exp);
 double __ovld frexp(double x, __private int *exp);
 double2 __ovld frexp(double2 x, __private int2 *exp);
 double3 __ovld frexp(double3 x, __private int3 *exp);
 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);
 half3 __ovld frexp(half3 x, __global int3 *exp);
 half4 __ovld frexp(half4 x, __global int4 *exp);
 half8 __ovld frexp(half8 x, __global int8 *exp);
 half16 __ovld frexp(half16 x, __global int16 *exp);
 half __ovld frexp(half x, __local int *exp);

  * without undue overflow or underflow.
  */
 float __ovld __cnfn hypot(float x, float y);
 float2 __ovld __cnfn hypot(float2 x, float2 y);
 float3 __ovld __cnfn hypot(float3 x, float3 y);
 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);
 half3 __ovld __cnfn hypot(half3 x, half3 y);
 half4 __ovld __cnfn hypot(half4 x, half4 y);
 half8 __ovld __cnfn hypot(half8 x, half8 y);
 half16 __ovld __cnfn hypot(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Return the exponent as an integer value.
  */
 int __ovld __cnfn ilogb(float x);
 int2 __ovld __cnfn ilogb(float2 x);
 int3 __ovld __cnfn ilogb(float3 x);
 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);
 int3 __ovld __cnfn ilogb(half3 x);
 int4 __ovld __cnfn ilogb(half4 x);
 int8 __ovld __cnfn ilogb(half8 x);
 int16 __ovld __cnfn ilogb(half16 x);
 #endif //cl_khr_fp16
 
 /**
  * Multiply x by 2 to the power n.
  */
 float __ovld __cnfn ldexp(float x, int n);
 float2 __ovld __cnfn ldexp(float2 x, int2 n);
 float3 __ovld __cnfn ldexp(float3 x, int3 n);
 float4 __ovld __cnfn ldexp(float4 x, int4 n);
 float8 __ovld __cnfn ldexp(float8 x, int8 n);
 float16 __ovld __cnfn ldexp(float16 x, int16 n);
 float2 __ovld __cnfn ldexp(float2 x, int n);
 float3 __ovld __cnfn ldexp(float3 x, int n);
 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);
 double4 __ovld __cnfn ldexp(double4 x, int4 n);
 double8 __ovld __cnfn ldexp(double8 x, int8 n);
 double16 __ovld __cnfn ldexp(double16 x, int16 n);
 double2 __ovld __cnfn ldexp(double2 x, int n);
 double3 __ovld __cnfn ldexp(double3 x, int n);
 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);
 half3 __ovld __cnfn ldexp(half3 x, int3 n);
 half4 __ovld __cnfn ldexp(half4 x, int4 n);
 half8 __ovld __cnfn ldexp(half8 x, int8 n);
 half16 __ovld __cnfn ldexp(half16 x, int16 n);
 half2 __ovld __cnfn ldexp(half2 x, int n);

  * returned in the signp argument of lgamma_r.
  */
 float __ovld __cnfn lgamma(float x);
 float2 __ovld __cnfn lgamma(float2 x);
 float3 __ovld __cnfn lgamma(float3 x);
 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);
 half3 __ovld __cnfn lgamma(half3 x);
 half4 __ovld __cnfn lgamma(half4 x);
 half8 __ovld __cnfn lgamma(half8 x);
 half16 __ovld __cnfn lgamma(half16 x);
 #endif //cl_khr_fp16
 
 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 float __ovld lgamma_r(float x, int *signp);
 float2 __ovld lgamma_r(float2 x, int2 *signp);
 float3 __ovld lgamma_r(float3 x, int3 *signp);
 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);
 half3 __ovld lgamma_r(half3 x, int3 *signp);
 half4 __ovld lgamma_r(half4 x, int4 *signp);
 half8 __ovld lgamma_r(half8 x, int8 *signp);
 half16 __ovld lgamma_r(half16 x, int16 *signp);
 #endif //cl_khr_fp16

 float8 __ovld lgamma_r(float8 x, __local int8 *signp);
 float16 __ovld lgamma_r(float16 x, __local int16 *signp);
 float __ovld lgamma_r(float x, __private int *signp);
 float2 __ovld lgamma_r(float2 x, __private int2 *signp);
 float3 __ovld lgamma_r(float3 x, __private int3 *signp);
 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);
 double4 __ovld lgamma_r(double4 x, __global int4 *signp);
 double8 __ovld lgamma_r(double8 x, __global int8 *signp);
 double16 __ovld lgamma_r(double16 x, __global int16 *signp);
 double __ovld lgamma_r(double x, __local int *signp);
 double2 __ovld lgamma_r(double2 x, __local int2 *signp);
 double3 __ovld lgamma_r(double3 x, __local int3 *signp);
 double4 __ovld lgamma_r(double4 x, __local int4 *signp);
 double8 __ovld lgamma_r(double8 x, __local int8 *signp);
 double16 __ovld lgamma_r(double16 x, __local int16 *signp);
 double __ovld lgamma_r(double x, __private int *signp);
 double2 __ovld lgamma_r(double2 x, __private int2 *signp);
 double3 __ovld lgamma_r(double3 x, __private int3 *signp);
 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);
 half3 __ovld lgamma_r(half3 x, __global int3 *signp);
 half4 __ovld lgamma_r(half4 x, __global int4 *signp);
 half8 __ovld lgamma_r(half8 x, __global int8 *signp);
 half16 __ovld lgamma_r(half16 x, __global int16 *signp);
 half __ovld lgamma_r(half x, __local int *signp);

  * Compute natural logarithm.
  */
 float __ovld __cnfn log(float);
 float2 __ovld __cnfn log(float2);
 float3 __ovld __cnfn log(float3);
 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);
 half3 __ovld __cnfn log(half3);
 half4 __ovld __cnfn log(half4);
 half8 __ovld __cnfn log(half8);
 half16 __ovld __cnfn log(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute a base 2 logarithm.
  */
 float __ovld __cnfn log2(float);
 float2 __ovld __cnfn log2(float2);
 float3 __ovld __cnfn log2(float3);
 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);
 half3 __ovld __cnfn log2(half3);
 half4 __ovld __cnfn log2(half4);
 half8 __ovld __cnfn log2(half8);
 half16 __ovld __cnfn log2(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute a base 10 logarithm.
  */
 float __ovld __cnfn log10(float);
 float2 __ovld __cnfn log10(float2);
 float3 __ovld __cnfn log10(float3);
 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);
 half3 __ovld __cnfn log10(half3);
 half4 __ovld __cnfn log10(half4);
 half8 __ovld __cnfn log10(half8);
 half16 __ovld __cnfn log10(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute a base e logarithm of (1.0 + x).
  */
 float __ovld __cnfn log1p(float x);
 float2 __ovld __cnfn log1p(float2 x);
 float3 __ovld __cnfn log1p(float3 x);
 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);
 half3 __ovld __cnfn log1p(half3 x);
 half4 __ovld __cnfn log1p(half4 x);
 half8 __ovld __cnfn log1p(half8 x);
 half16 __ovld __cnfn log1p(half16 x);
 #endif //cl_khr_fp16
 
 /**
  * Compute the exponent of x, which is the integral
  * part of logr | x |.
  */
 float __ovld __cnfn logb(float x);
 float2 __ovld __cnfn logb(float2 x);
 float3 __ovld __cnfn logb(float3 x);
 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);
 half3 __ovld __cnfn logb(half3 x);
 half4 __ovld __cnfn logb(half4 x);
 half8 __ovld __cnfn logb(half8 x);
 half16 __ovld __cnfn logb(half16 x);
 #endif //cl_khr_fp16
 
 /**
  * mad approximates a * b + c. Whether or how the
  * product of a * b is rounded and how supernormal or
  * subnormal intermediate products are handled is not
  * defined. mad is intended to be used where speed is
  * preferred over accuracy.
  */
 float __ovld __cnfn mad(float a, float b, float c);
 float2 __ovld __cnfn mad(float2 a, float2 b, float2 c);
 float3 __ovld __cnfn mad(float3 a, float3 b, float3 c);
 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);
 half3 __ovld __cnfn mad(half3 a, half3 b, half3 c);
 half4 __ovld __cnfn mad(half4 a, half4 b, half4 c);
 half8 __ovld __cnfn mad(half8 a, half8 b, half8 c);
 half16 __ovld __cnfn mad(half16 a, half16 b, half16 c);
 #endif //cl_khr_fp16
 
 /**
  * Returns x if | x | > | y |, y if | y | > | x |, otherwise
  * fmax(x, y).
  */
 float __ovld __cnfn maxmag(float x, float y);
 float2 __ovld __cnfn maxmag(float2 x, float2 y);
 float3 __ovld __cnfn maxmag(float3 x, float3 y);
 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);
 half3 __ovld __cnfn maxmag(half3 x, half3 y);
 half4 __ovld __cnfn maxmag(half4 x, half4 y);
 half8 __ovld __cnfn maxmag(half8 x, half8 y);
 half16 __ovld __cnfn maxmag(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Returns x if | x | < | y |, y if | y | < | x |, otherwise
  * fmin(x, y).
  */
 float __ovld __cnfn minmag(float x, float y);
 float2 __ovld __cnfn minmag(float2 x, float2 y);
 float3 __ovld __cnfn minmag(float3 x, float3 y);
 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);
 half3 __ovld __cnfn minmag(half3 x, half3 y);
 half4 __ovld __cnfn minmag(half4 x, half4 y);
 half8 __ovld __cnfn minmag(half8 x, half8 y);
 half16 __ovld __cnfn minmag(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Decompose a floating-point number. The modf
  * function breaks the argument x into integral and
  * fractional parts, each of which has the same sign as
  * the argument. It stores the integral part in the object
  * pointed to by iptr.
  */
 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 float __ovld modf(float x, float *iptr);
 float2 __ovld modf(float2 x, float2 *iptr);
 float3 __ovld modf(float3 x, float3 *iptr);
 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);
 half3 __ovld modf(half3 x, half3 *iptr);
 half4 __ovld modf(half4 x, half4 *iptr);
 half8 __ovld modf(half8 x, half8 *iptr);
 half16 __ovld modf(half16 x, half16 *iptr);
 #endif //cl_khr_fp16

 float8 __ovld modf(float8 x, __local float8 *iptr);
 float16 __ovld modf(float16 x, __local float16 *iptr);
 float __ovld modf(float x, __private float *iptr);
 float2 __ovld modf(float2 x, __private float2 *iptr);
 float3 __ovld modf(float3 x, __private float3 *iptr);
 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);
 double4 __ovld modf(double4 x, __global double4 *iptr);
 double8 __ovld modf(double8 x, __global double8 *iptr);
 double16 __ovld modf(double16 x, __global double16 *iptr);
 double __ovld modf(double x, __local double *iptr);
 double2 __ovld modf(double2 x, __local double2 *iptr);
 double3 __ovld modf(double3 x, __local double3 *iptr);
 double4 __ovld modf(double4 x, __local double4 *iptr);
 double8 __ovld modf(double8 x, __local double8 *iptr);
 double16 __ovld modf(double16 x, __local double16 *iptr);
 double __ovld modf(double x, __private double *iptr);
 double2 __ovld modf(double2 x, __private double2 *iptr);
 double3 __ovld modf(double3 x, __private double3 *iptr);
 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);
 half3 __ovld modf(half3 x, __global half3 *iptr);
 half4 __ovld modf(half4 x, __global half4 *iptr);
 half8 __ovld modf(half8 x, __global half8 *iptr);
 half16 __ovld modf(half16 x, __global half16 *iptr);
 half __ovld modf(half x, __local half *iptr);

  * in the significand of the resulting NaN.
  */
 float __ovld __cnfn nan(uint nancode);
 float2 __ovld __cnfn nan(uint2 nancode);
 float3 __ovld __cnfn nan(uint3 nancode);
 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);
 half3 __ovld __cnfn nan(ushort3 nancode);
 half4 __ovld __cnfn nan(ushort4 nancode);
 half8 __ovld __cnfn nan(ushort8 nancode);
 half16 __ovld __cnfn nan(ushort16 nancode);
 #endif //cl_khr_fp16
 
 /**
  * Computes the next representable single-precision
  * floating-point value following x in the direction of
  * y. Thus, if y is less than x, nextafter() returns the
  * largest representable floating-point number less
  * than x.
  */
 float __ovld __cnfn nextafter(float x, float y);
 float2 __ovld __cnfn nextafter(float2 x, float2 y);
 float3 __ovld __cnfn nextafter(float3 x, float3 y);
 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);
 half3 __ovld __cnfn nextafter(half3 x, half3 y);
 half4 __ovld __cnfn nextafter(half4 x, half4 y);
 half8 __ovld __cnfn nextafter(half8 x, half8 y);
 half16 __ovld __cnfn nextafter(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Compute x to the power y.
  */
 float __ovld __cnfn pow(float x, float y);
 float2 __ovld __cnfn pow(float2 x, float2 y);
 float3 __ovld __cnfn pow(float3 x, float3 y);
 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);
 half3 __ovld __cnfn pow(half3 x, half3 y);
 half4 __ovld __cnfn pow(half4 x, half4 y);
 half8 __ovld __cnfn pow(half8 x, half8 y);
 half16 __ovld __cnfn pow(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Compute x to the power y, where y is an integer.
  */
 float __ovld __cnfn pown(float x, int y);
 float2 __ovld __cnfn pown(float2 x, int2 y);
 float3 __ovld __cnfn pown(float3 x, int3 y);
 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);
 half3 __ovld __cnfn pown(half3 x, int3 y);
 half4 __ovld __cnfn pown(half4 x, int4 y);
 half8 __ovld __cnfn pown(half8 x, int8 y);
 half16 __ovld __cnfn pown(half16 x, int16 y);
 #endif //cl_khr_fp16
 
 /**
  * Compute x to the power y, where x is >= 0.
  */
 float __ovld __cnfn powr(float x, float y);
 float2 __ovld __cnfn powr(float2 x, float2 y);
 float3 __ovld __cnfn powr(float3 x, float3 y);
 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);
 half3 __ovld __cnfn powr(half3 x, half3 y);
 half4 __ovld __cnfn powr(half4 x, half4 y);
 half8 __ovld __cnfn powr(half8 x, half8 y);
 half16 __ovld __cnfn powr(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Compute the value r such that r = x - n*y, where n
  * is the integer nearest the exact value of x/y. If there
  * are two integers closest to x/y, n shall be the even
  * one. If r is zero, it is given the same sign as x.
  */
 float __ovld __cnfn remainder(float x, float y);
 float2 __ovld __cnfn remainder(float2 x, float2 y);
 float3 __ovld __cnfn remainder(float3 x, float3 y);
 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);
 half3 __ovld __cnfn remainder(half3 x, half3 y);
 half4 __ovld __cnfn remainder(half4 x, half4 y);
 half8 __ovld __cnfn remainder(half8 x, half8 y);
 half16 __ovld __cnfn remainder(half16 x, half16 y);
 #endif //cl_khr_fp16

  */
 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 float __ovld remquo(float x, float y, int *quo);
 float2 __ovld remquo(float2 x, float2 y, int2 *quo);
 float3 __ovld remquo(float3 x, float3 y, int3 *quo);
 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);
 half3 __ovld remquo(half3 x, half3 y, int3 *quo);
 half4 __ovld remquo(half4 x, half4 y, int4 *quo);
 half8 __ovld remquo(half8 x, half8 y, int8 *quo);
 half16 __ovld remquo(half16 x, half16 y, int16 *quo);
 

 float8 __ovld remquo(float8 x, float8 y, __local int8 *quo);
 float16 __ovld remquo(float16 x, float16 y, __local int16 *quo);
 float __ovld remquo(float x, float y, __private int *quo);
 float2 __ovld remquo(float2 x, float2 y, __private int2 *quo);
 float3 __ovld remquo(float3 x, float3 y, __private int3 *quo);
 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);
 double4 __ovld remquo(double4 x, double4 y, __global int4 *quo);
 double8 __ovld remquo(double8 x, double8 y, __global int8 *quo);
 double16 __ovld remquo(double16 x, double16 y, __global int16 *quo);
 double __ovld remquo(double x, double y, __local int *quo);
 double2 __ovld remquo(double2 x, double2 y, __local int2 *quo);
 double3 __ovld remquo(double3 x, double3 y, __local int3 *quo);
 double4 __ovld remquo(double4 x, double4 y, __local int4 *quo);
 double8 __ovld remquo(double8 x, double8 y, __local int8 *quo);
 double16 __ovld remquo(double16 x, double16 y, __local int16 *quo);
 double __ovld remquo(double x, double y, __private int *quo);
 double2 __ovld remquo(double2 x, double2 y, __private int2 *quo);
 double3 __ovld remquo(double3 x, double3 y, __private int3 *quo);
 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);
 half3 __ovld remquo(half3 x, half3 y, __global int3 *quo);
 half4 __ovld remquo(half4 x, half4 y, __global int4 *quo);
 half8 __ovld remquo(half8 x, half8 y, __global int8 *quo);
 half16 __ovld remquo(half16 x, half16 y, __global int16 *quo);
 half __ovld remquo(half x, half y, __local int *quo);

  * modes.
  */
 float __ovld __cnfn rint(float);
 float2 __ovld __cnfn rint(float2);
 float3 __ovld __cnfn rint(float3);
 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);
 half3 __ovld __cnfn rint(half3);
 half4 __ovld __cnfn rint(half4);
 half8 __ovld __cnfn rint(half8);
 half16 __ovld __cnfn rint(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute x to the power 1/y.
  */
 float __ovld __cnfn rootn(float x, int y);
 float2 __ovld __cnfn rootn(float2 x, int2 y);
 float3 __ovld __cnfn rootn(float3 x, int3 y);
 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);
 half3 __ovld __cnfn rootn(half3 x, int3 y);
 half4 __ovld __cnfn rootn(half4 x, int4 y);
 half8 __ovld __cnfn rootn(half8 x, int8 y);
 half16 __ovld __cnfn rootn(half16 x, int16 y);
 #endif //cl_khr_fp16
 
 /**
  * Return the integral value nearest to x rounding
  * halfway cases away from zero, regardless of the
  * current rounding direction.
  */
 float __ovld __cnfn round(float x);
 float2 __ovld __cnfn round(float2 x);
 float3 __ovld __cnfn round(float3 x);
 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);
 half3 __ovld __cnfn round(half3 x);
 half4 __ovld __cnfn round(half4 x);
 half8 __ovld __cnfn round(half8 x);
 half16 __ovld __cnfn round(half16 x);
 #endif //cl_khr_fp16
 
 /**
  * Compute inverse square root.
  */
 float __ovld __cnfn rsqrt(float);
 float2 __ovld __cnfn rsqrt(float2);
 float3 __ovld __cnfn rsqrt(float3);
 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);
 half3 __ovld __cnfn rsqrt(half3);
 half4 __ovld __cnfn rsqrt(half4);
 half8 __ovld __cnfn rsqrt(half8);
 half16 __ovld __cnfn rsqrt(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute sine.
  */
 float __ovld __cnfn sin(float);
 float2 __ovld __cnfn sin(float2);
 float3 __ovld __cnfn sin(float3);
 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);
 half3 __ovld __cnfn sin(half3);
 half4 __ovld __cnfn sin(half4);
 half8 __ovld __cnfn sin(half8);
 half16 __ovld __cnfn sin(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute sine and cosine of x. The computed sine
  * is the return value and computed cosine is returned
  * in cosval.
  */
 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 float __ovld sincos(float x, float *cosval);
 float2 __ovld sincos(float2 x, float2 *cosval);
 float3 __ovld sincos(float3 x, float3 *cosval);
 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);
 half3 __ovld sincos(half3 x, half3 *cosval);
 half4 __ovld sincos(half4 x, half4 *cosval);
 half8 __ovld sincos(half8 x, half8 *cosval);
 half16 __ovld sincos(half16 x, half16 *cosval);
 #endif //cl_khr_fp16

 float8 __ovld sincos(float8 x, __local float8 *cosval);
 float16 __ovld sincos(float16 x, __local float16 *cosval);
 float __ovld sincos(float x, __private float *cosval);
 float2 __ovld sincos(float2 x, __private float2 *cosval);
 float3 __ovld sincos(float3 x, __private float3 *cosval);
 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);
 double4 __ovld sincos(double4 x, __global double4 *cosval);
 double8 __ovld sincos(double8 x, __global double8 *cosval);
 double16 __ovld sincos(double16 x, __global double16 *cosval);
 double __ovld sincos(double x, __local double *cosval);
 double2 __ovld sincos(double2 x, __local double2 *cosval);
 double3 __ovld sincos(double3 x, __local double3 *cosval);
 double4 __ovld sincos(double4 x, __local double4 *cosval);
 double8 __ovld sincos(double8 x, __local double8 *cosval);
 double16 __ovld sincos(double16 x, __local double16 *cosval);
 double __ovld sincos(double x, __private double *cosval);
 double2 __ovld sincos(double2 x, __private double2 *cosval);
 double3 __ovld sincos(double3 x, __private double3 *cosval);
 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);
 half3 __ovld sincos(half3 x, __global half3 *cosval);
 half4 __ovld sincos(half4 x, __global half4 *cosval);
 half8 __ovld sincos(half8 x, __global half8 *cosval);
 half16 __ovld sincos(half16 x, __global half16 *cosval);
 half __ovld sincos(half x, __local half *cosval);

  * Compute hyperbolic sine.
  */
 float __ovld __cnfn sinh(float);
 float2 __ovld __cnfn sinh(float2);
 float3 __ovld __cnfn sinh(float3);
 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);
 half3 __ovld __cnfn sinh(half3);
 half4 __ovld __cnfn sinh(half4);
 half8 __ovld __cnfn sinh(half8);
 half16 __ovld __cnfn sinh(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute sin (PI * x).
  */
 float __ovld __cnfn sinpi(float x);
 float2 __ovld __cnfn sinpi(float2 x);
 float3 __ovld __cnfn sinpi(float3 x);
 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);
 half3 __ovld __cnfn sinpi(half3 x);
 half4 __ovld __cnfn sinpi(half4 x);
 half8 __ovld __cnfn sinpi(half8 x);
 half16 __ovld __cnfn sinpi(half16 x);
 #endif //cl_khr_fp16
 
 /**
  * Compute square root.
  */
 float __ovld __cnfn sqrt(float);
 float2 __ovld __cnfn sqrt(float2);
 float3 __ovld __cnfn sqrt(float3);
 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);
 half3 __ovld __cnfn sqrt(half3);
 half4 __ovld __cnfn sqrt(half4);
 half8 __ovld __cnfn sqrt(half8);
 half16 __ovld __cnfn sqrt(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute tangent.
  */
 float __ovld __cnfn tan(float);
 float2 __ovld __cnfn tan(float2);
 float3 __ovld __cnfn tan(float3);
 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);
 half3 __ovld __cnfn tan(half3);
 half4 __ovld __cnfn tan(half4);
 half8 __ovld __cnfn tan(half8);
 half16 __ovld __cnfn tan(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute hyperbolic tangent.
  */
 float __ovld __cnfn tanh(float);
 float2 __ovld __cnfn tanh(float2);
 float3 __ovld __cnfn tanh(float3);
 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);
 half3 __ovld __cnfn tanh(half3);
 half4 __ovld __cnfn tanh(half4);
 half8 __ovld __cnfn tanh(half8);
 half16 __ovld __cnfn tanh(half16);
 #endif //cl_khr_fp16
 
 /**
  * Compute tan (PI * x).
  */
 float __ovld __cnfn tanpi(float x);
 float2 __ovld __cnfn tanpi(float2 x);
 float3 __ovld __cnfn tanpi(float3 x);
 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);
 half3 __ovld __cnfn tanpi(half3 x);
 half4 __ovld __cnfn tanpi(half4 x);
 half8 __ovld __cnfn tanpi(half8 x);
 half16 __ovld __cnfn tanpi(half16 x);
 #endif //cl_khr_fp16
 
 /**
  * Compute the gamma function.
  */
 float __ovld __cnfn tgamma(float);
 float2 __ovld __cnfn tgamma(float2);
 float3 __ovld __cnfn tgamma(float3);
 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);
 half3 __ovld __cnfn tgamma(half3);
 half4 __ovld __cnfn tgamma(half4);
 half8 __ovld __cnfn tgamma(half8);
 half16 __ovld __cnfn tgamma(half16);
 #endif //cl_khr_fp16
 
 /**
  * Round to integral value using the round to zero
  * rounding mode.
  */
 float __ovld __cnfn trunc(float);
 float2 __ovld __cnfn trunc(float2);
 float3 __ovld __cnfn trunc(float3);
 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);
 half3 __ovld __cnfn trunc(half3);
 half4 __ovld __cnfn trunc(half4);
 half8 __ovld __cnfn trunc(half8);
 half16 __ovld __cnfn trunc(half16);
 #endif //cl_khr_fp16

 float4 __ovld __cnfn clamp(float4 x, float4 minval, float4 maxval);
 float8 __ovld __cnfn clamp(float8 x, float8 minval, float8 maxval);
 float16 __ovld __cnfn clamp(float16 x, float16 minval, float16 maxval);
 float2 __ovld __cnfn clamp(float2 x, float minval, float maxval);
 float3 __ovld __cnfn clamp(float3 x, float minval, float maxval);
 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);
 double4 __ovld __cnfn clamp(double4 x, double4 minval, double4 maxval);
 double8 __ovld __cnfn clamp(double8 x, double8 minval, double8 maxval);
 double16 __ovld __cnfn clamp(double16 x, double16 minval, double16 maxval);
 double2 __ovld __cnfn clamp(double2 x, double minval, double maxval);
 double3 __ovld __cnfn clamp(double3 x, double minval, double maxval);
 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);
 half3 __ovld __cnfn clamp(half3 x, half3 minval, half3 maxval);
 half4 __ovld __cnfn clamp(half4 x, half4 minval, half4 maxval);
 half8 __ovld __cnfn clamp(half8 x, half8 minval, half8 maxval);
 half16 __ovld __cnfn clamp(half16 x, half16 minval, half16 maxval);
 half2 __ovld __cnfn clamp(half2 x, half minval, half maxval);
 half3 __ovld __cnfn clamp(half3 x, half minval, half maxval);
 half4 __ovld __cnfn clamp(half4 x, half minval, half maxval);
 half8 __ovld __cnfn clamp(half8 x, half minval, half maxval);
 half16 __ovld __cnfn clamp(half16 x, half minval, half maxval);
 #endif //cl_khr_fp16
 
 /**
  * Converts radians to degrees, i.e. (180 / PI) *
  * radians.
  */
 float __ovld __cnfn degrees(float radians);
 float2 __ovld __cnfn degrees(float2 radians);
 float3 __ovld __cnfn degrees(float3 radians);
 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);
 half3 __ovld __cnfn degrees(half3 radians);
 half4 __ovld __cnfn degrees(half4 radians);
 half8 __ovld __cnfn degrees(half8 radians);
 half16 __ovld __cnfn degrees(half16 radians);
 #endif //cl_khr_fp16
 
 /**
  * Returns y if x < y, otherwise it returns x. If x and y
  * are infinite or NaN, the return values are undefined.
  */
 float __ovld __cnfn max(float x, float y);
 float2 __ovld __cnfn max(float2 x, float2 y);
 float3 __ovld __cnfn max(float3 x, float3 y);
 float4 __ovld __cnfn max(float4 x, float4 y);
 float8 __ovld __cnfn max(float8 x, float8 y);
 float16 __ovld __cnfn max(float16 x, float16 y);
 float2 __ovld __cnfn max(float2 x, float y);
 float3 __ovld __cnfn max(float3 x, float y);
 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);
 double4 __ovld __cnfn max(double4 x, double4 y);
 double8 __ovld __cnfn max(double8 x, double8 y);
 double16 __ovld __cnfn max(double16 x, double16 y);
 double2 __ovld __cnfn max(double2 x, double y);
 double3 __ovld __cnfn max(double3 x, double y);
 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);
 half3 __ovld __cnfn max(half3 x, half3 y);
 half4 __ovld __cnfn max(half4 x, half4 y);
 half8 __ovld __cnfn max(half8 x, half8 y);
 half16 __ovld __cnfn max(half16 x, half16 y);
 half2 __ovld __cnfn max(half2 x, half y);

 float4 __ovld __cnfn min(float4 x, float4 y);
 float8 __ovld __cnfn min(float8 x, float8 y);
 float16 __ovld __cnfn min(float16 x, float16 y);
 float2 __ovld __cnfn min(float2 x, float y);
 float3 __ovld __cnfn min(float3 x, float y);
 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);
 double4 __ovld __cnfn min(double4 x, double4 y);
 double8 __ovld __cnfn min(double8 x, double8 y);
 double16 __ovld __cnfn min(double16 x, double16 y);
 double2 __ovld __cnfn min(double2 x, double y);
 double3 __ovld __cnfn min(double3 x, double y);
 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);
 half3 __ovld __cnfn min(half3 x, half3 y);
 half4 __ovld __cnfn min(half4 x, half4 y);
 half8 __ovld __cnfn min(half8 x, half8 y);
 half16 __ovld __cnfn min(half16 x, half16 y);
 half2 __ovld __cnfn min(half2 x, half y);

 float4 __ovld __cnfn mix(float4 x, float4 y, float4 a);
 float8 __ovld __cnfn mix(float8 x, float8 y, float8 a);
 float16 __ovld __cnfn mix(float16 x, float16 y, float16 a);
 float2 __ovld __cnfn mix(float2 x, float2 y, float a);
 float3 __ovld __cnfn mix(float3 x, float3 y, float a);
 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);
 double4 __ovld __cnfn mix(double4 x, double4 y, double4 a);
 double8 __ovld __cnfn mix(double8 x, double8 y, double8 a);
 double16 __ovld __cnfn mix(double16 x, double16 y, double16 a);
 double2 __ovld __cnfn mix(double2 x, double2 y, double a);
 double3 __ovld __cnfn mix(double3 x, double3 y, double a);
 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);
 half3 __ovld __cnfn mix(half3 x, half3 y, half3 a);
 half4 __ovld __cnfn mix(half4 x, half4 y, half4 a);
 half8 __ovld __cnfn mix(half8 x, half8 y, half8 a);
 half16 __ovld __cnfn mix(half16 x, half16 y, half16 a);
 half2 __ovld __cnfn mix(half2 x, half2 y, half a);
 half3 __ovld __cnfn mix(half3 x, half3 y, half a);
 half4 __ovld __cnfn mix(half4 x, half4 y, half a);
 half8 __ovld __cnfn mix(half8 x, half8 y, half a);
 half16 __ovld __cnfn mix(half16 x, half16 y, half a);
 #endif //cl_khr_fp16
 
 /**
  * Converts degrees to radians, i.e. (PI / 180) *
  * degrees.
  */
 float __ovld __cnfn radians(float degrees);
 float2 __ovld __cnfn radians(float2 degrees);
 float3 __ovld __cnfn radians(float3 degrees);
 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);
 half3 __ovld __cnfn radians(half3 degrees);
 half4 __ovld __cnfn radians(half4 degrees);
 half8 __ovld __cnfn radians(half8 degrees);
 half16 __ovld __cnfn radians(half16 degrees);
 #endif //cl_khr_fp16
 
 /**
  * Returns 0.0 if x < edge, otherwise it returns 1.0.
  */
 float __ovld __cnfn step(float edge, float x);
 float2 __ovld __cnfn step(float2 edge, float2 x);
 float3 __ovld __cnfn step(float3 edge, float3 x);
 float4 __ovld __cnfn step(float4 edge, float4 x);
 float8 __ovld __cnfn step(float8 edge, float8 x);
 float16 __ovld __cnfn step(float16 edge, float16 x);
 float2 __ovld __cnfn step(float edge, float2 x);
 float3 __ovld __cnfn step(float edge, float3 x);
 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);
 double4 __ovld __cnfn step(double4 edge, double4 x);
 double8 __ovld __cnfn step(double8 edge, double8 x);
 double16 __ovld __cnfn step(double16 edge, double16 x);
 double2 __ovld __cnfn step(double edge, double2 x);
 double3 __ovld __cnfn step(double edge, double3 x);
 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);
 half3 __ovld __cnfn step(half3 edge, half3 x);
 half4 __ovld __cnfn step(half4 edge, half4 x);
 half8 __ovld __cnfn step(half8 edge, half8 x);
 half16 __ovld __cnfn step(half16 edge, half16 x);
 half2 __ovld __cnfn step(half edge, half2 x);

 float4 __ovld __cnfn smoothstep(float4 edge0, float4 edge1, float4 x);
 float8 __ovld __cnfn smoothstep(float8 edge0, float8 edge1, float8 x);
 float16 __ovld __cnfn smoothstep(float16 edge0, float16 edge1, float16 x);
 float2 __ovld __cnfn smoothstep(float edge0, float edge1, float2 x);
 float3 __ovld __cnfn smoothstep(float edge0, float edge1, float3 x);
 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);
 double4 __ovld __cnfn smoothstep(double4 edge0, double4 edge1, double4 x);
 double8 __ovld __cnfn smoothstep(double8 edge0, double8 edge1, double8 x);
 double16 __ovld __cnfn smoothstep(double16 edge0, double16 edge1, double16 x);
 double2 __ovld __cnfn smoothstep(double edge0, double edge1, double2 x);
 double3 __ovld __cnfn smoothstep(double edge0, double edge1, double3 x);
 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);
 half3 __ovld __cnfn smoothstep(half3 edge0, half3 edge1, half3 x);
 half4 __ovld __cnfn smoothstep(half4 edge0, half4 edge1, half4 x);
 half8 __ovld __cnfn smoothstep(half8 edge0, half8 edge1, half8 x);
 half16 __ovld __cnfn smoothstep(half16 edge0, half16 edge1, half16 x);
 half2 __ovld __cnfn smoothstep(half edge0, half edge1, half2 x);
 half3 __ovld __cnfn smoothstep(half edge0, half edge1, half3 x);
 half4 __ovld __cnfn smoothstep(half edge0, half edge1, half4 x);
 half8 __ovld __cnfn smoothstep(half edge0, half edge1, half8 x);
 half16 __ovld __cnfn smoothstep(half edge0, half edge1, half16 x);
 #endif //cl_khr_fp16
 
 /**
  * Returns 1.0 if x > 0, -0.0 if x = -0.0, +0.0 if x =
  * +0.0, or -1.0 if x < 0. Returns 0.0 if x is a NaN.
  */
 float __ovld __cnfn sign(float x);
 float2 __ovld __cnfn sign(float2 x);
 float3 __ovld __cnfn sign(float3 x);
 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);
 half3 __ovld __cnfn sign(half3 x);
 half4 __ovld __cnfn sign(half4 x);
 half8 __ovld __cnfn sign(half8 x);
 half16 __ovld __cnfn sign(half16 x);
 #endif //cl_khr_fp16
 
 // OpenCL v1.1 s6.11.5, v1.2 s6.12.5, v2.0 s6.13.5 - Geometric Functions
 
 /**
  * Returns the cross product of p0.xyz and p1.xyz. The
  * w component of float4 result returned will be 0.0.
  */
 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);
 #endif //cl_khr_fp16
 
 /**
  * Compute dot product.
  */
 float __ovld __cnfn dot(float p0, float p1);
 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);
 half __ovld __cnfn dot(half3 p0, half3 p1);
 half __ovld __cnfn dot(half4 p0, half4 p1);
 #endif //cl_khr_fp16
 
 /**
  * Returns the distance between p0 and p1. This is
  * calculated as length(p0 - p1).
  */
 float __ovld __cnfn distance(float p0, float p1);
 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);
 half __ovld __cnfn distance(half3 p0, half3 p1);
 half __ovld __cnfn distance(half4 p0, half4 p1);
 #endif //cl_khr_fp16
 
 /**
  * Return the length of vector p, i.e.,
  * sqrt(p.x2 + p.y 2 + ...)
  */
 float __ovld __cnfn length(float p);
 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);
 half __ovld __cnfn length(half3 p);
 half __ovld __cnfn length(half4 p);
 #endif //cl_khr_fp16
 
 /**
  * Returns a vector in the same direction as p but with a
  * length of 1.
  */
 float __ovld __cnfn normalize(float p);
 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);
 half3 __ovld __cnfn normalize(half3 p);
 half4 __ovld __cnfn normalize(half4 p);
 #endif //cl_khr_fp16
 
 /**

  * Returns the component-wise compare of x == y.
  */
 int __ovld __cnfn isequal(float x, float y);
 int2 __ovld __cnfn isequal(float2 x, float2 y);
 int3 __ovld __cnfn isequal(float3 x, float3 y);
 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);
 short3 __ovld __cnfn isequal(half3 x, half3 y);
 short4 __ovld __cnfn isequal(half4 x, half4 y);
 short8 __ovld __cnfn isequal(half8 x, half8 y);
 short16 __ovld __cnfn isequal(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Returns the component-wise compare of x != y.
  */
 int __ovld __cnfn isnotequal(float x, float y);
 int2 __ovld __cnfn isnotequal(float2 x, float2 y);
 int3 __ovld __cnfn isnotequal(float3 x, float3 y);
 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);
 short3 __ovld __cnfn isnotequal(half3 x, half3 y);
 short4 __ovld __cnfn isnotequal(half4 x, half4 y);
 short8 __ovld __cnfn isnotequal(half8 x, half8 y);
 short16 __ovld __cnfn isnotequal(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Returns the component-wise compare of x > y.
  */
 int __ovld __cnfn isgreater(float x, float y);
 int2 __ovld __cnfn isgreater(float2 x, float2 y);
 int3 __ovld __cnfn isgreater(float3 x, float3 y);
 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);
 short3 __ovld __cnfn isgreater(half3 x, half3 y);
 short4 __ovld __cnfn isgreater(half4 x, half4 y);
 short8 __ovld __cnfn isgreater(half8 x, half8 y);
 short16 __ovld __cnfn isgreater(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Returns the component-wise compare of x >= y.
  */
 int __ovld __cnfn isgreaterequal(float x, float y);
 int2 __ovld __cnfn isgreaterequal(float2 x, float2 y);
 int3 __ovld __cnfn isgreaterequal(float3 x, float3 y);
 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);
 short3 __ovld __cnfn isgreaterequal(half3 x, half3 y);
 short4 __ovld __cnfn isgreaterequal(half4 x, half4 y);
 short8 __ovld __cnfn isgreaterequal(half8 x, half8 y);
 short16 __ovld __cnfn isgreaterequal(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Returns the component-wise compare of x < y.
  */
 int __ovld __cnfn isless(float x, float y);
 int2 __ovld __cnfn isless(float2 x, float2 y);
 int3 __ovld __cnfn isless(float3 x, float3 y);
 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);
 short3 __ovld __cnfn isless(half3 x, half3 y);
 short4 __ovld __cnfn isless(half4 x, half4 y);
 short8 __ovld __cnfn isless(half8 x, half8 y);
 short16 __ovld __cnfn isless(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Returns the component-wise compare of x <= y.
  */
 int __ovld __cnfn islessequal(float x, float y);
 int2 __ovld __cnfn islessequal(float2 x, float2 y);
 int3 __ovld __cnfn islessequal(float3 x, float3 y);
 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);
 short3 __ovld __cnfn islessequal(half3 x, half3 y);
 short4 __ovld __cnfn islessequal(half4 x, half4 y);
 short8 __ovld __cnfn islessequal(half8 x, half8 y);
 short16 __ovld __cnfn islessequal(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Returns the component-wise compare of
  * (x < y) || (x > y) .
  */
 int __ovld __cnfn islessgreater(float x, float y);
 int2 __ovld __cnfn islessgreater(float2 x, float2 y);
 int3 __ovld __cnfn islessgreater(float3 x, float3 y);
 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);
 short3 __ovld __cnfn islessgreater(half3 x, half3 y);
 short4 __ovld __cnfn islessgreater(half4 x, half4 y);
 short8 __ovld __cnfn islessgreater(half8 x, half8 y);
 short16 __ovld __cnfn islessgreater(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Test for finite value.
  */
 int __ovld __cnfn isfinite(float);
 int2 __ovld __cnfn isfinite(float2);
 int3 __ovld __cnfn isfinite(float3);
 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);
 short3 __ovld __cnfn isfinite(half3);
 short4 __ovld __cnfn isfinite(half4);
 short8 __ovld __cnfn isfinite(half8);
 short16 __ovld __cnfn isfinite(half16);
 #endif //cl_khr_fp16
 
 /**
  * Test for infinity value (+ve or -ve) .
  */
 int __ovld __cnfn isinf(float);
 int2 __ovld __cnfn isinf(float2);
 int3 __ovld __cnfn isinf(float3);
 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);
 short3 __ovld __cnfn isinf(half3);
 short4 __ovld __cnfn isinf(half4);
 short8 __ovld __cnfn isinf(half8);
 short16 __ovld __cnfn isinf(half16);
 #endif //cl_khr_fp16
 
 /**
  * Test for a NaN.
  */
 int __ovld __cnfn isnan(float);
 int2 __ovld __cnfn isnan(float2);
 int3 __ovld __cnfn isnan(float3);
 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);
 short3 __ovld __cnfn isnan(half3);
 short4 __ovld __cnfn isnan(half4);
 short8 __ovld __cnfn isnan(half8);
 short16 __ovld __cnfn isnan(half16);
 #endif //cl_khr_fp16
 
 /**
  * Test for a normal value.
  */
 int __ovld __cnfn isnormal(float);
 int2 __ovld __cnfn isnormal(float2);
 int3 __ovld __cnfn isnormal(float3);
 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);
 short3 __ovld __cnfn isnormal(half3);
 short4 __ovld __cnfn isnormal(half4);
 short8 __ovld __cnfn isnormal(half8);
 short16 __ovld __cnfn isnormal(half16);
 #endif //cl_khr_fp16
 
 /**
  * Test if arguments are ordered. isordered() takes
  * arguments x and y, and returns the result
  * isequal(x, x) && isequal(y, y).
  */
 int __ovld __cnfn isordered(float x, float y);
 int2 __ovld __cnfn isordered(float2 x, float2 y);
 int3 __ovld __cnfn isordered(float3 x, float3 y);
 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);
 short3 __ovld __cnfn isordered(half3 x, half3 y);
 short4 __ovld __cnfn isordered(half4 x, half4 y);
 short8 __ovld __cnfn isordered(half8 x, half8 y);
 short16 __ovld __cnfn isordered(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Test if arguments are unordered. isunordered()
  * takes arguments x and y, returning non-zero if x or y
  * is NaN, and zero otherwise.
  */
 int __ovld __cnfn isunordered(float x, float y);
 int2 __ovld __cnfn isunordered(float2 x, float2 y);
 int3 __ovld __cnfn isunordered(float3 x, float3 y);
 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);
 short3 __ovld __cnfn isunordered(half3 x, half3 y);
 short4 __ovld __cnfn isunordered(half4 x, half4 y);
 short8 __ovld __cnfn isunordered(half8 x, half8 y);
 short16 __ovld __cnfn isunordered(half16 x, half16 y);
 #endif //cl_khr_fp16
 
 /**
  * Test for sign bit. The scalar version of the function
  * returns a 1 if the sign bit in the float is set else returns
  * 0. The vector version of the function returns the
  * following for each component in floatn: a -1 if the
  * sign bit in the float is set else returns 0.
  */
 int __ovld __cnfn signbit(float);
 int2 __ovld __cnfn signbit(float2);
 int3 __ovld __cnfn signbit(float3);
 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);
 short3 __ovld __cnfn signbit(half3);
 short4 __ovld __cnfn signbit(half4);
 short8 __ovld __cnfn signbit(half8);
 short16 __ovld __cnfn signbit(half16);
 #endif //cl_khr_fp16

 long16 __ovld __cnfn bitselect(long16 a, long16 b, long16 c);
 ulong16 __ovld __cnfn bitselect(ulong16 a, ulong16 b, ulong16 c);
 float __ovld __cnfn bitselect(float a, float b, float c);
 float2 __ovld __cnfn bitselect(float2 a, float2 b, float2 c);
 float3 __ovld __cnfn bitselect(float3 a, float3 b, float3 c);
 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);
 half3 __ovld __cnfn bitselect(half3 a, half3 b, half3 c);
 half4 __ovld __cnfn bitselect(half4 a, half4 b, half4 c);
 half8 __ovld __cnfn bitselect(half8 a, half8 b, half8 c);
 half16 __ovld __cnfn bitselect(half16 a, half16 b, half16 c);
 #endif //cl_khr_fp16

 ulong3 __ovld __cnfn select(ulong3 a, ulong3 b, ulong3 c);
 long4 __ovld __cnfn select(long4 a, long4 b, ulong4 c);
 ulong4 __ovld __cnfn select(ulong4 a, ulong4 b, ulong4 c);
 long8 __ovld __cnfn select(long8 a, long8 b, ulong8 c);
 ulong8 __ovld __cnfn select(ulong8 a, ulong8 b, ulong8 c);
 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);
 double4 __ovld __cnfn select(double4 a, double4 b, long4 c);
 double8 __ovld __cnfn select(double8 a, double8 b, long8 c);
 double16 __ovld __cnfn select(double16 a, double16 b, long16 c);
 double __ovld __cnfn select(double a, double b, ulong c);
 double2 __ovld __cnfn select(double2 a, double2 b, ulong2 c);
 double3 __ovld __cnfn select(double3 a, double3 b, ulong3 c);
 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);
 half3 __ovld __cnfn select(half3 a, half3 b, short3 c);
 half4 __ovld __cnfn select(half4 a, half4 b, short4 c);
 half8 __ovld __cnfn select(half8 a, half8 b, short8 c);
 half16 __ovld __cnfn select(half16 a, half16 b, short16 c);
 half __ovld __cnfn select(half a, half b, ushort c);

  *
  * The address computed as (p + (offset * n)) must be
  * 8-bit aligned if gentype is char, uchar;
  * 16-bit aligned if gentype is short, ushort, half;
  * 32-bit aligned if gentype is int, uint, float;
  * 64-bit aligned if gentype is long, ulong, double.
  */
 
 char2 __ovld vload2(size_t offset, const __constant char *p);
 uchar2 __ovld vload2(size_t offset, const __constant uchar *p);
 short2 __ovld vload2(size_t offset, const __constant short *p);
 ushort2 __ovld vload2(size_t offset, const __constant ushort *p);
 int2 __ovld vload2(size_t offset, const __constant int *p);
 uint2 __ovld vload2(size_t offset, const __constant uint *p);
 long2 __ovld vload2(size_t offset, const __constant long *p);
 ulong2 __ovld vload2(size_t offset, const __constant ulong *p);
 float2 __ovld vload2(size_t offset, const __constant float *p);
 char3 __ovld vload3(size_t offset, const __constant char *p);
 uchar3 __ovld vload3(size_t offset, const __constant uchar *p);
 short3 __ovld vload3(size_t offset, const __constant short *p);
 ushort3 __ovld vload3(size_t offset, const __constant ushort *p);
 int3 __ovld vload3(size_t offset, const __constant int *p);
 uint3 __ovld vload3(size_t offset, const __constant uint *p);
 long3 __ovld vload3(size_t offset, const __constant long *p);
 ulong3 __ovld vload3(size_t offset, const __constant ulong *p);
 float3 __ovld vload3(size_t offset, const __constant float *p);
 char4 __ovld vload4(size_t offset, const __constant char *p);
 uchar4 __ovld vload4(size_t offset, const __constant uchar *p);
 short4 __ovld vload4(size_t offset, const __constant short *p);

 uchar16 __ovld vload16(size_t offset, const __constant uchar *p);
 short16 __ovld vload16(size_t offset, const __constant short *p);
 ushort16 __ovld vload16(size_t offset, const __constant ushort *p);
 int16 __ovld vload16(size_t offset, const __constant int *p);
 uint16 __ovld vload16(size_t offset, const __constant uint *p);
 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);
 half2 __ovld vload2(size_t offset, const __constant half *p);
 half3 __ovld vload3(size_t offset, const __constant half *p);
 half4 __ovld vload4(size_t offset, const __constant half *p);
 half8 __ovld vload8(size_t offset, const __constant half *p);
 half16 __ovld vload16(size_t offset, const __constant half *p);

 short16 __ovld vload16(size_t offset, const short *p);
 ushort16 __ovld vload16(size_t offset, const ushort *p);
 int16 __ovld vload16(size_t offset, const int *p);
 uint16 __ovld vload16(size_t offset, const uint *p);
 long16 __ovld vload16(size_t offset, const long *p);
 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);
 half2 __ovld vload2(size_t offset, const half *p);
 half3 __ovld vload3(size_t offset, const half *p);
 half4 __ovld vload4(size_t offset, const half *p);
 half8 __ovld vload8(size_t offset, const half *p);
 half16 __ovld vload16(size_t offset, const half *p);

 short16 __ovld vload16(size_t offset, const __private short *p);
 ushort16 __ovld vload16(size_t offset, const __private ushort *p);
 int16 __ovld vload16(size_t offset, const __private int *p);
 uint16 __ovld vload16(size_t offset, const __private uint *p);
 long16 __ovld vload16(size_t offset, const __private long *p);
 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);
 double8 __ovld vload8(size_t offset, const __global double *p);
 double16 __ovld vload16(size_t offset, const __global double *p);
 double2 __ovld vload2(size_t offset, const __local double *p);
 double3 __ovld vload3(size_t offset, const __local double *p);
 double4 __ovld vload4(size_t offset, const __local double *p);
 double8 __ovld vload8(size_t offset, const __local double *p);
 double16 __ovld vload16(size_t offset, const __local double *p);
 double2 __ovld vload2(size_t offset, const __private double *p);
 double3 __ovld vload3(size_t offset, const __private double *p);
 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);
 half2 __ovld vload2(size_t offset, const __global half *p);
 half3 __ovld vload3(size_t offset, const __global half *p);
 half4 __ovld vload4(size_t offset, const __global half *p);
 half8 __ovld vload8(size_t offset, const __global half *p);
 half16 __ovld vload16(size_t offset, const __global half *p);

 void __ovld vstore16(uchar16 data, size_t offset, uchar *p);
 void __ovld vstore16(short16 data, size_t offset, short *p);
 void __ovld vstore16(ushort16 data, size_t offset, ushort *p);
 void __ovld vstore16(int16 data, size_t offset, int *p);
 void __ovld vstore16(uint16 data, size_t offset, uint *p);
 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);
 void __ovld vstore3(half3 data, size_t offset, half *p);
 void __ovld vstore4(half4 data, size_t offset, half *p);
 void __ovld vstore8(half8 data, size_t offset, half *p);
 void __ovld vstore16(half16 data, size_t offset, half *p);
 #endif //cl_khr_fp16

 void __ovld vstore16(uchar16 data, size_t offset, __private uchar *p);
 void __ovld vstore16(short16 data, size_t offset, __private short *p);
 void __ovld vstore16(ushort16 data, size_t offset, __private ushort *p);
 void __ovld vstore16(int16 data, size_t offset, __private int *p);
 void __ovld vstore16(uint16 data, size_t offset, __private uint *p);
 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);
 void __ovld vstore8(double8 data, size_t offset, __global double *p);
 void __ovld vstore16(double16 data, size_t offset, __global double *p);
 void __ovld vstore2(double2 data, size_t offset, __local double *p);
 void __ovld vstore3(double3 data, size_t offset, __local double *p);
 void __ovld vstore4(double4 data, size_t offset, __local double *p);
 void __ovld vstore8(double8 data, size_t offset, __local double *p);
 void __ovld vstore16(double16 data, size_t offset, __local double *p);
 void __ovld vstore2(double2 data, size_t offset, __private double *p);
 void __ovld vstore3(double3 data, size_t offset, __private double *p);
 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);
 void __ovld vstore3(half3 data, size_t offset, __global half *p);
 void __ovld vstore4(half4 data, size_t offset, __global half *p);
 void __ovld vstore8(half8 data, size_t offset, __global half *p);
 void __ovld vstore16(half16 data, size_t offset, __global half *p);
 void __ovld vstore(half data, size_t offset, __local half *p);

  * nearest even.
  */
 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 void __ovld vstore_half(float data, size_t offset, half *p);
 void __ovld vstore_half_rte(float data, size_t offset, half *p);
 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);
 void __ovld vstore_half_rtz(float data, size_t offset, __global half *p);
 void __ovld vstore_half_rtp(float data, size_t offset, __global half *p);
 void __ovld vstore_half_rtn(float data, size_t offset, __global half *p);
 void __ovld vstore_half(float data, size_t offset, __local half *p);
 void __ovld vstore_half_rte(float data, size_t offset, __local half *p);
 void __ovld vstore_half_rtz(float data, size_t offset, __local half *p);
 void __ovld vstore_half_rtp(float data, size_t offset, __local half *p);
 void __ovld vstore_half_rtn(float data, size_t offset, __local half *p);
 void __ovld vstore_half(float data, size_t offset, __private half *p);
 void __ovld vstore_half_rte(float data, size_t offset, __private half *p);
 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);
 void __ovld vstore_half_rtp(double data, size_t offset, __global half *p);
 void __ovld vstore_half_rtn(double data, size_t offset, __global half *p);
 void __ovld vstore_half(double data, size_t offset, __local half *p);
 void __ovld vstore_half_rte(double data, size_t offset, __local half *p);
 void __ovld vstore_half_rtz(double data, size_t offset, __local half *p);
 void __ovld vstore_half_rtp(double data, size_t offset, __local half *p);
 void __ovld vstore_half_rtn(double data, size_t offset, __local half *p);
 void __ovld vstore_half(double data, size_t offset, __private half *p);
 void __ovld vstore_half_rte(double data, size_t offset, __private half *p);
 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)
 
 /**
  * The floatn value given by data is converted to
  * a halfn value using the appropriate rounding
  * mode. The halfn value is then written to
  * address computed as (p + (offset * n)). The
  * address computed as (p + (offset * n)) must be

 void __ovld vstore_half4_rtp(float4 data, size_t offset, half *p);
 void __ovld vstore_half8_rtp(float8 data, size_t offset, half *p);
 void __ovld vstore_half16_rtp(float16 data, size_t offset, half *p);
 void __ovld vstore_half2_rtn(float2 data, size_t offset, half *p);
 void __ovld vstore_half3_rtn(float3 data, size_t offset, half *p);
 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);
 void __ovld vstore_half8(double8 data, size_t offset, half *p);
 void __ovld vstore_half16(double16 data, size_t offset, half *p);
 void __ovld vstore_half2_rte(double2 data, size_t offset, half *p);
 void __ovld vstore_half3_rte(double3 data, size_t offset, half *p);
 void __ovld vstore_half4_rte(double4 data, size_t offset, half *p);

 void __ovld vstore_half4_rtp(double4 data, size_t offset, half *p);
 void __ovld vstore_half8_rtp(double8 data, size_t offset, half *p);
 void __ovld vstore_half16_rtp(double16 data, size_t offset, half *p);
 void __ovld vstore_half2_rtn(double2 data, size_t offset, half *p);
 void __ovld vstore_half3_rtn(double3 data, size_t offset, half *p);
 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);
 void __ovld vstore_half4(float4 data, size_t offset, __global half *p);
 void __ovld vstore_half8(float8 data, size_t offset, __global half *p);
 void __ovld vstore_half16(float16 data, size_t offset, __global half *p);
 void __ovld vstore_half2_rte(float2 data, size_t offset, __global half *p);
 void __ovld vstore_half3_rte(float3 data, size_t offset, __global half *p);

 void __ovld vstore_half4_rtp(float4 data, size_t offset, __private half *p);
 void __ovld vstore_half8_rtp(float8 data, size_t offset, __private half *p);
 void __ovld vstore_half16_rtp(float16 data, size_t offset, __private half *p);
 void __ovld vstore_half2_rtn(float2 data, size_t offset, __private half *p);
 void __ovld vstore_half3_rtn(float3 data, size_t offset, __private half *p);
 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);
 void __ovld vstore_half8(double8 data, size_t offset, __global half *p);
 void __ovld vstore_half16(double16 data, size_t offset, __global half *p);
 void __ovld vstore_half2_rte(double2 data, size_t offset, __global half *p);
 void __ovld vstore_half3_rte(double3 data, size_t offset, __global half *p);
 void __ovld vstore_half4_rte(double4 data, size_t offset, __global half *p);

 void __ovld vstore_half4_rtp(double4 data, size_t offset, __private half *p);
 void __ovld vstore_half8_rtp(double8 data, size_t offset, __private half *p);
 void __ovld vstore_half16_rtp(double16 data, size_t offset, __private half *p);
 void __ovld vstore_half2_rtn(double2 data, size_t offset, __private half *p);
 void __ovld vstore_half3_rtn(double3 data, size_t offset, __private half *p);
 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)
 
 /**
  * For n = 1, 2, 4, 8 and 16 read sizeof (halfn)
  * bytes of data from address (p + (offset * n)).
  * The data read is interpreted as a halfn value.
  * The halfn value read is converted to a floatn
  * value and the floatn value is returned.

 
 void __ovld vstorea_half_rtn(float data, size_t offset, half *p);
 void __ovld vstorea_half2_rtn(float2 data, size_t offset, half *p);
 void __ovld vstorea_half3_rtn(float3 data, size_t offset, half *p);
 void __ovld vstorea_half4_rtn(float4 data, size_t offset, half *p);
 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);
 void __ovld vstorea_half4(double4 data, size_t offset, half *p);
 void __ovld vstorea_half8(double8 data, size_t offset, half *p);
 void __ovld vstorea_half16(double16 data, size_t offset, half *p);
 
 void __ovld vstorea_half_rte(double data, size_t offset, half *p);

 void __ovld vstorea_half16_rtp(double16 data, size_t offset, half *p);
 
 void __ovld vstorea_half_rtn(double data, size_t offset, half *p);
 void __ovld vstorea_half2_rtn(double2 data, size_t offset, half *p);
 void __ovld vstorea_half3_rtn(double3 data, size_t offset, half *p);
 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);
 void __ovld vstorea_half2(float2 data, size_t offset, __global half *p);
 void __ovld vstorea_half3(float3 data, size_t offset, __global half *p);
 void __ovld vstorea_half4(float4 data, size_t offset, __global half *p);
 void __ovld vstorea_half8(float8 data, size_t offset, __global half *p);
 void __ovld vstorea_half16(float16 data, size_t offset, __global half *p);

 
 void __ovld vstorea_half_rtn(float data, size_t offset, __private half *p);
 void __ovld vstorea_half2_rtn(float2 data, size_t offset, __private half *p);
 void __ovld vstorea_half3_rtn(float3 data, size_t offset, __private half *p);
 void __ovld vstorea_half4_rtn(float4 data, size_t offset, __private half *p);
 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);
 void __ovld vstorea_half4(double4 data, size_t offset, __global half *p);
 void __ovld vstorea_half8(double8 data, size_t offset, __global half *p);
 void __ovld vstorea_half16(double16 data, size_t offset, __global half *p);
 
 void __ovld vstorea_half_rte(double data, size_t offset, __global half *p);

 void __ovld vstorea_half16_rtp(double16 data, size_t offset, __private half *p);
 
 void __ovld vstorea_half_rtn(double data, size_t offset, __private half *p);
 void __ovld vstorea_half2_rtn(double2 data,size_t offset, __private half *p);
 void __ovld vstorea_half3_rtn(double3 data,size_t offset, __private half *p);
 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
 
 /**
  * All work-items in a work-group executing the kernel
  * on a processor must execute this function before any
  * are allowed to continue execution beyond the barrier.

 event_t __ovld async_work_group_copy(__global uchar16 *dst, const __local uchar16 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__global short16 *dst, const __local short16 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__global ushort16 *dst, const __local ushort16 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__global int16 *dst, const __local int16 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__global uint16 *dst, const __local uint16 *src, size_t num_elements, event_t event);
 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);
 event_t __ovld async_work_group_copy(__local double4 *dst, const __global double4 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__local double8 *dst, const __global double8 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__local double16 *dst, const __global double16 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__global double *dst, const __local double *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__global double2 *dst, const __local double2 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__global double3 *dst, const __local double3 *src, size_t num_elements, event_t event);
 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);
 event_t __ovld async_work_group_copy(__local half3 *dst, const __global half3 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__local half4 *dst, const __global half4 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__local half8 *dst, const __global half8 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__local half16 *dst, const __global half16 *src, size_t num_elements, event_t event);
 event_t __ovld async_work_group_copy(__global half *dst, const __local half *src, size_t num_elements, event_t event);

 event_t __ovld async_work_group_strided_copy(__global uchar16 *dst, const __local uchar16 *src, size_t num_elements, size_t dst_stride, event_t event);
 event_t __ovld async_work_group_strided_copy(__global short16 *dst, const __local short16 *src, size_t num_elements, size_t dst_stride, event_t event);
 event_t __ovld async_work_group_strided_copy(__global ushort16 *dst, const __local ushort16 *src, size_t num_elements, size_t dst_stride, event_t event);
 event_t __ovld async_work_group_strided_copy(__global int16 *dst, const __local int16 *src, size_t num_elements, size_t dst_stride, event_t event);
 event_t __ovld async_work_group_strided_copy(__global uint16 *dst, const __local uint16 *src, size_t num_elements, size_t dst_stride, event_t event);
 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);
 event_t __ovld async_work_group_strided_copy(__local double4 *dst, const __global double4 *src, size_t num_elements, size_t src_stride, event_t event);
 event_t __ovld async_work_group_strided_copy(__local double8 *dst, const __global double8 *src, size_t num_elements, size_t src_stride, event_t event);
 event_t __ovld async_work_group_strided_copy(__local double16 *dst, const __global double16 *src, size_t num_elements, size_t src_stride, event_t event);
 event_t __ovld async_work_group_strided_copy(__global double *dst, const __local double *src, size_t num_elements, size_t dst_stride, event_t event);
 event_t __ovld async_work_group_strided_copy(__global double2 *dst, const __local double2 *src, size_t num_elements, size_t dst_stride, event_t event);
 event_t __ovld async_work_group_strided_copy(__global double3 *dst, const __local double3 *src, size_t num_elements, size_t dst_stride, event_t event);
 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);
 event_t __ovld async_work_group_strided_copy(__local half3 *dst, const __global half3 *src, size_t num_elements, size_t src_stride, event_t event);
 event_t __ovld async_work_group_strided_copy(__local half4 *dst, const __global half4 *src, size_t num_elements, size_t src_stride, event_t event);
 event_t __ovld async_work_group_strided_copy(__local half8 *dst, const __global half8 *src, size_t num_elements, size_t src_stride, event_t event);
 event_t __ovld async_work_group_strided_copy(__local half16 *dst, const __global half16 *src, size_t num_elements, size_t src_stride, event_t event);
 event_t __ovld async_work_group_strided_copy(__global half *dst, const __local half *src, size_t num_elements, size_t dst_stride, event_t event);

 void __ovld prefetch(const __global uchar16 *p, size_t num_elements);
 void __ovld prefetch(const __global short16 *p, size_t num_elements);
 void __ovld prefetch(const __global ushort16 *p, size_t num_elements);
 void __ovld prefetch(const __global int16 *p, size_t num_elements);
 void __ovld prefetch(const __global uint16 *p, size_t num_elements);
 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);
 void __ovld prefetch(const __global half3 *p, size_t num_elements);
 void __ovld prefetch(const __global half4 *p, size_t num_elements);
 void __ovld prefetch(const __global half8 *p, size_t num_elements);
 void __ovld prefetch(const __global half16 *p, size_t num_elements);
 #endif // cl_khr_fp16

 
 // atomic_init()
 void __ovld atomic_init(volatile atomic_int *object, int value);
 void __ovld atomic_init(volatile atomic_uint *object, uint value);
 void __ovld atomic_init(volatile atomic_float *object, float value);
 #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()
 void __ovld atomic_work_item_fence(cl_mem_fence_flags flags, memory_order order, memory_scope scope);
 
 // atomic_fetch()
 
 int __ovld atomic_fetch_add(volatile atomic_int *object, int operand);

 void __ovld atomic_store_explicit(volatile atomic_int *object, int desired, memory_order order, memory_scope scope);
 void __ovld atomic_store(volatile atomic_uint *object, uint desired);
 void __ovld atomic_store_explicit(volatile atomic_uint *object, uint desired, memory_order order);
 void __ovld atomic_store_explicit(volatile atomic_uint *object, uint desired, memory_order order, memory_scope scope);
 void __ovld atomic_store(volatile atomic_float *object, float desired);
 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);
 void __ovld atomic_store(volatile atomic_ulong *object, ulong desired);
 void __ovld atomic_store_explicit(volatile atomic_ulong *object, ulong desired, memory_order order);
 void __ovld atomic_store_explicit(volatile atomic_ulong *object, ulong desired, memory_order order, memory_scope scope);
 #endif
 
 // atomic_load()
 
 int __ovld atomic_load(volatile atomic_int *object);
 int __ovld atomic_load_explicit(volatile atomic_int *object, memory_order order);
 int __ovld atomic_load_explicit(volatile atomic_int *object, memory_order order, memory_scope scope);
 uint __ovld atomic_load(volatile atomic_uint *object);
 uint __ovld atomic_load_explicit(volatile atomic_uint *object, memory_order order);
 uint __ovld atomic_load_explicit(volatile atomic_uint *object, memory_order order, memory_scope scope);
 float __ovld atomic_load(volatile atomic_float *object);
 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);
 ulong __ovld atomic_load(volatile atomic_ulong *object);
 ulong __ovld atomic_load_explicit(volatile atomic_ulong *object, memory_order order);
 ulong __ovld atomic_load_explicit(volatile atomic_ulong *object, memory_order order, memory_scope scope);
 #endif
 
 // atomic_exchange()
 
 int __ovld atomic_exchange(volatile atomic_int *object, int desired);
 int __ovld atomic_exchange_explicit(volatile atomic_int *object, int desired, memory_order order);
 int __ovld atomic_exchange_explicit(volatile atomic_int *object, int desired, memory_order order, memory_scope scope);
 uint __ovld atomic_exchange(volatile atomic_uint *object, uint desired);
 uint __ovld atomic_exchange_explicit(volatile atomic_uint *object, uint desired, memory_order order);
 uint __ovld atomic_exchange_explicit(volatile atomic_uint *object, uint desired, memory_order order, memory_scope scope);
 float __ovld atomic_exchange(volatile atomic_float *object, float desired);
 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);
 ulong __ovld atomic_exchange(volatile atomic_ulong *object, ulong desired);
 ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *object, ulong desired, memory_order order);
 ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *object, ulong desired, memory_order order, memory_scope scope);
 #endif
 

 bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_float *object, float *expected,
                                                                                  float desired, memory_order success, memory_order failure, memory_scope scope);
 bool __ovld atomic_compare_exchange_weak(volatile atomic_float *object, float *expected, float desired);
 bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_float *object, float *expected,
                                                                                  float desired, memory_order success, memory_order failure);
 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);
 bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_double *object, double *expected,
                                                                                  double desired, memory_order success, memory_order failure, memory_scope scope);
 bool __ovld atomic_compare_exchange_weak(volatile atomic_double *object, double *expected, double desired);
 bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_double *object, double *expected,
                                                                                  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);
 bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_long *object, long *expected,
                                                                                  long desired, memory_order success, memory_order failure, memory_scope scope);
 bool __ovld atomic_compare_exchange_weak(volatile atomic_long *object, long *expected, long desired);
 bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_long *object, long *expected,
                                                                                  long desired, memory_order success, memory_order failure);

 ulong16 __ovld __cnfn shuffle(ulong8 x, ulong16 mask);
 ulong16 __ovld __cnfn shuffle(ulong16 x, ulong16 mask);
 
 float16 __ovld __cnfn shuffle(float2 x, uint16 mask);
 float16 __ovld __cnfn shuffle(float4 x, uint16 mask);
 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);
 double2 __ovld __cnfn shuffle(double16 x, ulong2 mask);
 
 double4 __ovld __cnfn shuffle(double2 x, ulong4 mask);
 double4 __ovld __cnfn shuffle(double4 x, ulong4 mask);
 double4 __ovld __cnfn shuffle(double8 x, ulong4 mask);
 double4 __ovld __cnfn shuffle(double16 x, ulong4 mask);
 
 double8 __ovld __cnfn shuffle(double2 x, ulong8 mask);
 double8 __ovld __cnfn shuffle(double4 x, ulong8 mask);
 double8 __ovld __cnfn shuffle(double8 x, ulong8 mask);
 double8 __ovld __cnfn shuffle(double16 x, ulong8 mask);
 
 double16 __ovld __cnfn shuffle(double2 x, ulong16 mask);
 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);
 half2 __ovld __cnfn shuffle(half4 x, ushort2 mask);
 half2 __ovld __cnfn shuffle(half8 x, ushort2 mask);
 half2 __ovld __cnfn shuffle(half16 x, ushort2 mask);
 
 half4 __ovld __cnfn shuffle(half2 x, ushort4 mask);

 ulong16 __ovld __cnfn shuffle2(ulong8 x, ulong8 y, ulong16 mask);
 ulong16 __ovld __cnfn shuffle2(ulong16 x, ulong16 y, ulong16 mask);
 
 float16 __ovld __cnfn shuffle2(float2 x, float2 y, uint16 mask);
 float16 __ovld __cnfn shuffle2(float4 x, float4 y, uint16 mask);
 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);
 double2 __ovld __cnfn shuffle2(double16 x, double16 y, ulong2 mask);
 
 double4 __ovld __cnfn shuffle2(double2 x, double2 y, ulong4 mask);
 double4 __ovld __cnfn shuffle2(double4 x, double4 y, ulong4 mask);
 double4 __ovld __cnfn shuffle2(double8 x, double8 y, ulong4 mask);
 double4 __ovld __cnfn shuffle2(double16 x, double16 y, ulong4 mask);
 
 double8 __ovld __cnfn shuffle2(double2 x, double2 y, ulong8 mask);
 double8 __ovld __cnfn shuffle2(double4 x, double4 y, ulong8 mask);
 double8 __ovld __cnfn shuffle2(double8 x, double8 y, ulong8 mask);
 double8 __ovld __cnfn shuffle2(double16 x, double16 y, ulong8 mask);
 
 double16 __ovld __cnfn shuffle2(double2 x, double2 y, ulong16 mask);
 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);
 half2 __ovld __cnfn shuffle2(half4 x, half4 y, ushort2 mask);
 half2 __ovld __cnfn shuffle2(half8 x, half8 y, ushort2 mask);
 half2 __ovld __cnfn shuffle2(half16 x, half16 y, ushort2 mask);
 
 half4 __ovld __cnfn shuffle2(half2 x, half2 y, ushort4 mask);

 long __ovld __conv work_group_broadcast(long a, size_t x, size_t y);
 long __ovld __conv work_group_broadcast(long a, size_t x, size_t y, size_t z);
 ulong __ovld __conv work_group_broadcast(ulong a, size_t local_id);
 ulong __ovld __conv work_group_broadcast(ulong a, size_t x, size_t y);
 ulong __ovld __conv work_group_broadcast(ulong a, size_t x, size_t y, size_t z);
 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);
 half __ovld __conv work_group_reduce_min(half x);
 half __ovld __conv work_group_reduce_max(half x);
 half __ovld __conv work_group_scan_exclusive_add(half x);
 half __ovld __conv work_group_scan_exclusive_min(half x);
 half __ovld __conv work_group_scan_exclusive_max(half x);

 float __ovld __conv work_group_reduce_min(float x);
 float __ovld __conv work_group_reduce_max(float x);
 float __ovld __conv work_group_scan_exclusive_add(float x);
 float __ovld __conv work_group_scan_exclusive_min(float x);
 float __ovld __conv work_group_scan_exclusive_max(float x);
 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);
 double __ovld __conv work_group_scan_exclusive_add(double x);
 double __ovld __conv work_group_scan_exclusive_min(double x);
 double __ovld __conv work_group_scan_exclusive_max(double x);
 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)
 
 // OpenCL v2.0 s6.13.16 - Pipe Functions
 #if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 bool __ovld is_valid_reserve_id(reserve_id_t reserve_id);
 #endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0)
 

 half    __ovld __conv sub_group_scan_exclusive_add(half x);
 half    __ovld __conv sub_group_scan_exclusive_min(half x);
 half    __ovld __conv sub_group_scan_exclusive_max(half x);
 half    __ovld __conv sub_group_scan_inclusive_add(half x);
 half    __ovld __conv sub_group_scan_inclusive_min(half x);
 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);
 double  __ovld __conv sub_group_reduce_max(double x);
 double  __ovld __conv sub_group_scan_exclusive_add(double x);
 double  __ovld __conv sub_group_scan_exclusive_min(double x);
 double  __ovld __conv sub_group_scan_exclusive_max(double x);
 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
 
 #if defined(cl_khr_subgroup_extended_types)
 char __ovld __conv sub_group_broadcast( char value, uint index );
 char2 __ovld __conv sub_group_broadcast( char2 value, uint index );
 char3 __ovld __conv sub_group_broadcast( char3 value, uint index );
 char4 __ovld __conv sub_group_broadcast( char4 value, uint index );

 // scalar half broadcast is part of cl_khr_subgroups
 half2 __ovld __conv sub_group_broadcast( half2 value, uint index );
 half3 __ovld __conv sub_group_broadcast( half3 value, uint index );
 half4 __ovld __conv sub_group_broadcast( half4 value, uint index );
 half8 __ovld __conv sub_group_broadcast( half8 value, uint index );
 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
 
 #if defined(cl_khr_subgroup_non_uniform_vote)
 int     __ovld sub_group_elect(void);
 int     __ovld sub_group_non_uniform_all( int predicate );
 int     __ovld sub_group_non_uniform_any( int predicate );
 
 int     __ovld sub_group_non_uniform_all_equal( char value );
 int     __ovld sub_group_non_uniform_all_equal( uchar value );
 int     __ovld sub_group_non_uniform_all_equal( short value );
 int     __ovld sub_group_non_uniform_all_equal( ushort value );
 int     __ovld sub_group_non_uniform_all_equal( int value );
 int     __ovld sub_group_non_uniform_all_equal( uint value );
 int     __ovld sub_group_non_uniform_all_equal( long value );
 int     __ovld sub_group_non_uniform_all_equal( ulong value );
 int     __ovld sub_group_non_uniform_all_equal( float value );
 
 #if defined(cl_khr_fp16)
 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
 
 #if defined(cl_khr_subgroup_ballot)
 char    __ovld sub_group_non_uniform_broadcast( char value, uint index );
 char2   __ovld sub_group_non_uniform_broadcast( char2 value, uint index );
 char3   __ovld sub_group_non_uniform_broadcast( char3 value, uint index );
 char4   __ovld sub_group_non_uniform_broadcast( char4 value, uint index );

 half3   __ovld sub_group_non_uniform_broadcast( half3 value, uint index );
 half4   __ovld sub_group_non_uniform_broadcast( half4 value, uint index );
 half8   __ovld sub_group_non_uniform_broadcast( half8 value, uint index );
 half16  __ovld sub_group_non_uniform_broadcast( half16 value, uint index );
 
 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 );
 double4  __ovld sub_group_non_uniform_broadcast( double4 value, uint index );
 double8  __ovld sub_group_non_uniform_broadcast( double8 value, uint index );
 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
 
 #if defined(cl_khr_subgroup_non_uniform_arithmetic)
 char    __ovld sub_group_non_uniform_reduce_add( char value );
 uchar   __ovld sub_group_non_uniform_reduce_add( uchar value );
 short   __ovld sub_group_non_uniform_reduce_add( short value );
 ushort  __ovld sub_group_non_uniform_reduce_add( ushort value );

 half    __ovld sub_group_non_uniform_scan_inclusive_min( half value );
 half    __ovld sub_group_non_uniform_scan_inclusive_max( half value );
 half    __ovld sub_group_non_uniform_scan_exclusive_add( half value );
 half    __ovld sub_group_non_uniform_scan_exclusive_mul( half value );
 half    __ovld sub_group_non_uniform_scan_exclusive_min( half value );
 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 );
 double  __ovld sub_group_non_uniform_reduce_max( double value );
 double  __ovld sub_group_non_uniform_scan_inclusive_add( double value );
 double  __ovld sub_group_non_uniform_scan_inclusive_mul( double value );
 double  __ovld sub_group_non_uniform_scan_inclusive_min( double value );
 double  __ovld sub_group_non_uniform_scan_inclusive_max( double value );
 double  __ovld sub_group_non_uniform_scan_exclusive_add( double value );
 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
 
 #if defined(cl_khr_subgroup_shuffle)
 char    __ovld sub_group_shuffle( char value, uint index );
 uchar   __ovld sub_group_shuffle( uchar value, uint index );
 short   __ovld sub_group_shuffle( short value, uint index );
 ushort  __ovld sub_group_shuffle( ushort value, uint index );

 ulong   __ovld sub_group_shuffle_xor( ulong value, uint mask );
 float   __ovld sub_group_shuffle_xor( float value, uint mask );
 
 #if defined(cl_khr_fp16)
 half    __ovld sub_group_shuffle( half value, uint index );
 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
 
 #if defined(cl_khr_subgroup_shuffle_relative)
 char    __ovld sub_group_shuffle_up( char value, uint delta );
 uchar   __ovld sub_group_shuffle_up( uchar value, uint delta );
 short   __ovld sub_group_shuffle_up( short value, uint delta );
 ushort  __ovld sub_group_shuffle_up( ushort value, uint delta );

 ulong   __ovld sub_group_shuffle_down( ulong value, uint delta );
 float   __ovld sub_group_shuffle_down( float value, uint delta );
 
 #if defined(cl_khr_fp16)
 half    __ovld sub_group_shuffle_up( half value, uint delta );
 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
 
 #if defined(cl_khr_subgroup_clustered_reduce)
 char    __ovld sub_group_clustered_reduce_add( char value, uint clustersize );
 uchar   __ovld sub_group_clustered_reduce_add( uchar value, uint clustersize );
 short   __ovld sub_group_clustered_reduce_add( short value, uint clustersize );
 ushort  __ovld sub_group_clustered_reduce_add( ushort value, uint clustersize );

 
 #if defined(cl_khr_fp16)
 half    __ovld sub_group_clustered_reduce_add( half value, uint clustersize );
 half    __ovld sub_group_clustered_reduce_mul( half value, uint clustersize );
 half    __ovld sub_group_clustered_reduce_min( half value, uint clustersize );
 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
 
 #if defined(cl_intel_subgroups)
 // Intel-Specific Sub Group Functions
 float   __ovld __conv intel_sub_group_shuffle( float  x, uint c );
 float2  __ovld __conv intel_sub_group_shuffle( float2 x, uint c );
 float3  __ovld __conv intel_sub_group_shuffle( float3 x, uint c );

 
 #ifdef cl_khr_fp16
 half    __ovld __conv intel_sub_group_shuffle( half x, uint c );
 half    __ovld __conv intel_sub_group_shuffle_down( half prev, half cur, uint c );
 half    __ovld __conv intel_sub_group_shuffle_up( half prev, half cur, uint c );
 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 );
 double  __ovld __conv intel_sub_group_shuffle_xor( double x, uint c );
 #endif
 
 #endif //cl_intel_subgroups
 

clang/lib/Sema/Sema.cpp

void Sema::Initialize() {
   // Initialize predefined OpenCL types and supported extensions and (optional)
   // core features.
   if (getLangOpts().OpenCL) {
     getOpenCLOptions().addSupport(
         Context.getTargetInfo().getSupportedOpenCLOpts(), getLangOpts());
     getOpenCLOptions().enableSupportedCore(getLangOpts());
     addImplicitTypedef("sampler_t", Context.OCLSamplerTy);
     addImplicitTypedef("event_t", Context.OCLEventTy);
     if (getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) {
       addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);
       addImplicitTypedef("queue_t", Context.OCLQueueTy);
       addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy);
       addImplicitTypedef("atomic_int", Context.getAtomicType(Context.IntTy));
       addImplicitTypedef("atomic_uint",
                          Context.getAtomicType(Context.UnsignedIntTy));
       auto AtomicLongT = Context.getAtomicType(Context.LongTy);
       addImplicitTypedef("atomic_long", AtomicLongT);
       auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy);
       addImplicitTypedef("atomic_ulong", AtomicULongT);
if (getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) {
         Atomic64BitTypes.push_back(AtomicSizeT);
         Atomic64BitTypes.push_back(AtomicIntPtrT);
         Atomic64BitTypes.push_back(AtomicUIntPtrT);
         Atomic64BitTypes.push_back(AtomicPtrDiffT);
       }
       for (auto &I : Atomic64BitTypes)
         setOpenCLExtensionForType(I,
             "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics");
-
+      if (getLangOpts().OpenCLVersion >= 300)
+        setOpenCLExtensionForType(AtomicDoubleT, "__opencl_c_fp64");
+      else
         setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64");
     }
 
+    if (getLangOpts().OpenCLVersion >= 300)
+      setOpenCLExtensionForType(Context.DoubleTy, "__opencl_c_fp64");
+    else
       setOpenCLExtensionForType(Context.DoubleTy, "cl_khr_fp64");
 
 #define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \
     setOpenCLExtensionForType(Context.Id, Ext);
 #include "clang/Basic/OpenCLImageTypes.def"
 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
     addImplicitTypedef(#ExtType, Context.Id##Ty); \
     setOpenCLExtensionForType(Context.Id##Ty, #Ext);
 #include "clang/Basic/OpenCLExtensionTypes.def"
bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
                                          unsigned Selector,
                                          SourceRange SrcRange) {
   auto Loc = Map.find(D);
   if (Loc == Map.end())
     return false;
   bool Disabled = false;
   for (auto &I : Loc->second) {
     if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
-      Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
-                                                         << I << SrcRange;
+      Diag(DiagLoc, diag::err_opencl_requires_extension)
+          << Selector << DiagInfo << I << getOpenCLOptions().isFeature(I)
+          << SrcRange;
       Disabled = true;
     }
   }
   return Disabled;
 }
 
 bool Sema::checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType QT) {
   // Check extensions for declared types.

clang/lib/Sema/SemaChecking.cpp

if (!(*I)->isPointerType() || !(*I)->getPointeeType()->isVoidType() ||
       IllegalParams = true;
     }
   }
 
   return IllegalParams;
 }
 
 static bool checkOpenCLSubgroupExt(Sema &S, CallExpr *Call) {
-  if (!S.getOpenCLOptions().isEnabled("cl_khr_subgroups")) {
+  llvm::StringRef SubgroupExtName("cl_khr_subgroups");
+  if (!S.getOpenCLOptions().isEnabled(SubgroupExtName)) {
     S.Diag(Call->getBeginLoc(), diag::err_opencl_requires_extension)
-        << 1 << Call->getDirectCallee() << "cl_khr_subgroups";
+        << 1 << Call->getDirectCallee() << SubgroupExtName
+        << S.getOpenCLOptions().isFeature(SubgroupExtName);
     return true;
   }
   return false;
 }
 
 static bool SemaOpenCLBuiltinNDRangeAndBlock(Sema &S, CallExpr *TheCall) {
   if (checkArgCount(S, TheCall, 2))
     return true;

clang/lib/Sema/SemaExpr.cpp

ExprResult Sema::DefaultArgumentPromotion(Expr *E) {
   // If this is a 'float'  or '__fp16' (CVR qualified or typedef)
   // promote to double.
   // Note that default argument promotion applies only to float (and
   // half/fp16); it does not apply to _Float16.
   const BuiltinType *BTy = Ty->getAs<BuiltinType>();
   if (BTy && (BTy->getKind() == BuiltinType::Half ||
               BTy->getKind() == BuiltinType::Float)) {
     if (getLangOpts().OpenCL &&
-        !getOpenCLOptions().isEnabled("cl_khr_fp64")) {
-        if (BTy->getKind() == BuiltinType::Half) {
-            E = ImpCastExprToType(E, Context.FloatTy, CK_FloatingCast).get();
-        }
+        !getOpenCLOptions().isFP64Enabled(getLangOpts())) {
     } else {
       E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).get();
     }
   }
 
   // C++ performs lvalue-to-rvalue conversion as a default argument
   // promotion, even on class types, but note:
   //   C++11 [conv.lval]p2:
if (Literal.isFixedPointLiteral()) {
     Res = BuildFloatingLiteral(*this, Literal, Ty, Tok.getLocation());
 
     if (Ty == Context.DoubleTy) {
       if (getLangOpts().SinglePrecisionConstants) {
         if (Ty->castAs<BuiltinType>()->getKind() != BuiltinType::Float) {
           Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get();
         }
       } else if (getLangOpts().OpenCL &&
-                 !getOpenCLOptions().isEnabled("cl_khr_fp64")) {
+                 !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();
       }
     }
   } else if (!Literal.isIntegerLiteral()) {
     return ExprError();
   } else {
     QualType Ty;
 

clang/test/CodeGenOpenCL/printf.cl

 // 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
 
 int printf(__constant const char* st, ...) __attribute__((format(printf, 1, 2)));
 
 
 // ALL-LABEL: @test_printf_float2(
 // FP64: %call = call spir_func i32 (i8 addrspace(2)*, ...) @printf(i8 addrspace(2)* getelementptr inbounds ([7 x i8], [7 x i8] addrspace(2)* @.str, i32 0, i32 0), <2 x float> %0)
 
 
 // NOFP64:  call spir_func i32 (i8 addrspace(2)*, ...) @printf(i8 addrspace(2)* getelementptr inbounds ([7 x i8], [7 x i8] addrspace(2)* @.str, i32 0, i32 0), <2 x float> %0)
 kernel void test_printf_float2(float2 arg) {
   printf("%v2hlf", arg);
 }
 
 // ALL-LABEL: @test_printf_half2(
 // FP64:  %call = call spir_func i32 (i8 addrspace(2)*, ...) @printf(i8 addrspace(2)* getelementptr inbounds ([6 x i8], [6 x i8] addrspace(2)* @.str.1, i32 0, i32 0), <2 x half> %0)
 
 // NOFP64:  %call = call spir_func i32 (i8 addrspace(2)*, ...) @printf(i8 addrspace(2)* getelementptr inbounds ([6 x i8], [6 x i8] addrspace(2)* @.str.1, i32 0, i32 0), <2 x half> %0)
 kernel void test_printf_half2(half2 arg) {
   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) {
   printf("%v2lf", arg);
 }
 #endif

clang/test/SemaOpenCL/opencl-fp64-feature.cl

+// Test with a target not supporting fp64.
+// RUN: %clang_cc1 -cl-std=CL3.0 %s -triple r600-unknown-unknown -target-cpu r600 -verify -pedantic -fsyntax-only -DNOFP64
+
+// Test with features enable by cmd-line args
+//
+// RUN: %clang_cc1 -cl-std=CL3.0 %s -triple r600-unknown-unknown -target-cpu r600 -verify -pedantic -fsyntax-only -cl-ext=+__opencl_c_fp64
+//
+// Disable or enable all features
+// RUN: %clang_cc1 -cl-std=CL3.0 %s -triple spir-unknown-unknown -verify -pedantic -fsyntax-only -cl-ext=-all -DNOFP64
+// RUN: %clang_cc1 -cl-std=CL3.0 %s -triple r600-unknown-unknown -target-cpu r600 -verify -pedantic -fsyntax-only -cl-ext=+all
+// 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 -cl-std=CL3.0 %s -triple spir-unknown-unknown -verify -pedantic -fsyntax-only -cl-ext=-__opencl_c_fp64 -cl-ext=+__opencl_c_fp64
+// RUN: %clang_cc1 -cl-std=CL3.0 %s -triple spir-unknown-unknown -verify -pedantic -fsyntax-only -cl-ext=-__opencl_c_fp64,+__opencl_c_fp64
+// 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
+
+#ifndef NOFP64
+// expected-no-diagnostics
+#endif
+
+
+void f1(double da) { 
+#ifdef NOFP64
+// expected-error@-2 {{type 'double' requires __opencl_c_fp64 feature}}
+#endif
+}
+
+void f2(void) {
+  double d;
+#ifdef NOFP64
+// expected-error@-2{{use of type 'double' requires __opencl_c_fp64 feature to be enabled}}
+#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 __opencl_c_fp64 feature to be enabled}}
+// expected-error@-3 {{use of type 'double4' (vector of 4 'double' values) requires __opencl_c_fp64 feature to be enabled}}
+#endif
+
+  (void) 1.0;
+
+#ifdef NOFP64
+// expected-warning@-3{{double precision constant requires __opencl_c_fp64, casting to single precision}}
+#endif
+}
+