[OpenCL] Refactor of targets OpenCL option settings

[azabaznov]

Summary

Currently, there is some refactoring needed in existing interface of OpenCL option
settings to support OpenCL C 3.0. The problem is that OpenCL extensions and features
are not only determined by the target platform but also by the OpenCL version.
Also, there are core extensions/features which are supported unconditionally in
specific OpenCL C version. In fact, these rules are not being followed for all targets.
For example, there are some targets (as nvptx and r600) which don't support
OpenCL C 2.0 core features (nvptx.languageOptsOpenCL.cl, r600.languageOptsOpenCL.cl).

After the change there will be explicit differentiation between optional core and core
OpenCL features which allows giving diagnostics if target doesn't support any of
necessary core features for specific OpenCL version.

This patch also eliminates OpenCLOptions instance duplication from TargetOptions.
OpenCLOptions instance should take place in Sema as it's going to be modified
during parsing. Removing this duplication will also allow to generally simplify
OpenCLOptions class for parsing purposes.

[azabaznov]

@Anastasia, there is common functionality with your approach in https://reviews.llvm.org/D91531. I guess these two patches can be unified at some point once we discuss it.

[Anastasia]

Thanks for working on this! It is a very good refactoring that brings OpenCL closer inline with convention design flow. I also suggest removing the dependence on LangOpts. See detailed comments.

clang/include/clang/Basic/OpenCLExtensions.def

48

Let's document the differences in those macros.

clang/include/clang/Basic/OpenCLOptions.h

115–116

My concern is that at this point it reads like only core extensions are being initialized, perhaps we should add another macro which would be common between different extensions even if it might be just an alias to OPENCLCOREEXT_INTERNAL. This will avoid confusion.

124–125

How about creating a type alias for this map with a name reflecting its purpose? It could be used for Features in TargetOptions as well, but this can be done separately.

clang/include/clang/Basic/TargetInfo.h

1438

I feel this comment should get updated?

1512

provided in command line -> provided in command line configuration.

clang/lib/Basic/Targets.cpp

726

Setting all extensions as supported is a corner case so I think moving this into a member function that can be called by virtual targets would be a better fit. Btw since this logic is now moved here do you think we can remove OpenCLOptions::supportAll?

728

We used to do this everywhere, but I find it a bit ugly. In C++ we have many good language features to allow avoiding multiline macros. For example we could define a macro to a lambda that would contain the logic for setting one extension conditionally.

739

If we perform this logic in OpenCLOptions (for example in addSupport) we won't need to pass LangOpts here. Then we won't need to worry about the language being compiled for. This will bring implementation better inline with the conventional design i.e. the target configuration is unaffected by the language or its version. See related comment below.

746

OpenCLOptions::support has similar logic that I think won't be needed there any longer? If so I suggest removing it from that function.

clang/lib/Basic/Targets/AMDGPU.h

309

Since you are on this track already it would be cleaner if the target would just set the features based on the HW support without considering language settings i.e. OpenCL version.

When OpenCLOptions in Sema can be set considering both target features and language version. Those options are then used during parsing. I think it will simplify the interface and implementation too and more importantly avoid cyclic dependency between target options and language options.

clang/lib/Frontend/CompilerInstance.cpp

957 ↗

(On Diff #308212)

Ok, again if we don't need to pass LangOpts any more we can keep initialization of these options in TargetInfo::CreateTargetInfo that would allow adhering to the conventional flow which we should be doing!

[Anastasia]

clang/include/clang/Basic/TargetOptions.h

65

Your current design brings us closer to Features and FeatureMap. Generally it would be desirable to unify even further, even if it might not be possible to reuse the same fields potentially we could unify the date structures and create some common abstractions for this. Just to be clear, I am not saying we have to do this now or in this patch. However, if we can add some clarifications in the comment here to highlight the differences or even suggest further simplifications in FIXME, that would be great. Perhaps yu have already looked at it and have some insights.

My understanding is that the biggest difference right now that Features are mainly taken from architectural descriptions in LLVM. This could be done for some of OpenCL features but not those that are implemented in software i.e. using libraries. In the future, if we remove such features from Clang as suggested in my RFCs e.g. https://reviews.llvm.org/D91531, the unification between regular Features and OpenCL features might become more pleasable. Another obstacle is SPIR which is a virtual target and has no architecture description. Perhaps we could handle it as a special case it somehow.

69

The name is now inconsistent. We already use extensions and options to refer to these in the code. I don't mind which naming scheme you prefer as soon as we stick to one everywhere.

clang/lib/Basic/Targets/X86.h

362

Calling adjustSupportedOpenCLOpts seems to be required behavior now so how about we make it a default implementation of setSupportedOpenCLOpts in TargetInfo that would call a new member function - say setDefaultSupportedOpenCLOpts, that would be a pure virtual member in TargetInfo but every concrete subclass would need to implement to set the features supported by the specific target?

Or alternatively, subclasses can just call TargetInfo::setSupportedOpenCLOpts in their implementations. It seems the same happens with TargetInfo::initFeatureMap already. However, the first option might be a better match.

[Anastasia]

FYI I just noticed this review is public, but not linked to cfe-commits. Not sure it is intentional though.

[azabaznov]

Thanks for working on this! It is a very good refactoring that brings OpenCL closer inline with convention design flow

Thanks for feedback. Though the patch indeed requires refactoring and can't be merged as it is, but the main idea still will be the same.

This patch looks inaccurate mainly because I tried to preserve existing interaction with command line. So we should decide the following:

• Do we need to allow disabling core features via command line?

• Do we need to allow target disabling core features (NVPTX does so for OpenCL C 2.0 now)?

I personally think that we shouldn't allow doing so in both cases since it violates the specification of OpenCL C 2.0. In this way the change will be much cleaner because we can use only TargetInfo::getOpenCLFeatureDefines( LangOptions) to define macros for core features and set them in OpenCLOptions::addSupport(StringMap<bool> TargetOpts, LangOptions).

Also, I see benefits TargetInfo::setSupportedOpenCLOpts(LangOptions) as follows: targets will set features for each specific OpenCL C version. This may be helpful if target features differentiate between OpenCL C implementations:

if (CLVer == 200) {
 ...
} else if (CLVer == 300) {
 ...
}

But I'm ok to adjust interface if it's not expected to be a common case in general.

[Anastasia]

In D92277#2425416, @azabaznov wrote:

Thanks for working on this! It is a very good refactoring that brings OpenCL closer inline with convention design flow

Thanks for feedback. Though the patch indeed requires refactoring and can't be merged as it is, but the main idea still will be the same.

This patch looks inaccurate mainly because I tried to preserve existing interaction with command line. So we should decide the following:

• Do we need to allow disabling core features via command line?

• Do we need to allow target disabling core features (NVPTX does so for OpenCL C 2.0 now)?

I personally think that we shouldn't allow doing so in both cases since it violates the specification of OpenCL C 2.0. In this way the change will be much cleaner because we can use only TargetInfo::getOpenCLFeatureDefines( LangOptions) to define macros for core features and set them in OpenCLOptions::addSupport(StringMap<bool> TargetOpts, LangOptions).

I agree with you. I think we should focus on conformant behavior. Extensions are allowed but should have justification, and should be documented. Considering that OpenCL 3.0 provides finer-grained control of various functionality I think core features should be fixed in OpenCL 2.0 or any other versions.

Also, I see benefits TargetInfo::setSupportedOpenCLOpts(LangOptions) as follows: targets will set features for each specific OpenCL C version. This may be helpful if target features differentiate between OpenCL C implementations:

if (CLVer == 200) {
 ...
} else if (CLVer == 300) {
 ...
}

But I'm ok to adjust interface if it's not expected to be a common case in general.

I don't see why targets would support on not support certain features based on the language version though. I think targets should generally support some functionality or not based on the hardware or runtime setup and then it might be disabled from the user if standards are requested that don't expose it. I would vote for simplicity unless we find a strong case to justify the complexity.

[azabaznov]

Changes in the latest patch:

1. Core features can't be disabled via command line and target settings, core features are supported based on language version. Thus some tests marked as failed for now. NVPTX and r600 targets should use CL 3.0 since 3d image writes is optional in OpenCL C 3.0.

2. Explicitly differentiate between core and optional core features.

3. Refactoring of extensions info setting: extension info is using OpenCL versions mask to indicate in which versions it is core or optional core (instead of single value as it was earlier).

4. Changed TargetInfo::setSupportedOpenCLOpts interface back to not use LangOptions

[Anastasia]

This looks much cleaner than the current flow! Thanks! We should just figure out a better place for defining the macros (see detailed comment in Targets.cpp).

I am adding @cfe-commits since it's an important change to be visible to the community. Other than that I hope @yaxunl and @jvesely would be able to have a look at the amendment in the setup of AMD and NVPTX targets and notify us in case they see any concerns.

clang/include/clang/Basic/OpenCLExtensions.def

52

We should add a spec reference or a note detailing the differences among those different kinds.

clang/include/clang/Basic/OpenCLOptions.h

67–69

Let's add a comment to document this new enum.

73

Looking at the uses, it might be better to just have a helper function that takes OpenCLVersion and LangOpts instead of introducing a class that is only used as temporary.

132

Btw CLVer is not passed here. Same for the other methods above.

clang/include/clang/Basic/TargetInfo.h

1448

Btw here you could just iterate over the elements in the map? This could be faster than multiple independent look ups into the map. But mainly I think it makes the flow a bit cleaneras it indicated that you only set elements and not add them...

1462

This deserves a comment.

clang/lib/Basic/OpenCLOptions.cpp

24

I think the comment in the header should be enough, otherwise we will struggle to keep them in synch.

89

I feel this is outdated now?

109

Let's add a comment above saying that this adds options supported for the targets.

117

Btw what if the target doesn't support the feature? Do you think we could provide an error?

clang/lib/Basic/Targets.cpp

735

I think we should find different place for those now.

Ideally, we should iterate though the map in OpenCLOptions and set the define for the supported ones.

I suggest we move this into clang::InitializePreprocessor which means Preprocessor might need a reference to OpenCLOptions which is the right thing to do because it needs to know the features that require the macro, the same as for LangOpts. This means we will need to change the initialization time of OpenCLOptions member in Sema or potentially even reparent it elsewhere... perhaps to CompilerInstance where LangOpts and TargetInfo seems to be created already?

clang/test/Misc/nvptx.languageOptsOpenCL.cl

14

We shouldn't disable the test, but only change it to check the conformant behavior i.e. the expected diagnostics for cl_khr_3d_image_writes should be guarded by the OpenCL version.

[yaxunl]

clang/test/Misc/r600.languageOptsOpenCL.cl

20

Pls remove XFAIL

116

what's the expected behavior?

Is cl_khr_3d_image_writes to be always defined for -cl-std=CL2.0?

[azabaznov]

clang/include/clang/Basic/OpenCLOptions.h

67–69

I'm going to change comments all over the place in the next patch. Thanks!

73

Ok, that is reasonable. Will change.

clang/include/clang/Basic/TargetInfo.h

1448

Btw here you could just iterate over the elements in the map

Map is empty at this point. ::supportAllOpenCLOpts adds all elements which are declared in OpenCLExtensions.def into the map.

clang/lib/Basic/OpenCLOptions.cpp

117

I think that if a feature is core than a target must support it, do I miss something?

However, there is a place for such diagnostics for non-core features already: something similar to TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, DiagnosticsEngine &Diags) could be used

clang/lib/Basic/Targets.cpp

735

I suggest we move this into clang::InitializePreprocessor which means

I think I'm going to introduce InitializeOpenCLFeatureTestMacros(TargetInfo, LangOptions) in InitPreprocessor.cpp.

This means we will need to change the initialization time of OpenCLOptions member in Sema or potentially even reparent it elsewhere... perhaps to CompilerInstance where LangOpts and TargetInfo seems to be created already

This seems too invasive for me since CompilerInstance is a different purpose class; and it already holds Sema and TargetInfo. OpenCLOptions should mainly be used for parsing, so I would like to suggest avoiding using it elsewhere. Furthermore, with the proposed flow OpenCLOptions.h can be removed later and some simple helpers can be used to check the availability of features/extensions.

However, I see your point: we have two identical pieces of code in TargetInfo::getOpenCLFeatureDefines and OpenCLOptions::addSupport. I think I'll try to get rid of this duplication by transferring setting of core features into TargetInfo::adjust which seems pretty right thing to do. What do you think?

clang/test/Misc/r600.languageOptsOpenCL.cl

20

Sure. I'll guard this #ifndef check with OpenCL version in existing tests; but however, I think adding new tests with XFAIL for r600 and NVPTX (where #ifndef check fails) seems reasonable to me. What do you think?

116

Yes, 3d image writes is OpenCL C 2.0 core feature.

[yaxunl]

clang/test/Misc/r600.languageOptsOpenCL.cl

20

I think it may be reasonable to remove the run line for CL2.0 and corresponding checks for 2.0 specific core features/extensions from this lit test since r600 does not support CL2.0.

[azabaznov]

Changes in the latest patch:

1. Removed XFAIL and OpenCL C 2.0 test running for r600 and NVPTX target

2. Fixed comments.

3. Core features are being set in TargetInfo::adjust.

[azabaznov]

clang/include/clang/Basic/TargetInfo.h

1438

I'll change the naming in changes for OpenCL C 3.0 features.

[yaxunl]

LGTM about r600 changes. Thanks.

[Anastasia]

This patch contains very useful improvements to the design along with the behavioral fixes. I see that it opens more opportunities to bring the implementation in line with the conventional flow and therefore simplify the further development of new functionality. More improvements can be easily built on top of this work. I, therefore, suggest we drive towards finalizing this patch asap and I have made a couple of small comments that should hopefully be quick enough to address.

clang/include/clang/Basic/OpenCLExtensions.def

15–16

I guess you mean that this extension is not against a specific version i.e. applies to all versions?

67

FYI not saying this should be changed now because it is sufficient for the current needs but perhaps we could do something like

OPENCL_GENERIC_EXTENSION(cl_khr_3d_image_writes, 100, {OCL_C_20, OCL_C_31}, {OCL_C_30})

if we start having non-continuous set of versions where a feature is optional or core.

81

Is this code accidental? The following extensions cl_khr_subgroup_* were recently removed from this file.

https://github.com/llvm/llvm-project/blob/main/clang/include/clang/Basic/OpenCLExtensions.def

clang/include/clang/Basic/OpenCLOptions.h

70

I suggest putting this in an anonymous namespace along with encodeOpenCLVersion and OpenCLVersionIsContainedInMask, as they are only to be used locally.

97

A small renaming
OpenCLVersionIsContainedInMask -> isOpenCLVersionContainedInMask

100–101

I think it would be better to keep it in OpenCLOptions, as we don't intend this to be used stand-alone also considering that it's a struct? I understand that this is now being used in Targets too but that use should hopefully be eliminated in the future.

120–123

I think this map deserves type alias since it's used in quite many places.

clang/lib/Basic/OpenCLOptions.cpp

97

Maybe this could also be switched to a range based loop along with the one below.

clang/lib/Basic/TargetInfo.cpp

360 ↗

(On Diff #316627)

I still think the target map should be immutable and especially we should not change it silently based on the language compiled even if we have done it before but that caused incorrect behavior i.e. successfully compiling for the architectures that didn't support the features.

If I look at existing targets they already set most of the core features apart from 3d image writes. Perhaps it is reasonable to just drop this code? I don't think it makes the issue worse, in fact, I think it will make the behavior slightly better because now a diagnostic will occur if there is an attempt to use the unsupported feature although the diagnostic won't be the optimal one. After all it will still remain the responsibility of the user to get the right combination of a language version and a target.

It would be reasonable however to introduce a diagnostic that would report a mismatch between the language version and the hardware support available. We report similar diagnostics in CompilerInvocation already. But I don't think we have to do it in this patch because it doesn't introduce any regression. We already have a bug although the behavior of this bug will change. And perhaps if we add OpenCLOptions as a part of LangOpts at some point this will become straightforward to diagnose. However, I suggest we add information about this issue in a FIXME or perhaps this deserves a clang bug!

clang/lib/Basic/Targets.cpp

728

I still think it would be better if we just iterate over the elements in this map? We should keep the includes of clang/Basic/OpenCLExtensions.def to a minimum.

730

I think this defines should belong elsewhere, this will eliminate the need to create the temporary object OpenCLOptionInfo. But I appreciate there is only limited amount of refactoring we can do in one patch.

How about we at least add a FIXME explaining that some further refactoring is needed to move the macro definition with the rest of macros from LangOpts.

735

This seems too invasive for me since CompilerInstance is a different purpose class; and it already holds Sema and TargetInfo. OpenCLOptions should mainly be used for parsing, so I would like to suggest avoiding using it elsewhere.

Yes, it is a bigger change I agree. But it is closer to the conventional flow in my opinion. This is how it works for LangOpts and OpenCLOpts don't seem to be different to LangOpts, especially now after your refactoring. Perhaps we should just move OpenCLOpts to LangOpts? Then Sema can access OpenCLOpts through LangOpts as well as modify them because they are immutable. We can then just add the defines along with the rest of LangOpts in clang::InitializePreprocessor.

If you look at CompilerInvocation then you will see that while LangOpts are set TargetInfo are also taken into account. Then LangOpts are modified using pragmas for example in Parser::HandlePragmaFPContract().

Furthermore, with the proposed flow OpenCLOptions.h can be removed later and some simple helpers can be used to check the availability of features/extensions.

Ok, this would also be a nice alternative but we will still need to store information about optional/core versions and etc somewhere? Would it not be needed for pragmas?

[azabaznov]

clang/include/clang/Basic/OpenCLExtensions.def

15–16

Yeah, this is needed to enumerate all extensions (as it was earlier). I only changed the naming of macro in this patch, I'll adjust the comment.

81

Yes, thanks for noticing. This got here accidentally after rebasing.

clang/include/clang/Basic/OpenCLOptions.h

97

Sure, will change.

100–101

This check is needed to check availability of extensions (see comment in Targets.cpp). Or you mean to define it as a nested class in OpenCLOptions?

clang/lib/Basic/TargetInfo.cpp

360 ↗

(On Diff #316627)

I still think the target map should be immutable and especially we should not change it silently based on the language compiled

I'm confused. I think we have agreed to unconditionally support core features for a specific language version. Did I miss something?

successfully compiling for the architectures that didn't support the features.

I like idea providing diagnostics in that case. Something like: "Warning: r600 target doesn't support 
cl_khr_3d_image_writes which is core in OpenCL C 2.0, consider using OpenCL C 3.0". I also think this should be done in a separate commit.

If I look at existing targets they already set most of the core features apart from 3d image writes. Perhaps it is reasonable to just drop this code?

Oh, I haven't noticed that target set core features. For example cl_khr_global_int32_base_atomics is being set by NVPTX and AMDGPU, so I agree that this should be removed from target settings.

clang/lib/Basic/Targets.cpp

728

This is to check if extension/feature is available (by calling OpenCLOptionInfo::isAvailableIn(LangOpts)). For example, cl_khr_srgb_image_writes (which is available only in OpenCL C 2.0) can be supported via command  line for OpenCL C 1.2 which is erroneous.  Information about availability of an extension is stored in OpenCLExtensions.def.

730

this will eliminate the need to create the temporary object OpenCLOptionInfo

This temporary object is needed to check availability of extension (see comment above).

735

Perhaps we should just move OpenCLOpts to LangOpts?

Hmm, this sounds cool. I've never thought of it and this requires some extra investigation.

Ok, this would also be a nice alternative but we will still need to store information about optional/core versions and etc somewhere? Would it not be needed for pragmas?

Well, since there are not a few extensions which participate in parsing (require pragma) we can keep a separate structure for them. Originally my idea was to simplify OpenCLOptions for parsing purposes, so we might not to fully eliminate it.

[Anastasia]

clang/include/clang/Basic/OpenCLOptions.h

100–101

Or you mean to define it as a nested class in OpenCLOptions?

Exactly.

clang/lib/Basic/TargetInfo.cpp

360 ↗

(On Diff #316627)

It is correct that the core features should be set unconditionally but not in the TargetInfo. If core features are used for targets that don't support them then it should not succeed silently as it does now i.e. this means we need to know what is supported by the targets.

Setting target features in TargetInfo is correct and should stay. We should not change them here though because the language version doesn't change the target capabilities. It can either expose or hide them from the user but it should not modify targets. This is why TargetInfo is immutable after its creation and this is how it should stay. I think it's better if we remove the code here completely and introduce a diagnostic in the subsequent patches that would just check that the features required in the language version are supported by the target.

If we do this then during the parsing we will only use feature information from OpenCLOptions not the targets, but we will know that the target have support of all the features because the check has been performed earlier.

clang/lib/Basic/Targets.cpp

728

Ok, we can't do this now because OpenCLFeaturesMap is indeed simpler. Hopefully, we can change this in subsequent refactorings if we move OpenCLOptions into LangOpts.

730

Yes I understand. That's why I believe these macros should no longer be defined in the targets and I think it is very doable to avoid this but it requires some more changes (i.e. moving OpenCLOptions into LangOpts). So for now we can leave a FIXME comment to explain the issue.

[azabaznov]

clang/lib/Basic/TargetInfo.cpp

360 ↗

(On Diff #316627)

I'm not generally against of removing core features set up, but I do have some questions and arguments:

It is correct that the core features should be set unconditionally but not in the TargetInfo

Just to make sure: where do you mean core features should be set unconditionally? 

Setting target features in TargetInfo is correct and should stay. We should not change them here though because the language version doesn't change the target capabilities. It can either expose or hide them from the user but it should not modify targets. This is why TargetInfo is immutable after its creation and this is how it should stay

I agree that TargetInfo should stay immutable during parsing, but for example here, in TargetInfo::adjust, current design already allows to change target capabilities based on language options, so I don't see what is conceptually wrong here.

If core features are used for targets that don't support them then it should not succeed silently as it does now i.e. this means we need to know what is supported by the targets.

My main point in proposed design is that it is closer to specification: if target reports support for OpenCL C 2.0 then there is no need to extra checking for support of core features such as 3d image writes (we could also set for example generic address space and pipes as supported unconditionally later) as it is core in OpenCL C 2.0. Of course this should not be done silently; some diagnostics like fatal error "OpenCL C 2.0 is not supported in this target" or warning "core feature cl_khr_3d_image_writes is not supported in this target".

[azabaznov]

clang/lib/Basic/TargetInfo.cpp

360 ↗

(On Diff #316627)

then there is no need to extra checking for support of core features

I mean extra checks in compiler, not in kernel code.

[Anastasia]

clang/lib/Basic/TargetInfo.cpp

360 ↗

(On Diff #316627)

Just to make sure: where do you mean core features should be set unconditionally?

Why not to set them in OpenCLOptions directly? If you don't need any target properties for those why to do this in targets at all? After all OpenCLFeaturesMap will only be used to populate the OpenCLOptions. During the parsing, we will only use OpenCLOptions right?

I agree that TargetInfo should stay immutable during parsing, but for example here, in TargetInfo::adjust, current design already allows to change target capabilities based on language options, so I don't see what is conceptually wrong here.

Well, adjust was added to guarantee type widths for OpenCL. However, it has been introduced as a workaround and it still is. It has that fundamental problem of silently mutating the type without any guarantee of integrity i.e. what if targets doesn't support certain bitwidth? Then the code is just compiled incorrectly. There were various proposals to address this but it needs bigger refactoring - perhaps we should introduce the environment component for OpenCL. While for this use case the refactoring is too big and the workaround is very simple there are other places in clang where we could benefit from having such environment component in targets. So the gain might justify the effort. So in short unless there is a very good reason we should avoid using adjust because we still would like to remove it or at least remove OpenCL logic from it if possible.

My main point in proposed design is that it is closer to specification: if target reports support for OpenCL C 2.0 then there is no need to extra checking for support of core features such as 3d image writes (we could also set for example generic address space and pipes as supported unconditionally later) as it is core in OpenCL C 2.0. Of course this should not be done silently; some diagnostics like fatal error "OpenCL C 2.0 is not supported in this target" or warning "core feature cl_khr_3d_image_writes is not supported in this target".

I disagree spec never says that the standard should be supported on all targets even if they don't have the required functionality neither it regulate implementation aspects of mapping between language versions to targets.

I think the design we should aim for:

• Targets set supported HW features
• Frontend verifies the features are present for the language version requested during compilation. If there is a mismatch a diagnostic should occur.
• Frontend sets language options based on the requested language version and target features that are used during parsing to verify code correctness and create AST.

Do you see any issue with this flow?

[azabaznov]

clang/lib/Basic/TargetInfo.cpp

360 ↗

(On Diff #316627)

Why not to set them in OpenCLOptions directly? If you don't need any target properties for those why to do this in targets at all? After all OpenCLFeaturesMap will only be used to populate the OpenCLOptions. During the parsing, we will only use OpenCLOptions right?

We also need to add preprocessor define for these extensions so we should look into OpenCLFeaturesMap to add preprocessor defines because target could disable core feature (see my comment below).

I disagree spec never says that the standard should be supported on all targets even if they don't have the required functionality neither it regulate implementation aspects of mapping between language versions to targets.

Well, I think we start going in circles. This was actually my understanding of the difference between optional core and core features - the latter is required to be supported for all implementations from the version when it becomes core (unconditionally). Is my understanding right here? However, there is no clear stating about core features in the spec, this should definitely be added.

Do you see any issue with this flow?

This looks great. In terms of implementation I suggest doing the following: core features are supported unconditionally for certain OpenCL C version, but targets are allowed to disable them:

bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
...
  if (getLangOpts().OpenCL) {
    getTarget().setCoreOpenCLFeatures(getLangOpts());
    getTarget().setSupportedOpenCLOpts();
    getTarget().setCommandLineOpenCLOpts();
  }
  // FIXME: We shouldn't need to do this, the target should be immutable once
  // created. This complexity should be lifted elsewhere.
  getTarget().adjust(getLangOpts());
...
}

...

void AMDGPUTargetInfo::setSupportedOpenCLOpts() {
  // Core feature in CL 2.0, but not supported on amdgpu
  Opts["cl_khr_3d_image_writes"] = false;
  ...
}

Of course proposed flow is relevant if and only if core features concept is correctly interpreted. This will give more flexibility for targets and will also allow to do diagnostics later. Also, this will help to unconditionally support such core features for OpenCL C 2.0 as generic address space and pipes etc. when implementing OpenCL C 3.0. What do you think?

[Anastasia]

clang/lib/Basic/TargetInfo.cpp

360 ↗

(On Diff #316627)

We also need to add preprocessor define for these extensions so we should look into OpenCLFeaturesMap to add preprocessor defines because target could disable core feature (see my comment below).

Yes, this is because the macro definition is not correctly positioned. We should be able to lift that into clang::InitializePreprocessor with the subsequent changes as discussed earlier. Then we will no longer have this issue.

Well, I think we start going in circles. This was actually my understanding of the difference between optional core and core features - the latter is required to be supported for all implementations from the version when it becomes core (unconditionally). Is my understanding right here? However, there is no clear stating about core features in the spec, this should definitely be added.

I think we have attempted to but it has not been completed, so feel free to provide your feedback https://github.com/KhronosGroup/OpenCL-Docs/issues/500.

However, I feel you are conflating the specification wording that regulates conformant implementation behavior with the implementation detail of supporting various targets that don't necessarily support all standards.

This looks great. In terms of implementation I suggest doing the following: core features are supported unconditionally for certain OpenCL C version, but targets are allowed to disable them:

bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
...

if (getLangOpts().OpenCL) {
  getTarget().setCoreOpenCLFeatures(getLangOpts());
  getTarget().setSupportedOpenCLOpts();
  getTarget().setCommandLineOpenCLOpts();
}
// FIXME: We shouldn't need to do this, the target should be immutable once
// created. This complexity should be lifted elsewhere.
getTarget().adjust(getLangOpts());

...
}

...

void AMDGPUTargetInfo::setSupportedOpenCLOpts() {

// Core feature in CL 2.0, but not supported on amdgpu
Opts["cl_khr_3d_image_writes"] = false;
...

}

If we can make the flow straightforward why would we instead make it twisty? I think after your patch it should be very straightforward to just lift OpenCLOptions in the correct place and fix the macro definitions. I don't see what we gain from setting unsupported features to supported? If the wrong language version is being used for the target it is an incorrect case and the compilation should not be allowed or if it does it can be anything. At least if we don't set the unsupported features some errors are likely to occur if unsupported features are used in the kernel code. Otherwise the parsing just succeeds silently.

Of course, the best way is to provide a dedicated diagnostic and we have done it in Clang for a decade. All the mechanics is in place we just need to fix our flow.

Of course proposed flow is relevant if and only if core features concept is correctly interpreted. This will give more flexibility for targets and will also allow to do diagnostics later. Also, this will help to unconditionally support such core features for OpenCL C 2.0 as generic address space and pipes etc. when implementing OpenCL C 3.0. What do you think?

I am not suggesting by any means to implement non-conformant behavior. I think we should add the features to targets individually for now for OpenCL3.0 because there shouldn't too many? But I think we will be able to do the final fix to correct the flow soon, then we will have more options to avoid duplications (if we need to) and especially to add the correctness checks and the diagnostics.

[azabaznov]

Thanks for feedback. I agree that providing diagnostics for unsupported core features is enough for now (I guess I'll try to come up with something for OpenCL C 3.0 features to set them unconditionally for 2.0, or at least these macros can be defined in header only). So I removed setting of core features (and also addressed all cosmetic concerns).

[Anastasia]

LGTM! Thanks! Great work! The comment can be addressed before committing.

clang/include/clang/Basic/OpenCLOptions.h

165

I think we no longer need this? If so I suggest removing the function and if needed it can be added later?

clang/test/Misc/nvptx.languageOptsOpenCL.cl

9

We should try to remember restoring some of these RUN lines once we have enough OpenCL 3.0 functionality.

[azabaznov]

Removed getCoreFeatures() as it's not used in this change.

[azabaznov]

clang/test/Misc/nvptx.languageOptsOpenCL.cl

14

Yeah, sure. This won't a problem in this case as these test contain OpenCL C 1.2 runs. OpenCL C 3.0 is backward compatible with OpenCL C 1.2 so all 1.2 runs should be tested together with 3.0.

[Anastasia]

Cool. Thanks!

clang/include/clang/Basic/OpenCLExtensions.def

 //===--- OpenCLExtensions.def - OpenCL extension list -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the list of supported OpenCL extensions.
 //
 //===----------------------------------------------------------------------===//
 
-// Macro OPENCLEXT or OPENCLEXT_INTERNAL can be defined to enumerate the
+// Macro OPENCLEXTNAME or OPENCL_GENERIC_EXTENSION can be defined to enumerate all
 // OpenCL extensions listed in this file.
 //
-// If the extensions are to be enumerated without the supported OpenCL version,
-// define OPENCLEXT(ext) where ext is the name of the extension.
-//
-// If the extensions are to be enumerated with supported OpenCL version,
-// define OPENCLEXT_INTERNAL(ext, avail, core) where
+// If extensions are to be enumerated with information about whether
+// an extension is core or optional core and minimum OpenCL version
+// when an extension becomes available,
+// define OPENCL_GENERIC_EXTENSION(ext, avail, core, opt) where
 //   ext - name of the extension or optional core feature.
 //   avail - minimum OpenCL version supporting it.
-//   core - minimum OpenCL version when the extension becomes optional core
-//          feature or core feature. ~0U indicates not a core feature or an
-//          optional core feature.
+//   core - OpenCL versions mask when the extension becomes core feature.
+//          0U indicates not a core feature.
+//   opt - OpenCL versions mask when the extension becomes optional core
+//         feature. 0U indicates not a optional core feature.
+//
+// If extensions are to be enumerated without any information,
+// define OPENCLEXTNAME(ext) where ext is the name of the extension.
+//
+// Difference between optional core feature and core feature is that the 
+// later is unconditionally supported in specific OpenCL version.
 //
 // As per The OpenCL Extension Specification, Section 1.2, in this file, an
 // extension is defined if and only it either:
 //  * affects the OpenCL language semantics or its syntax,
 //  * adds built-in functions to the language.
 //
 // For such an extension, a preprocessor #define that matches the extension
 // name must be created and a #pragma is required if and only if the
 // compilation flow is impacted, e.g. due to a difference of syntax or
-// semantics in the language compared to the core standard.
+// semantics in the language compared to the core standard. #pragma directive
+// has no effect for optional core and core features.
 
-#ifndef OPENCLEXT_INTERNAL
-#ifndef OPENCLEXT
-#pragma error "macro OPENCLEXT or OPENCLEXT_INTERNAL is required"
+#ifndef OPENCL_GENERIC_EXTENSION
+#ifndef OPENCLEXTNAME
+#pragma error "macro OPENCLEXTNAME or OPENCL_GENERIC_EXTENSION is required"
 #else
-#define OPENCLEXT_INTERNAL(ext, ...) OPENCLEXT(ext)
-#endif // OPENCLEXT
-#endif // OPENCLEXT_INTERNAL
+#define OPENCL_GENERIC_EXTENSION(ext, ...) OPENCLEXTNAME(ext)
+#endif // OPENCLEXTNAME
+#endif // OPENCL_GENERIC_EXTENSION
+
+// Declaration helpers
+#define OPENCL_EXTENSION(ext, avail) OPENCL_GENERIC_EXTENSION(ext, avail, 0U, 0U)
+#define OPENCL_COREFEATURE(ext, avail, core)  OPENCL_GENERIC_EXTENSION(ext, avail, core, 0U)
+#define OPENCL_OPTIONALCOREFEATURE(ext, avail, opt) OPENCL_GENERIC_EXTENSION(ext, avail, 0U, opt)
 
 // OpenCL 1.0.
-OPENCLEXT_INTERNAL(cl_khr_3d_image_writes, 100, 200)
-OPENCLEXT_INTERNAL(cl_khr_byte_addressable_store, 100, 110)
-OPENCLEXT_INTERNAL(cl_khr_fp16, 100, ~0U)
-OPENCLEXT_INTERNAL(cl_khr_fp64, 100, 120)
-OPENCLEXT_INTERNAL(cl_khr_global_int32_base_atomics, 100, 110)
-OPENCLEXT_INTERNAL(cl_khr_global_int32_extended_atomics, 100, 110)
-OPENCLEXT_INTERNAL(cl_khr_local_int32_base_atomics, 100, 110)
-OPENCLEXT_INTERNAL(cl_khr_local_int32_extended_atomics, 100, 110)
-OPENCLEXT_INTERNAL(cl_khr_int64_base_atomics, 100, ~0U)
-OPENCLEXT_INTERNAL(cl_khr_int64_extended_atomics, 100, ~0U)
+OPENCL_COREFEATURE(cl_khr_byte_addressable_store, 100, OCL_C_11P)
+OPENCL_COREFEATURE(cl_khr_global_int32_base_atomics, 100, OCL_C_11P)
+OPENCL_COREFEATURE(cl_khr_global_int32_extended_atomics, 100, OCL_C_11P)
+OPENCL_COREFEATURE(cl_khr_local_int32_base_atomics, 100, OCL_C_11P)
+OPENCL_COREFEATURE(cl_khr_local_int32_extended_atomics, 100, OCL_C_11P)
+OPENCL_OPTIONALCOREFEATURE(cl_khr_fp64, 100, OCL_C_12P)
+OPENCL_EXTENSION(cl_khr_fp16, 100)
+OPENCL_EXTENSION(cl_khr_int64_base_atomics, 100)
+OPENCL_EXTENSION(cl_khr_int64_extended_atomics, 100)
+OPENCL_GENERIC_EXTENSION(cl_khr_3d_image_writes, 100, OCL_C_20, OCL_C_30)
 
 // EMBEDDED_PROFILE
-OPENCLEXT_INTERNAL(cles_khr_int64, 110, ~0U)
+OPENCL_EXTENSION(cles_khr_int64, 110)
 
 // OpenCL 1.2.
-OPENCLEXT_INTERNAL(cl_khr_depth_images, 120, ~0U)
-OPENCLEXT_INTERNAL(cl_khr_gl_msaa_sharing, 120, ~0U)
+OPENCL_EXTENSION(cl_khr_depth_images, 120)
+OPENCL_EXTENSION(cl_khr_gl_msaa_sharing, 120)
 
 // OpenCL 2.0.
-OPENCLEXT_INTERNAL(cl_khr_mipmap_image, 200, ~0U)
-OPENCLEXT_INTERNAL(cl_khr_mipmap_image_writes, 200, ~0U)
-OPENCLEXT_INTERNAL(cl_khr_srgb_image_writes, 200, ~0U)
-OPENCLEXT_INTERNAL(cl_khr_subgroups, 200, ~0U)
+OPENCL_EXTENSION(cl_khr_mipmap_image, 200)
+OPENCL_EXTENSION(cl_khr_mipmap_image_writes, 200)
+OPENCL_EXTENSION(cl_khr_srgb_image_writes, 200)
+OPENCL_EXTENSION(cl_khr_subgroups, 200)
 
 // Clang Extensions.
-OPENCLEXT_INTERNAL(cl_clang_storage_class_specifiers, 100, ~0U)
-OPENCLEXT_INTERNAL(__cl_clang_function_pointers, 100, ~0U)
-OPENCLEXT_INTERNAL(__cl_clang_variadic_functions, 100, ~0U)
+OPENCL_EXTENSION(cl_clang_storage_class_specifiers, 100)
+OPENCL_EXTENSION(__cl_clang_function_pointers, 100)
+OPENCL_EXTENSION(__cl_clang_variadic_functions, 100)
 
 // AMD OpenCL extensions
-OPENCLEXT_INTERNAL(cl_amd_media_ops, 100, ~0U)
-OPENCLEXT_INTERNAL(cl_amd_media_ops2, 100, ~0U)
+OPENCL_EXTENSION(cl_amd_media_ops, 100)
+OPENCL_EXTENSION(cl_amd_media_ops2, 100)
 
 // ARM OpenCL extensions
-OPENCLEXT_INTERNAL(cl_arm_integer_dot_product_int8, 120, ~0U)
-OPENCLEXT_INTERNAL(cl_arm_integer_dot_product_accumulate_int8, 120, ~0U)
-OPENCLEXT_INTERNAL(cl_arm_integer_dot_product_accumulate_int16, 120, ~0U)
-OPENCLEXT_INTERNAL(cl_arm_integer_dot_product_accumulate_saturate_int8, 120, ~0U)
+OPENCL_EXTENSION(cl_arm_integer_dot_product_int8, 120)
+OPENCL_EXTENSION(cl_arm_integer_dot_product_accumulate_int8, 120)
+OPENCL_EXTENSION(cl_arm_integer_dot_product_accumulate_int16, 120)
+OPENCL_EXTENSION(cl_arm_integer_dot_product_accumulate_saturate_int8, 120)
 
 // Intel OpenCL extensions
-OPENCLEXT_INTERNAL(cl_intel_subgroups, 120, ~0U)
-OPENCLEXT_INTERNAL(cl_intel_subgroups_short, 120, ~0U)
-OPENCLEXT_INTERNAL(cl_intel_device_side_avc_motion_estimation, 120, ~0U)
+OPENCL_EXTENSION(cl_intel_subgroups, 120)
+OPENCL_EXTENSION(cl_intel_subgroups_short, 120)
+OPENCL_EXTENSION(cl_intel_device_side_avc_motion_estimation, 120)
+
 
-#undef OPENCLEXT_INTERNAL
+#undef OPENCL_OPTIONALCOREFEATURE
+#undef OPENCL_COREFEATURE
+#undef OPENCL_GENERIC_EXTENSION
 
-#ifdef OPENCLEXT
-#undef OPENCLEXT
+#ifdef OPENCLEXTNAME
+#undef OPENCLEXTNAME
 #endif

clang/include/clang/Basic/OpenCLOptions.h

 #ifndef LLVM_CLANG_BASIC_OPENCLOPTIONS_H
 #define LLVM_CLANG_BASIC_OPENCLOPTIONS_H
 
 #include "clang/Basic/LangOptions.h"
 #include "llvm/ADT/StringMap.h"
 
 namespace clang {
 
-/// OpenCL supported extensions and optional core features
-class OpenCLOptions {
-  struct Info {
-    bool Supported; // Is this option supported
-    bool Enabled;   // Is this option enabled
-    unsigned Avail; // Option starts to be available in this OpenCL version
-    unsigned Core;  // Option becomes (optional) core feature in this OpenCL
-                    // version
-    Info(bool S = false, bool E = false, unsigned A = 100, unsigned C = ~0U)
-      :Supported(S), Enabled(E), Avail(A), Core(C){}
-  };
-  llvm::StringMap<Info> OptMap;
-public:
-  /// Check if \c Ext is a recognized OpenCL extension.
-  ///
-  /// \param Ext - Extension to look up.
-  /// \returns \c true if \c Ext is known, \c false otherwise.
-  bool isKnown(llvm::StringRef Ext) const {
-    return OptMap.find(Ext) != OptMap.end();
-  }
+namespace {
+// This enum maps OpenCL version(s) into value. These values are used as
+// a mask to indicate in which OpenCL version(s) extension is a core or
+// optional core feature.
+enum OpenCLVersionID : unsigned int {
+  OCL_C_10 = 0x1,
+  OCL_C_11 = 0x2,
+  OCL_C_12 = 0x4,
+  OCL_C_20 = 0x8,
+  OCL_C_30 = 0x10,
+  OCL_C_ALL = 0x1f,
+  OCL_C_11P = OCL_C_ALL ^ OCL_C_10,              // OpenCL C 1.1+
+  OCL_C_12P = OCL_C_ALL ^ (OCL_C_10 | OCL_C_11), // OpenCL C 1.2+
 
-  /// Check if \c Ext is an enabled OpenCL extension.
-  ///
-  /// \param Ext - Extension to look up.
-  /// \returns \c true if \c Ext is known and enabled, \c false otherwise.
-  bool isEnabled(llvm::StringRef Ext) const {
-    auto E = OptMap.find(Ext);
-    return E != OptMap.end() && E->second.Enabled;
+static inline OpenCLVersionID encodeOpenCLVersion(unsigned OpenCLVersion) {
+  switch (OpenCLVersion) {
+  default:
+    llvm_unreachable("Unknown OpenCL version code");
+  case 100:
+    return OCL_C_10;
+  case 110:
+    return OCL_C_11;
+  case 120:
+    return OCL_C_12;
+  case 200:
+    return OCL_C_20;
+  case 300:
+    return OCL_C_30;
   }
-
-  /// Check if \c Ext is supported as either an extension or an (optional) core
-  /// feature for the given OpenCL version.
-  ///
-  /// \param Ext - Extension to look up.
-  /// \param LO - \c LangOptions specifying the OpenCL version.
-  /// \returns \c true if \c Ext is known and supported, \c false otherwise.
-  bool isSupported(llvm::StringRef Ext, const LangOptions &LO) const {
-    auto E = OptMap.find(Ext);
-    if (E == OptMap.end()) {
-      return false;
-    }
-    // In C++ mode all extensions should work at least as in v2.0.
-    auto CLVer = LO.OpenCLCPlusPlus ? 200 : LO.OpenCLVersion;
-    auto I = E->getValue();
-    return I.Supported && I.Avail <= CLVer;
-  }
+
+// Simple helper to check if OpenCL C version is contained in a given encoded
+// OpenCL C version mask
+static inline bool isOpenCLVersionIsContainedInMask(const LangOptions &LO,
+                                                    unsigned Mask) {
+  OpenCLVersionID Code = encodeOpenCLVersion(CLVer);
+  return Mask & Code;
+} // end anonymous namespace
 
-  /// Check if \c Ext is supported as an (optional) OpenCL core features for
-  /// the given OpenCL version.
-  ///
-  /// \param Ext - Extension to look up.
-  /// \param LO - \c LangOptions specifying the OpenCL version.
-  /// \returns \c true if \c Ext is known and supported, \c false otherwise.
-  bool isSupportedCore(llvm::StringRef Ext, const LangOptions &LO) const {
-    auto E = OptMap.find(Ext);
-    if (E == OptMap.end()) {
-      return false;
-    }
+/// OpenCL supported extensions and optional core features
+class OpenCLOptions {
+public:
+  struct OpenCLOptionInfo {
+    // Option starts to be available in this OpenCL version
+    unsigned Avail;
+
+    // Option becomes core feature in this OpenCL versions
+    unsigned Core;
+
+    // Option becomes optional core feature in this OpenCL versions
+    unsigned Opt;
+
+    // Is this option supported
+    bool Supported = false;
+
+    // Is this option enabled
+    bool Enabled = false;
+
+    OpenCLOptionInfo(unsigned A = 100, unsigned C = 0U, unsigned O = 0U)
+        : Avail(A), Core(C), Opt(O) {}
+
+    bool isCore() const { return Core != 0U; }
+
+    bool isOptionalCore() const { return Opt != 0U; }
+
+    // Is option available in OpenCL version \p LO.
+    bool isAvailableIn(const LangOptions &LO) const {
       // In C++ mode all extensions should work at least as in v2.0.
       auto CLVer = LO.OpenCLCPlusPlus ? 200 : LO.OpenCLVersion;
-    auto I = E->getValue();
-    return I.Supported && I.Avail <= CLVer && I.Core != ~0U && CLVer >= I.Core;
+      return CLVer >= Avail;
     }
 
-  /// Check if \c Ext is a supported OpenCL extension for the given OpenCL
-  /// version.
-  ///
-  /// \param Ext - Extension to look up.
-  /// \param LO - \c LangOptions specifying the OpenCL version.
-  /// \returns \c true if \c Ext is known and supported, \c false otherwise.
-  bool isSupportedExtension(llvm::StringRef Ext, const LangOptions &LO) const {
-    auto E = OptMap.find(Ext);
-    if (E == OptMap.end()) {
-      return false;
-    }
-    // In C++ mode all extensions should work at least as in v2.0.
-    auto CLVer = LO.OpenCLCPlusPlus ? 200 : LO.OpenCLVersion;
-    auto I = E->getValue();
-    return I.Supported && I.Avail <= CLVer && (I.Core == ~0U || CLVer < I.Core);
+    // Is core option in OpenCL version \p LO.
+    bool isCoreIn(const LangOptions &LO) const {
+      return isAvailableIn(LO) && isOpenCLVersionIsContainedInMask(LO, Core);
     }
 
-  void enable(llvm::StringRef Ext, bool V = true) {
-    OptMap[Ext].Enabled = V;
+    // Is optional core option in OpenCL version \p LO.
+    bool isOptionalCoreIn(const LangOptions &LO) const {
+      return isAvailableIn(LO) && isOpenCLVersionIsContainedInMask(LO, Opt);
     }
+  };
 
-  /// Enable or disable support for OpenCL extensions
-  /// \param Ext name of the extension optionally prefixed with
-  ///        '+' or '-'
-  /// \param V used when \p Ext is not prefixed by '+' or '-'
-  void support(llvm::StringRef Ext, bool V = true) {
-    assert(!Ext.empty() && "Extension is empty.");
+  bool isKnown(llvm::StringRef Ext) const;
 
-    switch (Ext[0]) {
-    case '+':
-      V = true;
-      Ext = Ext.drop_front();
-      break;
-    case '-':
-      V = false;
-      Ext = Ext.drop_front();
-      break;
-    }
+  bool isEnabled(llvm::StringRef Ext) const;
 
-    if (Ext.equals("all")) {
-      supportAll(V);
-      return;
-    }
-    OptMap[Ext].Supported = V;
-  }
+  // 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;
 
-  OpenCLOptions(){
-#define OPENCLEXT_INTERNAL(Ext, AvailVer, CoreVer) \
-    OptMap[#Ext].Avail = AvailVer; \
-    OptMap[#Ext].Core = CoreVer;
-#include "clang/Basic/OpenCLExtensions.def"
-  }
+  // 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 OpenCLOptions &Opts) {
-    for (auto &I:Opts.OptMap)
-      if (I.second.Supported)
-        OptMap[I.getKey()].Supported = true;
-  }
+  // Is supported optional core OpenCL feature for OpenCL version \p LO.
+  // For supported extension, return false.
+  bool isSupportedOptionalCore(llvm::StringRef Ext,
+                               const LangOptions &LO) const;
 
-  void copy(const OpenCLOptions &Opts) {
-    OptMap = Opts.OptMap;
-  }
+  // Is supported optional core or core OpenCL feature for OpenCL version \p
+  // LO. For supported extension, return false.
+  bool isSupportedCoreOrOptionalCore(llvm::StringRef Ext,
+                                     const LangOptions &LO) const;
 
-  // Turn on or off support of all options.
-  void supportAll(bool On = true) {
-    for (llvm::StringMap<Info>::iterator I = OptMap.begin(),
-         E = OptMap.end(); I != E; ++I)
-      I->second.Supported = On;
-  }
+  // Is supported OpenCL extension for OpenCL version \p LO.
+  // For supported core or optional core feature, return false.
+  bool isSupportedExtension(llvm::StringRef Ext, const LangOptions &LO) const;
 
-  void disableAll() {
-    for (llvm::StringMap<Info>::iterator I = OptMap.begin(),
-         E = OptMap.end(); I != E; ++I)
-      I->second.Enabled = false;
-  }
+  void enable(llvm::StringRef Ext, bool V = true);
 
-  void enableSupportedCore(LangOptions LO) {
-    for (llvm::StringMap<Info>::iterator I = OptMap.begin(), E = OptMap.end();
-         I != E; ++I)
-      if (isSupportedCore(I->getKey(), LO))
-        I->second.Enabled = true;
-  }
+  /// Enable or disable support for OpenCL extensions
+  /// \param Ext name of the extension (not prefixed with '+' or '-')
+  /// \param V value to set for a extension
+  void support(llvm::StringRef Ext, bool V = true);
+
+  OpenCLOptions();
+  OpenCLOptions(const OpenCLOptions &) = default;
+
+  // Set supported options based on target settings and language version
+  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);
 
   friend class ASTWriter;
   friend class ASTReader;
+
+  using OpenCLOptionInfoMap = llvm::StringMap<OpenCLOptionInfo>;
+
+private:
+  OpenCLOptionInfoMap OptMap;
 };
 
 } // end namespace clang
 
 #endif

clang/include/clang/Basic/TargetInfo.h

   checkCFProtectionReturnSupported(DiagnosticsEngine &Diags) const;
 
   /// Whether target allows to overalign ABI-specified preferred alignment
   virtual bool allowsLargerPreferedTypeAlignment() const { return true; }
 
   /// Whether target defaults to the `power` alignment rules of AIX.
   virtual bool defaultsToAIXPowerAlignment() const { return false; }
 
   /// Set supported OpenCL extensions and optional core features.
   virtual void setSupportedOpenCLOpts() {}
 
+  virtual void supportAllOpenCLOpts(bool V = true) {
+#define OPENCLEXTNAME(Ext) getTargetOpts().OpenCLFeaturesMap[#Ext] = V;
+#include "clang/Basic/OpenCLExtensions.def"
+  }
+
   /// Set supported OpenCL extensions as written on command line
-  virtual void setOpenCLExtensionOpts() {
+  virtual void setCommandLineOpenCLOpts() {
     for (const auto &Ext : getTargetOpts().OpenCLExtensionsAsWritten) {
-      getTargetOpts().SupportedOpenCLOptions.support(Ext);
+      bool IsPrefixed = (Ext[0] == '+' || Ext[0] == '-');
+      std::string Name = IsPrefixed ? Ext.substr(1) : Ext;
+      bool V = IsPrefixed ? Ext[0] == '+' : true;
+
+      if (Name == "all") {
+        supportAllOpenCLOpts(V);
+        continue;
+      }
+
+      getTargetOpts().OpenCLFeaturesMap[Name] = V;
     }
   }
 
+  /// Define OpenCL macros based on target settings and language version
+  void getOpenCLFeatureDefines(const LangOptions &Opts,
+                               MacroBuilder &Builder) const;
+
   /// Get supported OpenCL extensions and optional core features.
-  OpenCLOptions &getSupportedOpenCLOpts() {
-    return getTargetOpts().SupportedOpenCLOptions;
+  llvm::StringMap<bool> &getSupportedOpenCLOpts() {
+    return getTargetOpts().OpenCLFeaturesMap;
   }
 
   /// Get const supported OpenCL extensions and optional core features.
-  const OpenCLOptions &getSupportedOpenCLOpts() const {
-      return getTargetOpts().SupportedOpenCLOptions;
+  const llvm::StringMap<bool> &getSupportedOpenCLOpts() const {
+    return getTargetOpts().OpenCLFeaturesMap;
   }
 
   /// Get address space for OpenCL type.
   virtual LangAS getOpenCLTypeAddrSpace(OpenCLTypeKind TK) const;
 
   /// \returns Target specific vtbl ptr address space.
   virtual unsigned getVtblPtrAddressSpace() const {
     return 0;
#include "clang/Basic/OpenCLExtensions.def"
 
   virtual void setAuxTarget(const TargetInfo *Aux) {}
 
   /// Whether target allows debuginfo types for decl only variables.
   virtual bool allowDebugInfoForExternalVar() const { return false; }
 
 protected:
   /// Copy type and layout related info.
   void copyAuxTarget(const TargetInfo *Aux);
   virtual uint64_t getPointerWidthV(unsigned AddrSpace) const {
     return PointerWidth;
   }
   virtual uint64_t getPointerAlignV(unsigned AddrSpace) const {
     return PointerAlign;
   }
   virtual enum IntType getPtrDiffTypeV(unsigned AddrSpace) const {
     return PtrDiffType;

clang/include/clang/Basic/TargetOptions.h

public:
   /// be a list of strings starting with by '+' or '-'.
   std::vector<std::string> Features;
 
   /// The map of which features have been enabled disabled based on the command
   /// line.
   llvm::StringMap<bool> FeatureMap;
 
   /// Supported OpenCL extensions and optional core features.
-  OpenCLOptions SupportedOpenCLOptions;
+  llvm::StringMap<bool> OpenCLFeaturesMap;
 
   /// The list of OpenCL extensions to enable or disable, as written on
   /// the command line.
   std::vector<std::string> OpenCLExtensionsAsWritten;
 
   /// If given, enables support for __int128_t and __uint128_t types.
   bool ForceEnableInt128 = false;
 
   /// \brief If enabled, use 32-bit pointers for accessing const/local/shared
   /// address space.
   bool NVPTXUseShortPointers = false;
 

clang/lib/Basic/CMakeLists.txt

add_clang_library(clangBasic
   FileEntry.cpp
   FileManager.cpp
   FileSystemStatCache.cpp
   IdentifierTable.cpp
   LangOptions.cpp
   LangStandards.cpp
   Module.cpp
   ObjCRuntime.cpp
+  OpenCLOptions.cpp
   OpenMPKinds.cpp
   OperatorPrecedence.cpp
   SanitizerBlacklist.cpp
   SanitizerSpecialCaseList.cpp
   Sanitizers.cpp
   SourceLocation.cpp
   SourceManager.cpp
   Stack.cpp

clang/lib/Basic/OpenCLOptions.cpp

+//===--- OpenCLOptions.cpp---------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Basic/OpenCLOptions.h"
+
+namespace clang {
+
+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::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);
+}
+
+bool OpenCLOptions::isSupportedCore(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.isCoreIn(LO);
+}
+
+bool OpenCLOptions::isSupportedOptionalCore(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.isOptionalCoreIn(LO);
+}
+
+bool OpenCLOptions::isSupportedCoreOrOptionalCore(llvm::StringRef Ext,
+                                                  const LangOptions &LO) const {
+  return isSupportedCore(Ext, LO) || isSupportedOptionalCore(Ext, LO);
+}
+
+bool OpenCLOptions::isSupportedExtension(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) &&
+         !isSupportedCoreOrOptionalCore(Ext, LO);
+}
+
+void OpenCLOptions::enable(llvm::StringRef Ext, bool V) {
+  OptMap[Ext].Enabled = V;
+}
+
+void OpenCLOptions::support(llvm::StringRef Ext, bool V) {
+  assert(!Ext.empty() && "Extension is empty.");
+  assert(Ext[0] != '+' && Ext[0] != '-');
+  OptMap[Ext].Supported = V;
+}
+
+OpenCLOptions::OpenCLOptions() {
+#define OPENCL_GENERIC_EXTENSION(Ext, AvailVer, CoreVer, OptVer)               \
+  OptMap[#Ext].Avail = AvailVer;                                               \
+  OptMap[#Ext].Core = CoreVer;                                                 \
+  OptMap[#Ext].Opt = OptVer;
+#include "clang/Basic/OpenCLExtensions.def"
+}
+
+void OpenCLOptions::addSupport(const llvm::StringMap<bool> &FeaturesMap,
+                               const LangOptions &Opts) {
+  for (const auto &F : FeaturesMap) {
+    const auto &Name = F.getKey();
+    if (F.getValue() && isKnown(Name) && OptMap[Name].isAvailableIn(Opts))
+      support(Name);
+  }
+}
+
+void OpenCLOptions::disableAll() {
+  for (auto &Opt : OptMap)
+    Opt.getValue().Enabled = false;
+}
+
+void OpenCLOptions::enableSupportedCore(const LangOptions &LO) {
+  for (auto &Opt : OptMap)
+    if (isSupportedCoreOrOptionalCore(Opt.getKey(), LO))
+      Opt.getValue().Enabled = true;
+}
+
+} // end namespace clang

clang/lib/Basic/Targets.cpp

TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
   // Sort here, so we handle the features in a predictable order. (This matters
   // when we're dealing with features that overlap.)
   llvm::sort(Opts->Features);
 
   if (!Target->handleTargetFeatures(Opts->Features, Diags))
     return nullptr;
 
   Target->setSupportedOpenCLOpts();
-  Target->setOpenCLExtensionOpts();
+  Target->setCommandLineOpenCLOpts();
   Target->setMaxAtomicWidth();
 
   if (!Target->validateTarget(Diags))
     return nullptr;
 
   Target->CheckFixedPointBits();
 
   return Target.release();
 }
+
+/// getOpenCLFeatureDefines - Define OpenCL macros based on target settings
+/// and language version
+void TargetInfo::getOpenCLFeatureDefines(const LangOptions &Opts,
+                                         MacroBuilder &Builder) const {
+
+  auto defineOpenCLExtMacro = [&](llvm::StringRef Name, unsigned AvailVer,
+                                  unsigned CoreVersions,
+                                  unsigned OptionalVersions) {
+    // Check if extension is supported by target and is available in this
+    // OpenCL version
+    auto It = getTargetOpts().OpenCLFeaturesMap.find(Name);
+    if ((It != getTargetOpts().OpenCLFeaturesMap.end()) && It->getValue() &&
+        OpenCLOptions::OpenCLOptionInfo(AvailVer, CoreVersions,
+                                        OptionalVersions)
+            .isAvailableIn(Opts))
+      Builder.defineMacro(Name);
+  };
+#define OPENCL_GENERIC_EXTENSION(Ext, Avail, Core, Opt)                        \
+  defineOpenCLExtMacro(#Ext, Avail, Core, Opt);
+#include "clang/Basic/OpenCLExtensions.def"
+
+  // FIXME: OpenCL options which affect language semantics/syntax
+  // should be moved into LangOptions, thus macro definitions of
+  // such options is better to be done in clang::InitializePreprocessor
+}

clang/lib/Basic/Targets/AMDGPU.h

if (getTriple().getArch() == llvm::Triple::amdgcn) {
       GPUFeatures = llvm::AMDGPU::getArchAttrR600(GPUKind);
     }
 
     return GPUKind != llvm::AMDGPU::GK_NONE;
   }
 
   void setSupportedOpenCLOpts() override {
     auto &Opts = getSupportedOpenCLOpts();
-    Opts.support("cl_clang_storage_class_specifiers");
-    Opts.support("__cl_clang_function_pointers");
-    Opts.support("__cl_clang_variadic_functions");
+    Opts["cl_clang_storage_class_specifiers"] = true;
+    Opts["__cl_clang_variadic_functions"] = true;
+    Opts["__cl_clang_function_pointers"] = true;
 
     bool IsAMDGCN = isAMDGCN(getTriple());
 
-    if (hasFP64())
-      Opts.support("cl_khr_fp64");
+    Opts["cl_khr_fp64"] = hasFP64();
 
     if (IsAMDGCN || GPUKind >= llvm::AMDGPU::GK_CEDAR) {
-      Opts.support("cl_khr_byte_addressable_store");
-      Opts.support("cl_khr_global_int32_base_atomics");
-      Opts.support("cl_khr_global_int32_extended_atomics");
-      Opts.support("cl_khr_local_int32_base_atomics");
-      Opts.support("cl_khr_local_int32_extended_atomics");
+      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;
     }
 
     if (IsAMDGCN) {
-      Opts.support("cl_khr_fp16");
-      Opts.support("cl_khr_int64_base_atomics");
-      Opts.support("cl_khr_int64_extended_atomics");
-      Opts.support("cl_khr_mipmap_image");
-      Opts.support("cl_khr_mipmap_image_writes");
-      Opts.support("cl_khr_subgroups");
-      Opts.support("cl_khr_3d_image_writes");
-      Opts.support("cl_amd_media_ops");
-      Opts.support("cl_amd_media_ops2");
+      Opts["cl_khr_fp16"] = true;
+      Opts["cl_khr_int64_base_atomics"] = true;
+      Opts["cl_khr_int64_extended_atomics"] = true;
+      Opts["cl_khr_mipmap_image"] = true;
+      Opts["cl_khr_mipmap_image_writes"] = true;
+      Opts["cl_khr_subgroups"] = true;
+      Opts["cl_khr_3d_image_writes"] = true;
+      Opts["cl_amd_media_ops"] = true;
+      Opts["cl_amd_media_ops2"] = true;
     }
   }
 
   LangAS getOpenCLTypeAddrSpace(OpenCLTypeKind TK) const override {
     switch (TK) {
     case OCLTK_Image:
       return LangAS::opencl_constant;
 

clang/lib/Basic/Targets/NVPTX.h

public:
 
   bool setCPU(const std::string &Name) override {
     GPU = StringToCudaArch(Name);
     return GPU != CudaArch::UNKNOWN;
   }
 
   void setSupportedOpenCLOpts() override {
     auto &Opts = getSupportedOpenCLOpts();
-    Opts.support("cl_clang_storage_class_specifiers");
-    Opts.support("__cl_clang_function_pointers");
-    Opts.support("__cl_clang_variadic_functions");
-
-    Opts.support("cl_khr_fp64");
-    Opts.support("cl_khr_byte_addressable_store");
-    Opts.support("cl_khr_global_int32_base_atomics");
-    Opts.support("cl_khr_global_int32_extended_atomics");
-    Opts.support("cl_khr_local_int32_base_atomics");
-    Opts.support("cl_khr_local_int32_extended_atomics");
+    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["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
   /// space \p AddressSpace to be converted in order to be used, then return the
   /// corresponding target specific DWARF address space.
   ///
   /// \returns Otherwise return None and no conversion will be emitted in the
   /// DWARF.

clang/lib/Basic/Targets/SPIR.h

public:
 
   CallingConv getDefaultCallingConv() const override {
     return CC_SpirFunction;
   }
 
   void setSupportedOpenCLOpts() override {
     // Assume all OpenCL extensions and optional core features are supported
     // for SPIR since it is a generic target.
-    getSupportedOpenCLOpts().supportAll();
+    supportAllOpenCLOpts();
   }
 
   bool hasExtIntType() const override { return true; }
 
   bool hasInt128Type() const override { return false; }
 };
 class LLVM_LIBRARY_VISIBILITY SPIR32TargetInfo : public SPIRTargetInfo {
 public:

clang/lib/Basic/Targets/X86.h

public:
   }
 
   CallingConv getDefaultCallingConv() const override {
     return CC_C;
   }
 
   bool hasSjLjLowering() const override { return true; }
 
-  void setSupportedOpenCLOpts() override {
-    getSupportedOpenCLOpts().supportAll();
-  }
+  void setSupportedOpenCLOpts() override { supportAllOpenCLOpts(); }
 
   uint64_t getPointerWidthV(unsigned AddrSpace) const override {
     if (AddrSpace == ptr32_sptr || AddrSpace == ptr32_uptr)
       return 32;
     if (AddrSpace == ptr64)
       return 64;
     return PointerWidth;
   }

clang/lib/Frontend/InitPreprocessor.cpp

#undef DEFINE_LOCK_FREE_MACRO
   // Define a macro indicating that the source file is being compiled with a
   // SYCL device compiler which doesn't produce host binary.
   if (LangOpts.SYCLIsDevice) {
     Builder.defineMacro("__SYCL_DEVICE_ONLY__", "1");
   }
 
   // OpenCL definitions.
   if (LangOpts.OpenCL) {
-#define OPENCLEXT(Ext)                                                         \
-  if (TI.getSupportedOpenCLOpts().isSupported(#Ext, LangOpts))                 \
-    Builder.defineMacro(#Ext);
-#include "clang/Basic/OpenCLExtensions.def"
+    TI.getOpenCLFeatureDefines(LangOpts, Builder);
 
     if (TI.getTriple().isSPIR())
       Builder.defineMacro("__IMAGE_SUPPORT__");
   }
 
   if (TI.hasInt128Type() && LangOpts.CPlusPlus && LangOpts.GNUMode) {
     // For each extended integer type, g++ defines a macro mapping the
     // index of the type (0 in this case) in some list of extended types

clang/lib/Parse/ParsePragma.cpp

void Parser::HandlePragmaOpenCLExtension() {
   } else if (State == End) {
     if (Name != Actions.getCurrentOpenCLExtension())
       PP.Diag(NameLoc, diag::warn_pragma_begin_end_mismatch);
     Actions.setCurrentOpenCLExtension("");
   } else if (!Opt.isKnown(Name))
     PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << Ident;
   else if (Opt.isSupportedExtension(Name, getLangOpts()))
     Opt.enable(Name, State == Enable);
-  else if (Opt.isSupportedCore(Name, getLangOpts()))
+  else if (Opt.isSupportedCoreOrOptionalCore(Name, getLangOpts()))
     PP.Diag(NameLoc, diag::warn_pragma_extension_is_core) << Ident;
   else
     PP.Diag(NameLoc, diag::warn_pragma_unsupported_extension) << Ident;
 }
 
 void Parser::HandlePragmaMSPointersToMembers() {
   assert(Tok.is(tok::annot_pragma_ms_pointers_to_members));
   LangOptions::PragmaMSPointersToMembersKind RepresentationMethod =

clang/lib/Sema/Sema.cpp

if (getLangOpts().MSVCCompat) {
 
     addImplicitTypedef("size_t", Context.getSizeType());
   }
 
   // Initialize predefined OpenCL types and supported extensions and (optional)
   // core features.
   if (getLangOpts().OpenCL) {
     getOpenCLOptions().addSupport(
-        Context.getTargetInfo().getSupportedOpenCLOpts());
+        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));

clang/lib/Serialization/ASTReader.cpp

while (true) {
     case FP_PRAGMA_OPTIONS:
       // Later tables overwrite earlier ones.
       FPPragmaOptions.swap(Record);
       break;
 
     case OPENCL_EXTENSIONS:
       for (unsigned I = 0, E = Record.size(); I != E; ) {
         auto Name = ReadString(Record, I);
-        auto &Opt = OpenCLExtensions.OptMap[Name];
-        Opt.Supported = Record[I++] != 0;
-        Opt.Enabled = Record[I++] != 0;
-        Opt.Avail = Record[I++];
-        Opt.Core = Record[I++];
+        auto &OptInfo = OpenCLExtensions.OptMap[Name];
+        OptInfo.Supported = Record[I++] != 0;
+        OptInfo.Enabled = Record[I++] != 0;
+        OptInfo.Avail = Record[I++];
+        OptInfo.Core = Record[I++];
+        OptInfo.Opt = Record[I++];
       }
       break;
 
     case OPENCL_EXTENSION_TYPES:
       for (unsigned I = 0, E = Record.size(); I != E;) {
         auto TypeID = static_cast<::TypeID>(Record[I++]);
         auto *Type = GetType(TypeID).getTypePtr();
         auto NumExt = static_cast<unsigned>(Record[I++]);
void ASTReader::InitializeSema(Sema &S) {
   if (!FPPragmaOptions.empty()) {
     assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
     FPOptionsOverride NewOverrides =
         FPOptionsOverride::getFromOpaqueInt(FPPragmaOptions[0]);
     SemaObj->CurFPFeatures =
         NewOverrides.applyOverrides(SemaObj->getLangOpts());
   }
 
-  SemaObj->OpenCLFeatures.copy(OpenCLExtensions);
+  SemaObj->OpenCLFeatures = OpenCLExtensions;
   SemaObj->OpenCLTypeExtMap = OpenCLTypeExtMap;
   SemaObj->OpenCLDeclExtMap = OpenCLDeclExtMap;
 
   UpdateSema();
 }
 
 void ASTReader::UpdateSema() {
   assert(SemaObj && "no Sema to update");

clang/lib/Serialization/ASTWriter.cpp

void ASTWriter::WriteOpenCLExtensions(Sema &SemaRef) {
   RecordData Record;
   for (const auto &I:Opts.OptMap) {
     AddString(I.getKey(), Record);
     auto V = I.getValue();
     Record.push_back(V.Supported ? 1 : 0);
     Record.push_back(V.Enabled ? 1 : 0);
     Record.push_back(V.Avail);
     Record.push_back(V.Core);
+    Record.push_back(V.Opt);
   }
   Stream.EmitRecord(OPENCL_EXTENSIONS, Record);
 }
 
 void ASTWriter::WriteOpenCLExtensionTypes(Sema &SemaRef) {
   if (!SemaRef.Context.getLangOpts().OpenCL)
     return;
 

clang/test/Misc/nvptx.languageOptsOpenCL.cl

 // REQUIRES: nvptx-registered-target
 // RUN: %clang_cc1 -x cl -cl-std=CL %s -verify -triple nvptx-unknown-unknown
 // RUN: %clang_cc1 -x cl -cl-std=CL1.1 %s -verify -triple nvptx-unknown-unknown
 // RUN: %clang_cc1 -x cl -cl-std=CL1.2 %s -verify -triple nvptx-unknown-unknown
-// RUN: %clang_cc1 -x cl -cl-std=CL2.0 %s -verify -triple nvptx-unknown-unknown
 // RUN: %clang_cc1 -x cl -cl-std=CL %s -verify -triple nvptx-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES
 // RUN: %clang_cc1 -x cl -cl-std=CL1.1 %s -verify -triple nvptx-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES
 // RUN: %clang_cc1 -x cl -cl-std=CL1.2 %s -verify -triple nvptx-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES
-// RUN: %clang_cc1 -x cl -cl-std=CL2.0 %s -verify -triple nvptx-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES
 // RUN: %clang_cc1 -x cl -cl-std=CL %s -verify -triple nvptx64-unknown-unknown
 // RUN: %clang_cc1 -x cl -cl-std=CL1.1 %s -verify -triple nvptx64-unknown-unknown
 // RUN: %clang_cc1 -x cl -cl-std=CL1.2 %s -verify -triple nvptx64-unknown-unknown
-// RUN: %clang_cc1 -x cl -cl-std=CL2.0 %s -verify -triple nvptx64-unknown-unknown
 // RUN: %clang_cc1 -x cl -cl-std=CL %s -verify -triple nvptx64-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES
 // RUN: %clang_cc1 -x cl -cl-std=CL1.1 %s -verify -triple nvptx64-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES
 // RUN: %clang_cc1 -x cl -cl-std=CL1.2 %s -verify -triple nvptx64-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES
-// RUN: %clang_cc1 -x cl -cl-std=CL2.0 %s -verify -triple nvptx64-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES
 
 // Extensions in all versions
 #ifndef cl_clang_storage_class_specifiers
 #error "Missing cl_clang_storage_class_specifiers define"
 #endif
 #pragma OPENCL EXTENSION cl_clang_storage_class_specifiers : enable
 
 #ifndef __cl_clang_function_pointers
 #error "Missing __cl_clang_function_pointers define"

clang/test/Misc/r600.languageOptsOpenCL.cl

 // REQUIRES: amdgpu-registered-target
 // RUN: %clang_cc1 -x cl -cl-std=CL %s -verify -triple r600-unknown-unknown -target-cpu cayman
 // RUN: %clang_cc1 -x cl -cl-std=CL1.1 %s -verify -triple r600-unknown-unknown -target-cpu cayman
 // RUN: %clang_cc1 -x cl -cl-std=CL1.2 %s -verify -triple r600-unknown-unknown -target-cpu cayman
-// RUN: %clang_cc1 -x cl -cl-std=CL2.0 %s -verify -triple r600-unknown-unknown -target-cpu cayman
 // RUN: %clang_cc1 -x cl -cl-std=CL %s -verify -triple r600-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES -target-cpu cayman
 // RUN: %clang_cc1 -x cl -cl-std=CL1.1 %s -verify -triple r600-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES -target-cpu cayman
 // RUN: %clang_cc1 -x cl -cl-std=CL1.2 %s -verify -triple r600-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES -target-cpu cayman
-// RUN: %clang_cc1 -x cl -cl-std=CL2.0 %s -verify -triple r600-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES -target-cpu cayman
 // RUN: %clang_cc1 -x cl -cl-std=CL %s -verify -triple r600-unknown-unknown -target-cpu cypress
 // RUN: %clang_cc1 -x cl -cl-std=CL1.1 %s -verify -triple r600-unknown-unknown -target-cpu cypress
 // RUN: %clang_cc1 -x cl -cl-std=CL1.2 %s -verify -triple r600-unknown-unknown -target-cpu cypress
-// RUN: %clang_cc1 -x cl -cl-std=CL2.0 %s -verify -triple r600-unknown-unknown -target-cpu cypress
 // RUN: %clang_cc1 -x cl -cl-std=CL %s -verify -triple r600-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES -target-cpu cypress
 // RUN: %clang_cc1 -x cl -cl-std=CL1.1 %s -verify -triple r600-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES -target-cpu cypress
 // RUN: %clang_cc1 -x cl -cl-std=CL1.2 %s -verify -triple r600-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES -target-cpu cypress
-// RUN: %clang_cc1 -x cl -cl-std=CL2.0 %s -verify -triple r600-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES -target-cpu cypress
 // RUN: %clang_cc1 -x cl -cl-std=CL %s -verify -triple r600-unknown-unknown -target-cpu turks
 // RUN: %clang_cc1 -x cl -cl-std=CL1.1 %s -verify -triple r600-unknown-unknown -target-cpu turks
 // RUN: %clang_cc1 -x cl -cl-std=CL1.2 %s -verify -triple r600-unknown-unknown -target-cpu turks
-// RUN: %clang_cc1 -x cl -cl-std=CL2.0 %s -verify -triple r600-unknown-unknown -target-cpu turks
 // RUN: %clang_cc1 -x cl -cl-std=CL %s -verify -triple r600-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES -target-cpu turks
 // RUN: %clang_cc1 -x cl -cl-std=CL1.1 %s -verify -triple r600-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES -target-cpu turks
 // RUN: %clang_cc1 -x cl -cl-std=CL1.2 %s -verify -triple r600-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES -target-cpu turks
-// RUN: %clang_cc1 -x cl -cl-std=CL2.0 %s -verify -triple r600-unknown-unknown -Wpedantic-core-features -DTEST_CORE_FEATURES -target-cpu turks
 
 // Extensions in all versions
 #ifndef cl_clang_storage_class_specifiers
 #error "Missing cl_clang_storage_class_specifiers define"
 #endif
 #pragma OPENCL EXTENSION cl_clang_storage_class_specifiers : enable
 
 #ifndef __cl_clang_function_pointers
 #error "Missing __cl_clang_function_pointers define"

 #error "Incorrect cl_khr_fp64 define"
 #endif
 #pragma OPENCL EXTENSION cl_khr_fp64: enable
 // expected-warning@-1{{unsupported OpenCL extension 'cl_khr_fp64' - ignoring}}
 #endif // __HAS_FP64__
 
 //Core feature in CL 2.0
 #ifdef cl_khr_3d_image_writes
 #error "Incorrect cl_khr_3d_image_writes define"
 #endif
 #pragma OPENCL EXTENSION cl_khr_3d_image_writes: enable
 // expected-warning@-1{{unsupported OpenCL extension 'cl_khr_3d_image_writes' - ignoring}}
 
 #ifdef cl_khr_gl_msaa_sharing
 #error "Incorrect cl_khr_gl_msaa_sharing define"
 #endif
 #pragma OPENCL EXTENSION cl_khr_gl_msaa_sharing: enable