Add support for target-configurable address spaces.

[ebevhan]

Summary

This patch adds support in Clang for targets to configure
the relations between address spaces, making it possible
for a target to express which address space conversions
are permitted/invalid.

The original RFC is here: http://lists.llvm.org/pipermail/cfe-dev/2019-March/061541.html
However, the design in this patch has deviated from the
original suggestion.

It does multiple things to accomplish its goal:

• Moves QualType/Qualifiers accessors which deal with qualifier relations (such as compatiblyIncludes, etc.) to ASTContext, as Qualifiers cannot be made aware of the relations between address spaces on their own.
• Adds APIs to TargetInfo for querying address space relationships:
  • isAddressSpaceSuperSetOf is used to ask a target whether an address space is a superspace of another. Implicit conversion from a subspace to a superspace is always allowed, but not the other way around. By default, all address spaces are disjoint.
  • isExplicitAddrSpaceConversionLegal is used to ask whether an explicit conversion (e.g. via a cast) is permitted regardless of the address space relations given by the first method. By default, all explicit casts are allowed.

The ASTContext accessors will obey rules for LangASes first,
and then proceed to ask the target.

The reason for adding isExplicitAddrSpaceConversionLegal
is that according to Embedded-C, explicit casting between
all address spaces is permitted, but is undefined behavior
if the address spaces do not overlap.

This default behavior is odd, because there's no reason to
permit AS casts that will always be UB. However, as this has
been the default behavior since ASes were introduced, adding
this interface was the easiest way to keep supporting the
default behavior while also permitting targets to disallow
AS conversions that they do not want to allow.

There are still a few suspected issues with how explicit
casting is handled; in some cases, we do not know whether
we are performing an explicit cast, so we cannot know if
we should ask isExplicitAddrSpaceConversionLegal or
isAddressSpaceSuperSetOf.

[Anastasia]

This patch does not address the issue with the accessors
on Qualifiers (isAddressSpaceSupersetOf, compatiblyIncludes),
because I don't know how to solve it without breaking a ton of
rather nice encapsulation. Either, every mention of compatiblyIncludes
must be replaced with a call to a corresponding ASTContext method,
Qualifiers must have a handle to ASTContext, or ASTContext must be
passed to every such call. This revision mentions the issue in a comment:
https://reviews.llvm.org/D49294

I think using ASTContext helper is ok then.

I was just thinking about testing the new logic. Should we add something like -ffake-address-space-map (https://clang.llvm.org/docs/UsersManual.html#opencl-specific-options) that will force targets to use some implementation of fake address space conversions? It was quite useful in OpenCL before we added concrete targets with address spaces. Alternatively, we can try to use SPIR that is a generic Clang-only target that has address spaces.

lib/Sema/SemaOverload.cpp

3171 ↗

(On Diff #201842)

I guess if address spaces don't overlap we don't have a valid qualification conversion. This seems to align with the logic for cv. My guess is that none of the other conversions will be valid for non overlapping address spaces and the error will occur.

I think at this point we might not need to know if it's implicit or explicit? I believe we might have a separate check for this somewhere because it works for OpenCL. I don't know though if it might simplify the flow if we move this logic rather here.

The cv checks above seem to use CStyle flag. I am wondering if we could use it to detect implicit or explicit. Because we can only cast address space with C style cast at the moment. Although after adding addrspace_cast operator that will no longer be the only way.

5150 ↗

(On Diff #201842)

Agree! We need to check that address spaces are not identical and then validity!

But I guess it's ok for C++ because we can't add addr space qualifier to implicit object parameter yet?

It's broken for OpenCL though!

[ebevhan]

In D62574#1523835, @Anastasia wrote:

This patch does not address the issue with the accessors
on Qualifiers (isAddressSpaceSupersetOf, compatiblyIncludes),
because I don't know how to solve it without breaking a ton of
rather nice encapsulation. Either, every mention of compatiblyIncludes
must be replaced with a call to a corresponding ASTContext method,
Qualifiers must have a handle to ASTContext, or ASTContext must be
passed to every such call. This revision mentions the issue in a comment:
https://reviews.llvm.org/D49294

I think using ASTContext helper is ok then.

Alright. Just to clarify, you mean the first option (using a new accessor on ASTContext and replacing all existing compatiblyIncludes with that)?

I'll have to see if that's possible without breaking a few more interfaces, since you can throw around Qualifiers and check for compatibility without an ASTContext today.

I was just thinking about testing the new logic. Should we add something like -ffake-address-space-map (https://clang.llvm.org/docs/UsersManual.html#opencl-specific-options) that will force targets to use some implementation of fake address space conversions? It was quite useful in OpenCL before we added concrete targets with address spaces. Alternatively, we can try to use SPIR that is a generic Clang-only target that has address spaces.

Well, there are a couple targets which have target address spaces even today, I think. AMDGPU should be one, right?

I forgot to mention; this patch also disables two "extensions" that Clang has, namely that subtraction and comparison on pointers of different address spaces is legal regardless of address space compatibility. I'm pretty sure that these extensions only exist because Clang hasn't had support for targets to express address space compatibility until now. According to the docs, x86 uses address spaces for certain types of segment access: https://clang.llvm.org/docs/LanguageExtensions.html#memory-references-to-specified-segments

If x86 (or any target that uses target address spaces) wants to keep using this and still keep such pointers implicitly compatible with each other, it will need to configure this in its target hooks.

lib/Sema/SemaOverload.cpp

3171 ↗

(On Diff #201842)

I guess if address spaces don't overlap we don't have a valid qualification conversion. This seems to align with the logic for cv. My guess is that none of the other conversions will be valid for non overlapping address spaces and the error will occur.

Right. So the reasoning is that if the address spaces are disjoint according to the overlap rule, then it cannot be considered a qualification conversion.

But with the new hooks, it's possible for a target to allow explicit conversion even if address spaces do not overlap according to the rules. So even though there is no overlap, such a conversion could still be a qualification conversion if it was explicit (either via a c-style cast or an addrspace_cast). This is in fact the default for all targets (see the patch in TargetInfo.h).

I think I need a refresher on how the casts were meant to work; were both static_cast and reinterpret_cast supposed to be capable of implicit conversion (say, private -> generic) but only addrspace_cast for the other direction (generic -> private)? Or was reinterpret_cast supposed to fail in the first case?

5150 ↗

(On Diff #201842)

But I guess it's ok for C++ because we can't add addr space qualifier to implicit object parameter yet?

True, but that will become possible eventually.

I'm not sure if this is currently an issue with OpenCL as it is either. It's only a problem if FromType is not qualified, but is that possible? Even the 'notational' non-AS-qualification in OpenCL is still a qualification under the hood (either private or generic). Or maybe I'm misunderstanding how it works.

[Anastasia]

In D62574#1527126, @ebevhan wrote:

In D62574#1523835, @Anastasia wrote:

This patch does not address the issue with the accessors
on Qualifiers (isAddressSpaceSupersetOf, compatiblyIncludes),
because I don't know how to solve it without breaking a ton of
rather nice encapsulation. Either, every mention of compatiblyIncludes
must be replaced with a call to a corresponding ASTContext method,
Qualifiers must have a handle to ASTContext, or ASTContext must be
passed to every such call. This revision mentions the issue in a comment:
https://reviews.llvm.org/D49294

I think using ASTContext helper is ok then.

Alright. Just to clarify, you mean the first option (using a new accessor on ASTContext and replacing all existing compatiblyIncludes with that)?

Yes, it seems ok to me. Not sure if @rjmccall has an opinion.

I'll have to see if that's possible without breaking a few more interfaces, since you can throw around Qualifiers and check for compatibility without an ASTContext today.

I was just thinking about testing the new logic. Should we add something like -ffake-address-space-map (https://clang.llvm.org/docs/UsersManual.html#opencl-specific-options) that will force targets to use some implementation of fake address space conversions? It was quite useful in OpenCL before we added concrete targets with address spaces. Alternatively, we can try to use SPIR that is a generic Clang-only target that has address spaces.

Well, there are a couple targets which have target address spaces even today, I think. AMDGPU should be one, right?

Yes, however I am not sure we will be able to test more than what we test with OpenCL. Also I am not sure AMD maintainer would be ok. Do you have any concrete idea of what to test?

I forgot to mention; this patch also disables two "extensions" that Clang has, namely that subtraction and comparison on pointers of different address spaces is legal regardless of address space compatibility. I'm pretty sure that these extensions only exist because Clang hasn't had support for targets to express address space compatibility until now. According to the docs, x86 uses address spaces for certain types of segment access: https://clang.llvm.org/docs/LanguageExtensions.html#memory-references-to-specified-segments

If x86 (or any target that uses target address spaces) wants to keep using this and still keep such pointers implicitly compatible with each other, it will need to configure this in its target hooks.

Ok, it seems logical to me. In OpenCL we don't allow those cases.

lib/Sema/SemaOverload.cpp

3171 ↗

(On Diff #201842)

Just as a summary:

• All casts should allow safe/implicit AS conversions i.e. __private/__local/__global -> __generic in OpenCL
• All casts except for C-style and addrspace_cast should disallow unsafe/explicit conversions i.e. generic -> __private/__local/__global in OpenCL
• All casts should disallow forbidden conversions with no address space overlap i.e. __constant <-> any other in OpenCL

In OpenCL overlapping logic is only used for explicit i.e. unsafe conversion. So it seems we might only need those conversions here then?

5150 ↗

(On Diff #201842)

Yes, ideally we deduce address spaces if they are not specified explicitly. However I am not sure this is currently the case everywhere and whether we can have weird interplay with templates logic. One case I have in mind is function return type that is kept with Default address space but it shouldn't ever occur with the logic here.

So perhaps theoretically it's not broken for OpenCL. :)

[ebevhan]

I'll have to see if that's possible without breaking a few more interfaces, since you can throw around Qualifiers and check for compatibility without an ASTContext today.

I was just thinking about testing the new logic. Should we add something like -ffake-address-space-map (https://clang.llvm.org/docs/UsersManual.html#opencl-specific-options) that will force targets to use some implementation of fake address space conversions? It was quite useful in OpenCL before we added concrete targets with address spaces. Alternatively, we can try to use SPIR that is a generic Clang-only target that has address spaces.

Well, there are a couple targets which have target address spaces even today, I think. AMDGPU should be one, right?

Yes, however I am not sure we will be able to test more than what we test with OpenCL. Also I am not sure AMD maintainer would be ok. Do you have any concrete idea of what to test?

Well, since there is a mapping from the OpenCL address spaces to the AMDGPU target spaces, I would presume that if the target spaces were used on their own (via __attribute__((address_space(1))) for example) they should behave similarly to their OpenCL counterparts. It wouldn't have to be much, just a couple of type definitions and checks for implicit/explicit cast behavior.

There's also the x86 case I mentioned. I'm not really sure how that feature is used, though.

[ebevhan]

Replaced compatiblyIncludes and its dependents with ASTContext accessors instead.

[Anastasia]

In D62574#1534159, @ebevhan wrote:

I'll have to see if that's possible without breaking a few more interfaces, since you can throw around Qualifiers and check for compatibility without an ASTContext today.

I was just thinking about testing the new logic. Should we add something like -ffake-address-space-map (https://clang.llvm.org/docs/UsersManual.html#opencl-specific-options) that will force targets to use some implementation of fake address space conversions? It was quite useful in OpenCL before we added concrete targets with address spaces. Alternatively, we can try to use SPIR that is a generic Clang-only target that has address spaces.

Well, there are a couple targets which have target address spaces even today, I think. AMDGPU should be one, right?

Yes, however I am not sure we will be able to test more than what we test with OpenCL. Also I am not sure AMD maintainer would be ok. Do you have any concrete idea of what to test?

Well, since there is a mapping from the OpenCL address spaces to the AMDGPU target spaces, I would presume that if the target spaces were used on their own (via __attribute__((address_space(1))) for example) they should behave similarly to their OpenCL counterparts. It wouldn't have to be much, just a couple of type definitions and checks for implicit/explicit cast behavior.

There's also the x86 case I mentioned. I'm not really sure how that feature is used, though.

Ok, I think at some point you might want to test extra functionality that doesn't fit into OpenCL model, for example explicit conversion over non-overlapping address spaces? I think for this you might find useful to add the extra flag that switches on extra testing with "fake" setup of address spaces.

include/clang/AST/ASTContext.h

2598 ↗

(On Diff #203559)

Is there any advantage of keeping superset&subset concept? Amd if yes, how do we position the new functionality with explicit cast?

I think I am missing a bit conceptual view... because I think we originally discussed to switch to implicit/explicit conversion model. Perhaps there is no reason to do it but I would just like to understand why?

lib/Sema/SemaCast.cpp

2224 ↗

(On Diff #203559)

It seems like you are changing the functionality here. Don't we need any test for this?

2319 ↗

(On Diff #203559)

Btw I think this is set in:
https://reviews.llvm.org/D62299

Although I don't have any objections to changing to this.

2334 ↗

(On Diff #203559)

I think you might need to update the comment above to reflect that you are generalizing the behavior.

[ebevhan]

In D62574#1552220, @Anastasia wrote:

Ok, I think at some point you might want to test extra functionality that doesn't fit into OpenCL model, for example explicit conversion over non-overlapping address spaces? I think for this you might find useful to add the extra flag that switches on extra testing with "fake" setup of address spaces.

That functionality is actually enabled by default to allow for Clang's current semantics. Embedded-C allows all explicit conversions by default, and OpenCL in Clang allows all explicit conversion to and from target spaces as an extension.

It's rather up to each target to *disable* the default explicit conversion behavior if they don't want it.

include/clang/AST/ASTContext.h

2598 ↗

(On Diff #203559)

Yes, I know the original discussion was regarding the implicit/explicit model, but I came to realize during the implementation that all that was needed to get the superspace model to work generically with the current behavior was an override on the explicit conversion.

The implicit/explicit model also has the drawback that it's a bit too expressive. You can express semantics that just don't really make sense, like permitting implicit conversion but not explicit conversion. The superspace model doesn't let you do that, and the additions I've made here still don't: If implicit conversion is allowed, explicit conversion must also be allowed. It just becomes possible to allow explicit conversion for ASes that don't overlap.

Since the superspace model is what OpenCL and Embedded-C use in their specification, it's probably better to use that anyway.

lib/Sema/SemaCast.cpp

2224 ↗

(On Diff #203559)

I don't think it's necessarily changing. If we are doing a reinterpret_cast that stems from a c-style cast, we want to check that explicit conversion is allowed. This happens both if either AS overlaps, or if the target permits it. If it's not a C-style cast, then we need to check for subspace correctness instead, as reinterpret_cast can only do 'safe' casts.

The original code here allows all explicit C-style casts regardless of AS, but now we have to ask the target first.

2319 ↗

(On Diff #203559)

Oh, indeed.

[ebevhan]

Rebased and addressed some comments.

[Anastasia]

include/clang/AST/ASTContext.h

2598 ↗

(On Diff #203559)

The implicit/explicit model also has the drawback that it's a bit too expressive. You can express semantics that just don't really make sense, like permitting implicit conversion but not explicit conversion. The superspace model doesn't let you do that, and the additions I've made here still don't: If implicit conversion is allowed, explicit conversion must also be allowed. It just becomes possible to allow explicit conversion for ASes that don't overlap.

Ok, I think we could define the new model something like - explicit conversions are automatically allowed for all implicit conversions... targets won't have to specify those but only extra comversions that are not allowed implicitly.

Just to understand in the current patch when are we supposed to use isAddressSpaceOverlapping and when isExplicitAddrSpaceConversionLegal. Can't we just always use isExplicitAddrSpaceConversionLegal?

Since the superspace model is what OpenCL and Embedded-C use in their specification, it's probably better to use that anyway.

I agree the advantage of following spec is really huge. However, Clang is already broken for Emdedded C isn't it? Because it allows any explicit conversions?

As for OpenCL it might be reasonable to provide new documentation if needed as soon as the new rules don't invalidate all behavior.

lib/Sema/SemaCast.cpp

2325 ↗

(On Diff #206691)

I would keep the OpenCL part but move it to the end as an example. It often helps when there are spec references in the code.

// OpenCL v2.0 s6.5.5 - Generic addr space overlaps with any named one, except for constant.

2224 ↗

(On Diff #203559)

Ok, but shouldn't we test the new functionality of rejecting C style casts if target doesn't permit the conversion?

Also I believe C style cast functionality is being handled in TryAddressSpaceCast, and it probably belongs there. In fact you have already extended this:

if (!DestPtrType->isAddressSpaceOverlapping(*SrcPtrType)) {
    msg = diag::err_bad_cxx_cast_addr_space_mismatch;
    return TC_Failed;
}

Why is this change here needed? What test case does it cover?

lib/Sema/SemaExpr.cpp

10616 ↗

(On Diff #206691)

Should this also be allowed if pointers are explicitly convertible?

lib/Sema/SemaOverload.cpp

3171 ↗

(On Diff #201842)

Did you have time to look into this?

[ebevhan]

Sorry for the very late response to this!

include/clang/AST/ASTContext.h

2598 ↗

(On Diff #203559)

Ok, I think we could define the new model something like - explicit conversions are automatically allowed for all implicit conversions... targets won't have to specify those but only extra comversions that are not allowed implicitly.

Yes, this is how it's defined. Converting explicitly between two ASes where either one is a superset of the other is always legal.

Just to understand in the current patch when are we supposed to use isAddressSpaceOverlapping and when isExplicitAddrSpaceConversionLegal. Can't we just always use isExplicitAddrSpaceConversionLegal?

I guess the distinction between isAddressSpaceOverlapping and isExplicitAddrSpaceConversionLegal is pretty subtle. You would want the former when you need to know if implicit conversion A->B or B->A is permitted, and the latter when you need to know if explicit conversion A->B is permitted.

Though in most cases, I think the latter is probably the most common.

I agree the advantage of following spec is really huge. However, Clang is already broken for Emdedded C isn't it? Because it allows any explicit conversions?

No, the current behavior of permitting all explicit conversions is according to spec: "A non-null pointer into an address space A can be cast to a pointer into another address space B, but such a cast is undefined if the source pointer does not point to a location in B." The addition of isExplicitAddrSpaceConversionLegal lets targets override this behavior and make such casts non-legal.

lib/Sema/SemaCast.cpp

2224 ↗

(On Diff #203559)

Ok, but shouldn't we test the new functionality of rejecting C style casts if target doesn't permit the conversion?

Absolutely, but there are no targets which use the functionality yet, and I wouldn't want to make any such change without consulting with a target owner first.

Also I believe C style cast functionality is being handled in TryAddressSpaceCast, and it probably belongs there. Why is this change here needed? What test case does it cover?

That's a good point! Address space conversion for c-style casts should have already been handled by the time we get to TryReinterpretCast. So doesn't that mean that this code path is dead in trunk as well?

lib/Sema/SemaExpr.cpp

10616 ↗

(On Diff #206691)

No, I don't think so. We have some kind of AS_A < AS_B here, and if we check if either the LHS or the RHS can be implicitly converted to the other, we are safe. Checking explicit conversion isn't interesting here, because there is no explicit conversion in the code.

This is one of the cases I mentioned in the other comment about wanting to know if either AS can be implicitly converted, rather than knowing if one can be explicitly converted to the other.

lib/Sema/SemaOverload.cpp

3171 ↗

(On Diff #201842)

I still don't really understand why the code checks for overlap here. Removing this check causes one test case to break, CodeGenCXX/address-space-cast.cpp. Specifically, this:

#define __private__ __attribute__((address_space(5)))

void test_cast(char *gen_char_ptr, void *gen_void_ptr, int *gen_int_ptr) {
  __private__ void *priv_void_ptr = (__private__ void *)gen_char_ptr;
}

It tries to resolve the C-style cast with TryAddressSpaceCast, but fails as the underlying pointee types (char and void) are different. Then it tries to do it as a static_cast instead, but fails to produce an AddressSpaceConversion; instead, it makes a BitCast as the second conversion step which causes CodeGen to break since the conversion kind is wrong (the address spaces don't match).

Is address space conversion supposed to be a pointer conversion or a qualification conversion? If the second conversion step had emitted an AddressSpaceConversion instead of a BitCast, it would have worked. But at the same time, if we have IsQualificationConversion return false whenever we would need to do an address space conversion, other tests break.

I suppose that a solution might be to remove the special case in IsQualificationConversion for address spaces, and that TryAddressSpaceCast should ignore the underlying type if it's part of a C-style cast. That way we won't try to handle it as a static_cast. But I don't know if that's just a workaround for a larger underlying issue, or if it causes other issues.

All in all, I have no idea what these code paths are trying to accomplish. It just doesn't make sense to me. :(

[Anastasia]

include/clang/AST/ASTContext.h

2598 ↗

(On Diff #203559)

I see so we are making the new rules then. I guess it should be fine. However we might want to document this better and explain the difference between two types of API provided.

lib/Sema/SemaCast.cpp

2224 ↗

(On Diff #203559)

Absolutely, but there are no targets which use the functionality yet, and I wouldn't want to make any such change without consulting with a target owner first.

Alternatively we can add a flag just for testing to override the address space settings for targets. Or may be we could just reuse -ffake-address-space-map. I believe I've mentioned it before.

That's a good point! Address space conversion for c-style casts should have already been handled by the time we get to TryReinterpretCast. So doesn't that mean that this code path is dead in trunk as well?

Yeah, possibly we have overlooked that.

lib/Sema/SemaOverload.cpp

3171 ↗

(On Diff #201842)

It tries to resolve the C-style cast with TryAddressSpaceCast, but fails as the underlying pointee types (char and void) are different. Then it tries to do it as a static_cast instead, but fails to produce an AddressSpaceConversion; instead, it makes a BitCast as the second conversion step which causes CodeGen to break since the conversion kind is wrong (the address spaces don't match).

Strange! TryStaticCast should set cast kind to CK_AddressSpaceConversion if it detects the address spaces are different. Do you know why it doesn't happen for this test case?

Is address space conversion supposed to be a pointer conversion or a qualification conversion?

It is a qualification conversion.

I suppose that a solution might be to remove the special case in IsQualificationConversion for address spaces, and that TryAddressSpaceCast should ignore the underlying type if it's part of a C-style cast. That way we won't try to handle it as a static_cast. But I don't know if that's just a workaround for a larger underlying issue, or if it causes other issues.

I think the idea of separate conversions is for each of them to work as a separate step. So address space cast should be working just as const cast i.e. it should only check the address space conversion and not the type. However the problem here is that addrspacecast supersedes bitcast. Therefore there are extra checks in the casts later to classify the cast kind correctly. If this flow fails we can reevaluate but this is the idea we were following up to now.

[ebevhan]

Sorry for the very late response on this. Hope it's not completely off your radar.

include/clang/AST/ASTContext.h

2598 ↗

(On Diff #203559)

I will add some more comments to the functions to describe a bit better what they should be used for.

lib/Sema/SemaCast.cpp

2224 ↗

(On Diff #203559)

I haven't looked more into the testing issue yet.

---

I think that reinterpret_casts for c-style casts must handle AS conversions like this as it must be possible to do a conversion like AS1 T1 * -> AS2 T2 * where:

• T1 is not a derived of T2
• T2 is not void

and AS2 is not a superspace of AS1.

In such cases neither addrspace_cast nor static_cast apply, so reinterpret_cast must be able to handle explicit AS conversions.

lib/Sema/SemaOverload.cpp

3171 ↗

(On Diff #201842)

I've determined that something doesn't add up with how conversions are generated. I'm pretty sure that the issue lies in PerformImplicitConversion.

When we analyze the c-style cast in this:

char * p;
__private__ void * pp = (__private__ void *)gen_char_ptr;

we determine that this cannot be an addrspace_cast (as the unqualified pointee types are different). It can be a static_cast, though. The implicit conversion resulting from this static_cast should occur in two steps: the second conversion should be a pointer conversion from char* to void*, and the third conversion should be a qualification conversion from void* to __private__ void*.

Now, this *is* the ICS/SCS that we get. However, when we realize the conversion sequence in PerformImplicitConversion, it actually completely ignores the intermediate types in the conversion sequence. Everything it does is only on the intermediate 'From' type after each conversion step and the final 'To' type, but we never consider the intermediate 'To' type. This means that it will try to realize the entire conversion sequence (both the 'bitcast' conversion and the 'addrspace' conversion) in a single (pointer conversion) step instead of two, and since CheckPointerConversion has no provisions for address space casts (because why should it?) we get a CK_BitCast and codegen fails since it's trying to change the address space of the type.

This means that each conversion step realization needs to be aware of every kind of CastKind that could possibly occur in each step, which is bizarre. We know exactly what type we are converting from and to in each conversion in the sequence; why do we use the *final* result type to determine what kind of implicit cast we should use in each step?

I've tried to make PerformImplicitConversion aware of the intermediate types, but this breaks a bunch of tests, as there are lots of checks and diagnoses in the function that require the final type. One contributor to this is that the 'ToType' of the SCS (ToType[2]) doesn't actually have to match the final 'ToType' of the conversion. Something to do with exception specifications.

It feels like this code is just broken and everyone has just been coding around the issues. Perhaps this is the root:

// Overall FIXME: we are recomputing too many types here and doing far too
// much extra work. What this means is that we need to keep track of more
// information that is computed when we try the implicit conversion initially,
// so that we don't need to recompute anything here.

I don't know what the solution here is, short of redesigning PerformImplicitConversion.

[danilaml]

What are the remaining roadblocks left before this patch can be merged? I'm interested in having a target-specific way to define the allowed explicit/implicit address space conversions.
Also, it appears that currently whether implicit casts between pointers of different AS are allowed is determined by the superset relations only, however https://reviews.llvm.org/D73360 introduced another (openCL-specific) variable into the mix: whether the conversion is a top level or not. IMHO, this should also be configured by the target, although I'm not sure whether it needs a separate hook (isBitcastNoop or similar?) or it needs to check the legality of the implicit casts differently.

[ebevhan]

In D62574#2133160, @danilaml wrote:

What are the remaining roadblocks left before this patch can be merged? I'm interested in having a target-specific way to define the allowed explicit/implicit address space conversions.

This has been on my backburner for various reasons, so I'm not sure what the status is any more. I could try rebasing it and seeing where things are at.
I don't believe that the issues I mentioned last have been dealt with, though.

This was also only an initial concept. I think that even once all the issues with the patch have been ironed out, it would require a round of wider review since it's a fairly hefty API change.

Also, it appears that currently whether implicit casts between pointers of different AS are allowed is determined by the superset relations only, however https://reviews.llvm.org/D73360 introduced another (openCL-specific) variable into the mix: whether the conversion is a top level or not. IMHO, this should also be configured by the target, although I'm not sure whether it needs a separate hook (isBitcastNoop or similar?) or it needs to check the legality of the implicit casts differently.

That patch only seems to apply to C++, I think? The restriction on top-level-only conversion should be correct, at least in C++.
It's generally not safe to alter address spaces below the top level. C is just very permissive about it.

[ebevhan]

It seems that D70605 attempted to ameliorate the issues that I observed (pointer-conversion doing too much), but it didn't manage to solve the problem fully.

[danilaml]

In D62574#2135662, @ebevhan wrote:

It's generally not safe to alter address spaces below the top level. C is just very permissive about it.

Isn't that also true for the top-level casts? Unless when it is. And the target should know when it's safe or not. It's just that for non top-level casts there is added condition that casts are noop (i.e. don't change the bit pattern of the pointer). At least that's how I see it.

I think that you are write about that patch being targeted at C++ (need to do some C tests), but having the same implicit conversion being legal in C and not in C++ would be a bit confusing for the users (especially when the target knows it's completely safe). Anyway, this is not as important as getting this target-configurable AS work done. Without it, I guess the only option for downstream works to customize the behavior is to introduce their own LangAS-level AS entries, which is definitely not ideal.

[ebevhan]

In D62574#2136553, @danilaml wrote:

In D62574#2135662, @ebevhan wrote:

It's generally not safe to alter address spaces below the top level. C is just very permissive about it.

Isn't that also true for the top-level casts? Unless when it is. And the target should know when it's safe or not. It's just that for non top-level casts there is added condition that casts are noop (i.e. don't change the bit pattern of the pointer). At least that's how I see it.

Yes, I see what you mean. I think that the default assumption in Clang at the moment is that it is not safe to do so, hence the current design. Not that there are many targets that use address spaces, so perhaps that assumption is too conservative for ones that do downstream.

[ebevhan]

Rebased.

[Anastasia]

In D62574#2136423, @ebevhan wrote:

It seems that D70605 attempted to ameliorate the issues that I observed (pointer-conversion doing too much), but it didn't manage to solve the problem fully.

Can you explain what's left to be done?

lib/Sema/SemaOverload.cpp

3171 ↗

(On Diff #201842)

Btw the example that you provide here seems to compile in OpenCL now: https://godbolt.org/z/j9E3s4

[Anastasia]

This was also only an initial concept. I think that even once all the issues with the patch have been ironed out, it would require a round of wider review since it's a fairly hefty API change.

You don't always need a super polished prototype to justify adding new functionality. As soon as your design is clearly explained and agreed by the relevant stakeholders it should be good enough to kick off the work. Once you add some initial implementation it is easier for the community to chip in if this functionality is important enough which I sense might be the case.

[ebevhan]

In D62574#2183294, @Anastasia wrote:

In D62574#2136423, @ebevhan wrote:

It seems that D70605 attempted to ameliorate the issues that I observed (pointer-conversion doing too much), but it didn't manage to solve the problem fully.

Can you explain what's left to be done?

My cache is a bit flushed on this at the moment but I do believe that if the issue described in D83325 is resolved, this patch should work.

lib/Sema/SemaOverload.cpp

3171 ↗

(On Diff #201842)

That's neat. It does seem like the example in D83325 compiles too, but I suspect it wouldn't work with this patch.

[ebevhan]

Rebased and updated summary.

[ebevhan]

I think this works now. It should probably be given a few more reviewers to have a look. Do you have some suggestions, @Anastasia ?

[Anastasia]

In D62574#2210503, @ebevhan wrote:

I think this works now. It should probably be given a few more reviewers to have a look. Do you have some suggestions, @Anastasia ?

Great! I will look at this again within a week or so. I think it would be good to get some feedback from John @rjmccall too?

[Anastasia]

This change looks good to me in general conceptually as it is completing missing logic in clang that let's targets to customize the address space behavior!

The change also looks good from the implementation side apart from some small details raised in the comments.

The only thing is that it would be good to test the new target setting logic somehow... do you have any ideas in mind? We could think of creating a dummy target for that or adding a dummy setting in existing targets - maybe SPIR could be a candidate. We have done something similar in the past if you look at FakeAddrSpaceMap in LangOpts.

clang/include/clang/AST/ASTContext.h

2355

Perhaps not necessarily related to this change but I feel we should provide an explanation of how those functions behave wrt address spaces because terms more qualified or less qualified don't really apply there.

2572

I think we should finally start referring to section 5 of embedded C spec as it is not a secret that clang implements exactly this. It is rather a good thing to document the implemented behavior.

2596

Here we should say that this is an extension or enhancement of embedded C rules that clang implements.

Technically for OpenCL we could refactor to use this functionality as we don't support such explicit casts on disjoint address spaces. But then this would not be necessarily a target setting.

clang/lib/AST/ASTContext.cpp

10920

I guess we should add a similar check here as below?

if (isTargetAddressSpace(From) || isTargetAddressSpace(To) ||
      From == LangAS::Default || To == LangAS::Default)

10924

Btw I assume that explicit cast can't reject what is not rejected by implicit cast?

I am not sure if we need to enforce or document this somehow considering that we provide full configurability now?

clang/lib/Sema/SemaCast.cpp

2425–2426

Btw just to point our that overlapping used to be a commutative operation so you could swap arguments and still get the same answer but for isExplicitAddrSpaceConversionLegal is not the same I assume?

clang/lib/Sema/SemaOverload.cpp

3233

Sorry if this has been discussed previously, do you refer to the first or the second case and is there any failing test case?

5287

Do you have a failing test case, if so feel free to create a bug?

clang/test/CodeGenCXX/address-space-cast.cpp

41

I am confused about why this is changed now? adrspacecast can cast a type and an address space too i.e. it is implicitly a bitcast too.

[ebevhan]

In D62574#2242471, @Anastasia wrote:

The only thing is that it would be good to test the new target setting logic somehow... do you have any ideas in mind? We could think of creating a dummy target for that or adding a dummy setting in existing targets - maybe SPIR could be a candidate. We have done something similar in the past if you look at FakeAddrSpaceMap in LangOpts.

Perhaps we could add a configuration to AMDGPU? That has address spaces.

I'm not a big fan of adding an option just for testing.

clang/include/clang/AST/ASTContext.h

2596

I'm still a bit on the fence about what Embedded-C really stipulates. I don't think it's against the spec to simply disallow disjoint conversion altogether, but it's only necessary to keep Clang's current implementation working.

clang/lib/AST/ASTContext.cpp

10920

Is it not useful for targets to be able to express relations of LangASes and target ASes?

The method below must be guarded because otherwise all casts between LangASes would be legal.

10924

It shouldn't do that, no. I don't think there's any way to guarantee this, though.

I could add something to the target methods about it.

clang/lib/Sema/SemaCast.cpp

2425–2426

Correct, isExplicitAddrSpaceConversionLegal doesn't have to be commutative.

clang/lib/Sema/SemaOverload.cpp

3233

It refers to the first case of "valid to convert to addr space that is a superset in all cases". Technically, it could be permitted even if the addr space is not a superset, if this is an explicit cast. But we don't know that. We only know if it's a c-style cast, because those are always 'explicit'.

I don't have a test case, unfortunately. I just made this observation as I was redoing all of the overlap/superspace checks. It might not even be a problem.

5287

Unsure how I'd make one. I suspect this can't be triggered in OpenCL++, because you can't really have LangAS::Default on FromType there, can you? It would always be some AS.

Doing it in another way would require a target that has configurable ASes, which doesn't exist yet. Also, it would require methods qualified with target ASes, and that doesn't work yet either.

clang/test/CodeGenCXX/address-space-cast.cpp

41

I don't remember the exact details of how it ends up this way, but it has to do with the way standard conversion sequences are determined. The bitcast and AS-cast are done in two separate steps; the bitcast as part of the pointer conversion in the second SCS step, and the AS-cast as part of the qualification conversion in the third SCS step.

[ebevhan]

clang/lib/AST/ASTContext.cpp

10924

Wait, no. This is already guaranteed, because the method here in ASTContext will check for overlap first.

[Anastasia]

In D62574#2249817, @ebevhan wrote:

In D62574#2242471, @Anastasia wrote:

The only thing is that it would be good to test the new target setting logic somehow... do you have any ideas in mind? We could think of creating a dummy target for that or adding a dummy setting in existing targets - maybe SPIR could be a candidate. We have done something similar in the past if you look at FakeAddrSpaceMap in LangOpts.

Perhaps we could add a configuration to AMDGPU? That has address spaces.

I'm not a big fan of adding an option just for testing.

Ok yes if that can be done it would be better. However, it might need extra involvement from AMD side to make sure at least they would agree on maintaining this.

clang/include/clang/AST/ASTContext.h

2596

Technically Clang's policy is to implement documented and standardized behavior. So the question is not necessarily about its usefulness, but about adhering to good practices.

I think it is ok to deviate from the standard to make the behavior more helpful in some cases but we should aim at documenting such changes. This will help the developers in the future if they need to fix bugs or build something on top.

clang/lib/AST/ASTContext.cpp

10920

I am not sure I follow your comment.

Is it not useful for targets to be able to express relations of LangASes and target ASes?

yes that's why I was thinking we should add a check to make sure we only ask target for target ASes...

However, I am not sure what we should do if there is a mix of target and language AS. I guess this should be governed by the target hooks?

clang/lib/Sema/SemaOverload.cpp

3233

Ok, we could update to:
`
This should probably be using isExplicitAddrSpaceConversionLegal -> The first conversion should probably be using isExplicitAddrSpaceConversionLegal too.`

If you already have a failing test case we could create a bug to track this better.

5287

Ok, that's right in OpenCL almost every type gets an address space early in parsing.

But if we already know it's a bug and the fix for it we could change this code? Although I think the bug fix should better be done on a separate review.

clang/test/CodeGenCXX/address-space-cast.cpp

41

Ah ok, makes sense although the IR will be different to C, but the sematic is the same.

[danilaml]

So is missing an in-tree user (like AMDGPU) the only thing that prevents from merging this?

[rjmccall]

Sorry for never actually reviewing this. I have no objection to taking a refactor that implements the Embedded C address-space overlap rules even if we don't have an in-tree target that uses it. I'll try to find time to review.

[ebevhan]

I've been away from LLVM development for a while, and sadly this patch has languished a bit.

I don't think there were any strong objections to its inclusion, though. If there is still interest in reviewing this, I could try to rebase the patch (or something resembling it) onto the latest main and see if it still works.

[rjmccall]

I completely lost track of this, but if you'd like to rebase it, I can try to make time.

[ebevhan]

Rebased and addressed some comments.

[ebevhan]

Sorry for the delay! I rebased the patch onto latest and it mostly worked, with a few hitches.

clang/lib/Sema/SemaCast.cpp

2477–2479

Without this, SemaOpenCL/func.cl fails since foo((void*)foo) is no longer an error. Since the function pointer is Default-qualified, isExplicitAddrSpaceConversionLegal delegates the check to the target, which will always return true.

To be honest, the clause in that method for letting targets allow conversions where LangAS::Default is involved only works so long as every type in OpenCL has the "right" semantic AS. When any of them are Default, things like this happen.

Maybe we should only ask the target about explicit conversions if both ASes are Default or a target AS?

clang/lib/Sema/SemaOverload.cpp

5287

I made the fix here just to try, and it caused a difference in address-space-lambda.clcpp.

I'm not sure why that lambda would be valid just because mutable is added... So this seems like the correct behavior to me?

clang-tools-extra/clang-tidy/bugprone/VirtualNearMissCheck.cpp

static bool checkOverridingFunctionReturnType(const ASTContext *Context,
 
   // Both pointers or references should have the same cv-qualification.
   if (DerivedReturnTy.getLocalCVRQualifiers() !=
       BaseReturnTy.getLocalCVRQualifiers())
     return false;
 
   // The class type D should have the same cv-qualification as or less
   // cv-qualification than the class type B.
-  if (DTy.isMoreQualifiedThan(BTy))
+  if (Context->isMoreQualifiedThan(DTy, BTy))
     return false;
 
   return true;
 }
 
 /// \returns decayed type for arrays and functions.
 static QualType getDecayedType(QualType Type) {
   if (const auto *Decayed = Type->getAs<DecayedType>())

clang/include/clang/AST/ASTContext.h

 //===- ASTContext.h - Context to hold long-lived AST nodes ------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 /// \file
public:
   ///
   /// Clang offers a number of qualifiers in addition to the C++ qualifiers;
   /// those qualifiers are also ignored in the 'similarity' check.
   bool hasSimilarType(QualType T1, QualType T2);
 
   /// Determine if two types are similar, ignoring only CVR qualifiers.
   bool hasCvrSimilarType(QualType T1, QualType T2);
 
+  /// Determines if the qualifiers A compatibly include another set B.
+  /// Generally this answers the question of whether an object qualified with B
+  /// can be safely used as an object qualified with A.
+  bool compatiblyIncludes(Qualifiers A, Qualifiers B) const {
+    return isAddressSpaceSupersetOf(A, B) &&
+           // ObjC GC qualifiers can match, be added, or be removed, but can't
+           // be changed.
+           (A.getObjCGCAttr() == B.getObjCGCAttr() || !A.hasObjCGCAttr() ||
+            !B.hasObjCGCAttr()) &&
+           // ObjC lifetime qualifiers must match exactly.
+           A.getObjCLifetime() == B.getObjCLifetime() &&
+           // CVR qualifiers may subset.
+           ((A.getCVRQualifiers() | B.getCVRQualifiers()) ==
+            A.getCVRQualifiers()) &&
+           // U qualifier may superset.
+           (!B.hasUnaligned() || A.hasUnaligned());
+  }
+
+  /// Determine whether the type A is more qualified than the type B.
+  /// For example, "const volatile int" is more qualified than "const int",
+  /// "volatile int", and "int". However, it is not more qualified than
+  /// "const volatile int".
+  bool isMoreQualifiedThan(QualType A, QualType B) const {
+    Qualifiers AQuals = A.getQualifiers();
+    Qualifiers BQuals = B.getQualifiers();
+    return (AQuals != BQuals && compatiblyIncludes(AQuals, BQuals));
+  }
+
+  /// Determine whether the type A is at least as qualified as the type B.
+  /// For example, "const volatile int" is at least as qualified as
+  /// "const int", "volatile int", "int", and "const volatile int".
+  bool isAtLeastAsQualifiedAs(QualType A, QualType B) const {
+    Qualifiers BQuals = B.getQualifiers();
+
+    // Ignore __unaligned qualifier if A is a void.
+    if (A.getUnqualifiedType()->isVoidType())
+      BQuals.removeUnaligned();
+
+    return compatiblyIncludes(A.getQualifiers(), BQuals);
+  }
+
   /// Retrieves the "canonical" nested name specifier for a
   /// given nested name specifier.
   ///
   /// The canonical nested name specifier is a nested name specifier
   /// that uniquely identifies a type or namespace within the type
   /// system. For example, given:
   ///
   /// \code
public:
   /// Get target-dependent integer value for null pointer which is used for
   /// constant folding.
   uint64_t getTargetNullPointerValue(QualType QT) const;
 
   bool addressSpaceMapManglingFor(LangAS AS) const {
     return AddrSpaceMapMangling || isTargetAddressSpace(AS);
   }
 
+  /// Returns true if address space A is a superset of B.
+  /// The subspace/superspace relation governs the validity of implicit
+  /// conversion. If A is a superspace of B, implicitly converting from
+  /// address space B to address space A is permitted.
+  bool isAddressSpaceSupersetOf(LangAS A, LangAS B) const;
+  bool isAddressSpaceSupersetOf(Qualifiers A, Qualifiers B) const {
+    return isAddressSpaceSupersetOf(A.getAddressSpace(), B.getAddressSpace());
+  }
+
+  /// Returns true if address space A overlaps with B.
+  /// This is the same as saying that either A is a superspace of B, or B is
+  /// a superspace of A. If this is true, implicitly converting from A to B
+  /// or from B to A is permitted. This method should not be used to test for
+  /// validity of explicit conversion, as the target may override the behavior
+  /// of explicit conversion for disjoint target address spaces.
+  bool isAddressSpaceOverlapping(LangAS A, LangAS B) const {
+    // A overlaps with B if either is a superset of the other.
+    return isAddressSpaceSupersetOf(A, B) ||
+           isAddressSpaceSupersetOf(B, A);
+  }
+  bool isAddressSpaceOverlapping(Qualifiers A, Qualifiers B) const {
+    return isAddressSpaceOverlapping(A.getAddressSpace(), B.getAddressSpace());
+  }
+
+  /// Returns true if an explicit cast from address space A to B is legal.
+  /// Explicit conversion between address spaces is permitted if the address
+  /// spaces are not disjoint (one of them is a superspace of the other) or
+  /// if the target has decided to permit it regardless of the address space
+  /// relation.
+  bool isExplicitAddrSpaceConversionLegal(LangAS From, LangAS To) const;
+  bool isExplicitAddrSpaceConversionLegal(Qualifiers From,
+                                          Qualifiers To) const {
+    return isExplicitAddrSpaceConversionLegal(From.getAddressSpace(),
+                                              To.getAddressSpace());
+  }
+
 private:
   // Helper for integer ordering
   unsigned getIntegerRank(const Type *T) const;
 
 public:
   //===--------------------------------------------------------------------===//
   //                    Type Compatibility Predicates
   //===--------------------------------------------------------------------===//

clang/include/clang/AST/CanonicalType.h

public:
   CanQual<T> getUnqualifiedType() const;
 
   /// Retrieves a version of this type with const applied.
   /// Note that this does not always yield a canonical type.
   QualType withConst() const {
     return Stored.withConst();
   }
 
-  /// Determines whether this canonical type is more qualified than
-  /// the @p Other canonical type.
-  bool isMoreQualifiedThan(CanQual<T> Other) const {
-    return Stored.isMoreQualifiedThan(Other.Stored);
-  }
-
-  /// Determines whether this canonical type is at least as qualified as
-  /// the @p Other canonical type.
-  bool isAtLeastAsQualifiedAs(CanQual<T> Other) const {
-    return Stored.isAtLeastAsQualifiedAs(Other.Stored);
-  }
-
   /// If the canonical type is a reference type, returns the type that
   /// it refers to; otherwise, returns the type itself.
   CanQual<Type> getNonReferenceType() const;
 
   /// Retrieve the internal representation of this canonical type.
   void *getAsOpaquePtr() const { return Stored.getAsOpaquePtr(); }
 
   /// Construct a canonical type from its internal representation.

clang/include/clang/AST/Type.h

assert(getAddressSpace() == qs.getAddressSpace() ||
            !hasAddressSpace() || !qs.hasAddressSpace());
     assert(getObjCGCAttr() == qs.getObjCGCAttr() ||
            !hasObjCGCAttr() || !qs.hasObjCGCAttr());
     assert(getObjCLifetime() == qs.getObjCLifetime() ||
            !hasObjCLifetime() || !qs.hasObjCLifetime());
     Mask |= qs.Mask;
   }
 
-  /// Returns true if address space A is equal to or a superset of B.
-  /// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of
-  /// overlapping address spaces.
-  /// CL1.1 or CL1.2:
-  ///   every address space is a superset of itself.
-  /// CL2.0 adds:
-  ///   __generic is a superset of any address space except for __constant.
-  static bool isAddressSpaceSupersetOf(LangAS A, LangAS B) {
-    // Address spaces must match exactly.
-    return A == B ||
-           // Otherwise in OpenCLC v2.0 s6.5.5: every address space except
-           // for __constant can be used as __generic.
-           (A == LangAS::opencl_generic && B != LangAS::opencl_constant) ||
-           // Consider pointer size address spaces to be equivalent to default.
-           ((isPtrSizeAddressSpace(A) || A == LangAS::Default) &&
-            (isPtrSizeAddressSpace(B) || B == LangAS::Default));
-  }
-
-  /// Returns true if the address space in these qualifiers is equal to or
-  /// a superset of the address space in the argument qualifiers.
-  bool isAddressSpaceSupersetOf(Qualifiers other) const {
-    return isAddressSpaceSupersetOf(getAddressSpace(), other.getAddressSpace());
-  }
-
-  /// Determines if these qualifiers compatibly include another set.
-  /// Generally this answers the question of whether an object with the other
-  /// qualifiers can be safely used as an object with these qualifiers.
-  bool compatiblyIncludes(Qualifiers other) const {
-    return isAddressSpaceSupersetOf(other) &&
-           // ObjC GC qualifiers can match, be added, or be removed, but can't
-           // be changed.
-           (getObjCGCAttr() == other.getObjCGCAttr() || !hasObjCGCAttr() ||
-            !other.hasObjCGCAttr()) &&
-           // ObjC lifetime qualifiers must match exactly.
-           getObjCLifetime() == other.getObjCLifetime() &&
-           // CVR qualifiers may subset.
-           (((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask)) &&
-           // U qualifier may superset.
-           (!other.hasUnaligned() || hasUnaligned());
-  }
-
   /// Determines if these qualifiers compatibly include another set of
   /// qualifiers from the narrow perspective of Objective-C ARC lifetime.
   ///
   /// One set of Objective-C lifetime qualifiers compatibly includes the other
   /// if the lifetime qualifiers match, or if both are non-__weak and the
   /// including set also contains the 'const' qualifier, or both are non-__weak
   /// and one is None (which can only happen in non-ARC modes).
   bool compatiblyIncludesObjCLifetime(Qualifiers other) const {
public:
   /// Like getUnqualifiedType(), but also returns the set of
   /// qualifiers that were built up.
   ///
   /// The resulting type might still be qualified if it's sugar for an array
   /// type.  To strip qualifiers even from within a sugared array type, use
   /// ASTContext::getUnqualifiedArrayType.
   inline SplitQualType getSplitUnqualifiedType() const;
 
-  /// Determine whether this type is more qualified than the other
-  /// given type, requiring exact equality for non-CVR qualifiers.
-  bool isMoreQualifiedThan(QualType Other) const;
-
-  /// Determine whether this type is at least as qualified as the other
-  /// given type, requiring exact equality for non-CVR qualifiers.
-  bool isAtLeastAsQualifiedAs(QualType Other) const;
-
   QualType getNonReferenceType() const;
 
   /// Determine the type of a (typically non-lvalue) expression with the
   /// specified result type.
   ///
   /// This routine should be used for expressions for which the return type is
   /// explicitly specified (e.g., in a cast or call) and isn't necessarily
   /// an lvalue. It removes a top-level reference (since there are no
public:
   }
 
   /// Check if this type has any address space qualifier.
   inline bool hasAddressSpace() const;
 
   /// Return the address space of this type.
   inline LangAS getAddressSpace() const;
 
-  /// Returns true if address space qualifiers overlap with T address space
-  /// qualifiers.
-  /// OpenCL C defines conversion rules for pointers to different address spaces
-  /// and notion of overlapping address spaces.
-  /// CL1.1 or CL1.2:
-  ///   address spaces overlap iff they are they same.
-  /// OpenCL C v2.0 s6.5.5 adds:
-  ///   __generic overlaps with any address space except for __constant.
-  bool isAddressSpaceOverlapping(QualType T) const {
-    Qualifiers Q = getQualifiers();
-    Qualifiers TQ = T.getQualifiers();
-    // Address spaces overlap if at least one of them is a superset of another
-    return Q.isAddressSpaceSupersetOf(TQ) || TQ.isAddressSpaceSupersetOf(Q);
-  }
-
   /// Returns gc attribute of this type.
   inline Qualifiers::GC getObjCGCAttr() const;
 
   /// true when Type is objc's weak.
   bool isObjCGCWeak() const {
     return getObjCGCAttr() == Qualifiers::Weak;
   }
 
inline FunctionType::ExtInfo getFunctionExtInfo(const Type &t) {
 
   return FunctionType::ExtInfo();
 }
 
 inline FunctionType::ExtInfo getFunctionExtInfo(QualType t) {
   return getFunctionExtInfo(*t);
 }
 
-/// Determine whether this type is more
-/// qualified than the Other type. For example, "const volatile int"
-/// is more qualified than "const int", "volatile int", and
-/// "int". However, it is not more qualified than "const volatile
-/// int".
-inline bool QualType::isMoreQualifiedThan(QualType other) const {
-  Qualifiers MyQuals = getQualifiers();
-  Qualifiers OtherQuals = other.getQualifiers();
-  return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals));
-}
-
-/// Determine whether this type is at last
-/// as qualified as the Other type. For example, "const volatile
-/// int" is at least as qualified as "const int", "volatile int",
-/// "int", and "const volatile int".
-inline bool QualType::isAtLeastAsQualifiedAs(QualType other) const {
-  Qualifiers OtherQuals = other.getQualifiers();
-
-  // Ignore __unaligned qualifier if this type is a void.
-  if (getUnqualifiedType()->isVoidType())
-    OtherQuals.removeUnaligned();
-
-  return getQualifiers().compatiblyIncludes(OtherQuals);
-}
-
 /// If Type is a reference type (e.g., const
 /// int&), returns the type that the reference refers to ("const
 /// int"). Otherwise, returns the type itself. This routine is used
 /// throughout Sema to implement C++ 5p6:
 ///
 ///   If an expression initially has the type "reference to T" (8.3.2,
 ///   8.5.3), the type is adjusted to "T" prior to any further
 ///   analysis, the expression designates the object or function

clang/include/clang/Basic/TargetInfo.h

public:
   }
 
   /// Specify if mangling based on address space map should be used or
   /// not for language specific address spaces
   bool useAddressSpaceMapMangling() const {
     return UseAddrSpaceMapMangling;
   }
 
+  /// Return true if address space A is a superspace of B.
+  /// By default, all target address spaces are disjoint.
+  virtual bool isAddressSpaceSupersetOf(LangAS A, LangAS B) const {
+    return false;
+  }
+
+  /// Return true if an explicit cast from address space From to To is legal.
+  /// This lets targets override the behavior when neither address space is a
+  /// true superset of the other, but the target still wants explicit casting
+  /// between them.
+  /// By default, explicit casting between all target address spaces is
+  /// permitted.
+  virtual bool isExplicitAddrSpaceConversionLegal(LangAS From, LangAS To) const{
+    return true;
+  }
+
   ///===---- Other target property query methods --------------------------===//
 
   /// Appends the target-specific \#define values for this
   /// target set to the specified buffer.
   virtual void getTargetDefines(const LangOptions &Opts,
                                 MacroBuilder &Builder) const = 0;
 
 

clang/lib/AST/ASTContext.cpp

if (Unqualified) {
       LHSPointee = LHSPointee.getUnqualifiedType();
       RHSPointee = RHSPointee.getUnqualifiedType();
     }
     if (getLangOpts().OpenCL) {
       Qualifiers LHSPteeQual = LHSPointee.getQualifiers();
       Qualifiers RHSPteeQual = RHSPointee.getQualifiers();
       // Blocks can't be an expression in a ternary operator (OpenCL v2.0
       // 6.12.5) thus the following check is asymmetric.
-      if (!LHSPteeQual.isAddressSpaceSupersetOf(RHSPteeQual))
+      if (!isAddressSpaceSupersetOf(LHSPteeQual, RHSPteeQual))
         return {};
       LHSPteeQual.removeAddressSpace();
       RHSPteeQual.removeAddressSpace();
       LHSPointee =
           QualType(LHSPointee.getTypePtr(), LHSPteeQual.getAsOpaqueValue());
       RHSPointee =
           QualType(RHSPointee.getTypePtr(), RHSPteeQual.getAsOpaqueValue());
     }

 
 unsigned ASTContext::getTargetAddressSpace(LangAS AS) const {
   if (isTargetAddressSpace(AS))
     return toTargetAddressSpace(AS);
   else
     return (*AddrSpaceMap)[(unsigned)AS];
 }
 
+bool ASTContext::isAddressSpaceSupersetOf(LangAS A, LangAS B) const {
+  // All address spaces are supersets of themselves.
+  if (A == B)
+    return true;
+
+  // OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of
+  // overlapping address spaces.
+  // CL1.1 or CL1.2:
+  //   every address space is a superset of itself.
+  // CL2.0 adds:
+  //   __generic is a superset of any address space except for __constant.
+  if (A == LangAS::opencl_generic &&
+      B != LangAS::opencl_constant)
+    return true;
+
+  // Consider pointer size address spaces to be equivalent to default.
+  if ((isPtrSizeAddressSpace(A) || A == LangAS::Default) &&
+      (isPtrSizeAddressSpace(B) || B == LangAS::Default))
+    return true;
+
+  // Otherwise, ask the target.
+  return Target->isAddressSpaceSupersetOf(A, B);
+}
+
+bool
+ASTContext::isExplicitAddrSpaceConversionLegal(LangAS From, LangAS To) const {
+  // If From and To overlap, the cast is legal.
+  if (isAddressSpaceOverlapping(From, To))
+    return true;
+
+  // Or, if either From or To are target address spaces, the target can
+  // decide whether or not to allow the cast regardless of overlap.
+  if (isTargetAddressSpace(From) || isTargetAddressSpace(To) ||
+      From == LangAS::Default || To == LangAS::Default)
+    return Target->isExplicitAddrSpaceConversionLegal(From, To);
+
+  // Otherwise, the cast is illegal.
+  return false;
+}
+
 QualType ASTContext::getCorrespondingSaturatedType(QualType Ty) const {
   assert(Ty->isFixedPointType());
 
   if (Ty->isSaturatedFixedPointType()) return Ty;
 
   switch (Ty->castAs<BuiltinType>()->getKind()) {
     default:
       llvm_unreachable("Not a fixed point type!");

clang/lib/Sema/SemaCast.cpp

if (CheckCVR) {
       Qualifiers DestCvrQuals =
           Qualifiers::fromCVRMask(DestQuals.getCVRQualifiers());
 
       if (SrcCvrQuals != DestCvrQuals) {
         if (CastAwayQualifiers)
           *CastAwayQualifiers = SrcCvrQuals - DestCvrQuals;
 
         // If we removed a cvr-qualifier, this is casting away 'constness'.
-        if (!DestCvrQuals.compatiblyIncludes(SrcCvrQuals)) {
+        if (!Self.Context.compatiblyIncludes(DestCvrQuals, SrcCvrQuals)) {
           if (TheOffendingSrcType)
             *TheOffendingSrcType = PrevUnwrappedSrcType;
           if (TheOffendingDestType)
             *TheOffendingDestType = PrevUnwrappedDestType;
           return WorstKind;
         }
 
         // If any prior level was not 'const', this is also casting away
void CastOperation::CheckDynamicCast() {
 
   assert((DestPointer || DestReference) &&
     "Bad destination non-ptr/ref slipped through.");
   assert((DestRecord || DestPointee->isVoidType()) &&
     "Bad destination pointee slipped through.");
   assert(SrcRecord && "Bad source pointee slipped through.");
 
   // C++ 5.2.7p1: The dynamic_cast operator shall not cast away constness.
-  if (!DestPointee.isAtLeastAsQualifiedAs(SrcPointee)) {
+  if (!Self.Context.isAtLeastAsQualifiedAs(DestPointee, SrcPointee)) {
     Self.Diag(OpRange.getBegin(), diag::err_bad_cxx_cast_qualifiers_away)
       << CT_Dynamic << OrigSrcType << this->DestType << OpRange;
     SrcExpr = ExprError();
     return;
   }
 
   // C++ 5.2.7p3: If the type of v is the same as the required result type,
   //   [except for cv].
if (SrcPointee->isVoidType()) {
           if (!CStyle) {
             Qualifiers DestPointeeQuals = DestPointee.getQualifiers();
             Qualifiers SrcPointeeQuals = SrcPointee.getQualifiers();
             DestPointeeQuals.removeObjCGCAttr();
             DestPointeeQuals.removeObjCLifetime();
             SrcPointeeQuals.removeObjCGCAttr();
             SrcPointeeQuals.removeObjCLifetime();
             if (DestPointeeQuals != SrcPointeeQuals &&
-                !DestPointeeQuals.compatiblyIncludes(SrcPointeeQuals)) {
+                !Self.Context.compatiblyIncludes(DestPointeeQuals,
+                                                 SrcPointeeQuals)) {
               msg = diag::err_bad_cxx_cast_qualifiers_away;
               return TC_Failed;
             }
           }
           Kind = IsAddressSpaceConversion(SrcType, DestType)
                      ? CK_AddressSpaceConversion
                      : CK_BitCast;
           return TC_Success;
TryStaticDowncast(Sema &Self, CanQualType SrcType, CanQualType DestType,
   // }
   // As far as the standard is concerned, p5 does not apply (A is virtual), so
   // p2 should be used instead - "const B& t(*((A*)0));" is perfectly valid.
   // However, both GCC and Comeau reject this example, and accepting it would
   // mean more complex code if we're to preserve the nice error message.
   // FIXME: Being 100% compliant here would be nice to have.
 
   // Must preserve cv, as always, unless we're in C-style mode.
-  if (!CStyle && !DestType.isAtLeastAsQualifiedAs(SrcType)) {
+  if (!CStyle && !Self.Context.isAtLeastAsQualifiedAs(DestType, SrcType)) {
     msg = diag::err_bad_cxx_cast_qualifiers_away;
     return TC_Failed;
   }
 
   if (Paths.isAmbiguous(SrcType.getUnqualifiedType())) {
     // This code is analoguous to that in CheckDerivedToBaseConversion, except
     // that it builds the paths in reverse order.
     // To sum up: record all paths to the base and build a nice string from
static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr,
   if (auto CACK =
           CastsAwayConstness(Self, SrcType, DestType, /*CheckCVR=*/!CStyle,
                              /*CheckObjCLifetime=*/CStyle))
     SuccessResult = getCastAwayConstnessCastKind(CACK, msg);
 
   if (IsAddressSpaceConversion(SrcType, DestType)) {
     Kind = CK_AddressSpaceConversion;
     assert(SrcType->isPointerType() && DestType->isPointerType());
-    if (!CStyle &&
-        !DestType->getPointeeType().getQualifiers().isAddressSpaceSupersetOf(
-            SrcType->getPointeeType().getQualifiers())) {
+    auto SrcQ = SrcType->getPointeeType().getQualifiers();
+    auto DestQ = DestType->getPointeeType().getQualifiers();
+    // Real reinterpret_casts can only do address space conversions which are
+    // 'implicit', such as subspace->superspace. For C-style casts, check if
+    // the cast is explicitly legal as well.
+    if (CStyle ? !Self.Context.isExplicitAddrSpaceConversionLegal(SrcQ, DestQ)
+               : !Self.Context.isAddressSpaceSupersetOf(DestQ, SrcQ)) {
       SuccessResult = TC_Failed;
     }
   } else if (IsLValueCast) {
     Kind = CK_LValueBitCast;
   } else if (DestType->isObjCObjectPointerType()) {
     Kind = Self.PrepareCastToObjCObjectPointer(SrcExpr);
   } else if (DestType->isBlockPointerType()) {
     if (!SrcType->isBlockPointerType()) {
static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr,
   // So we finish by allowing everything that remains - it's got to be two
   // object pointers.
   return SuccessResult;
 }
 
 static TryCastResult TryAddressSpaceCast(Sema &Self, ExprResult &SrcExpr,
                                          QualType DestType, bool CStyle,
                                          unsigned &msg, CastKind &Kind) {
-  if (!Self.getLangOpts().OpenCL)
-    // FIXME: As compiler doesn't have any information about overlapping addr
-    // spaces at the moment we have to be permissive here.
-    return TC_NotApplicable;
-  // Even though the logic below is general enough and can be applied to
-  // non-OpenCL mode too, we fast-path above because no other languages
-  // define overlapping address spaces currently.
   auto SrcType = SrcExpr.get()->getType();
   // FIXME: Should this be generalized to references? The reference parameter
   // however becomes a reference pointee type here and therefore rejected.
   // Perhaps this is the right behavior though according to C++.
   auto SrcPtrType = SrcType->getAs<PointerType>();
   if (!SrcPtrType)
     return TC_NotApplicable;
   auto DestPtrType = DestType->getAs<PointerType>();
   if (!DestPtrType)
     return TC_NotApplicable;
   auto SrcPointeeType = SrcPtrType->getPointeeType();
   auto DestPointeeType = DestPtrType->getPointeeType();
-  if (!DestPointeeType.isAddressSpaceOverlapping(SrcPointeeType)) {
+  if (!Self.Context.isExplicitAddrSpaceConversionLegal(
+        SrcPointeeType.getQualifiers(), DestPointeeType.getQualifiers())) {
     msg = diag::err_bad_cxx_cast_addr_space_mismatch;
     return TC_Failed;
   }
   auto SrcPointeeTypeWithoutAS =
       Self.Context.removeAddrSpaceQualType(SrcPointeeType.getCanonicalType());
   auto DestPointeeTypeWithoutAS =
       Self.Context.removeAddrSpaceQualType(DestPointeeType.getCanonicalType());
   if (Self.Context.hasSameType(SrcPointeeTypeWithoutAS,
void CastOperation::checkAddressSpaceCast(QualType SrcType, QualType DestType) {
 
   // Converting the top level pointee addrspace is permitted for compatible
   // addrspaces (such as 'generic int *' to 'local int *' or vice versa), but
   // if any of the nested pointee addrspaces differ, we emit a warning
   // regardless of addrspace compatibility. This makes
   //   local int ** p;
   //   return (generic int **) p;
   // warn even though local -> generic is permitted.
-  if (Self.getLangOpts().OpenCL) {
-    const Type *DestPtr, *SrcPtr;
-    bool Nested = false;
-    unsigned DiagID = diag::err_typecheck_incompatible_address_space;
-    DestPtr = Self.getASTContext().getCanonicalType(DestType.getTypePtr()),
-    SrcPtr  = Self.getASTContext().getCanonicalType(SrcType.getTypePtr());
 
-    while (isa<PointerType>(DestPtr) && isa<PointerType>(SrcPtr)) {
-      const PointerType *DestPPtr = cast<PointerType>(DestPtr);
-      const PointerType *SrcPPtr = cast<PointerType>(SrcPtr);
-      QualType DestPPointee = DestPPtr->getPointeeType();
-      QualType SrcPPointee = SrcPPtr->getPointeeType();
-      if (Nested
-              ? DestPPointee.getAddressSpace() != SrcPPointee.getAddressSpace()
-              : !DestPPointee.isAddressSpaceOverlapping(SrcPPointee)) {
-        Self.Diag(OpRange.getBegin(), DiagID)
-            << SrcType << DestType << Sema::AA_Casting
-            << SrcExpr.get()->getSourceRange();
-        if (!Nested)
-          SrcExpr = ExprError();
-        return;
-      }
+            : !Self.Context.isExplicitAddrSpaceConversionLegal(
+                 SrcPPointee.getAddressSpace(),
+                 DestPPointee.getAddressSpace())) {
 
-      DestPtr = DestPPtr->getPointeeType().getTypePtr();
-      SrcPtr = SrcPPtr->getPointeeType().getTypePtr();
-      Nested = true;
-      DiagID = diag::ext_nested_pointer_qualifier_mismatch;
-    }
-  }
-}
 
 void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
                                        bool ListInitialization) {
   assert(Self.getLangOpts().CPlusPlus);
 
   // Handle placeholders.
   if (isPlaceholder()) {
     // C-style casts can resolve __unknown_any types.

clang/lib/Sema/SemaChecking.cpp

bool Sema::CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall,
   // what the appropriate type is.
   QualType ValType = pointerType->getPointeeType();
   QualType AddrType = ValType.getUnqualifiedType().withVolatile();
   if (IsLdrex)
     AddrType.addConst();
 
   // Issue a warning if the cast is dodgy.
   CastKind CastNeeded = CK_NoOp;
-  if (!AddrType.isAtLeastAsQualifiedAs(ValType)) {
+  if (!Context.isAtLeastAsQualifiedAs(AddrType, ValType)) {
     CastNeeded = CK_BitCast;
     Diag(DRE->getBeginLoc(), diag::ext_typecheck_convert_discards_qualifiers)
         << PointerArg->getType() << Context.getPointerType(AddrType)
         << AA_Passing << PointerArg->getSourceRange();
   }
 
   // Finally, do the cast and replace the argument with the corrected version.
   AddrType = Context.getPointerType(AddrType);

clang/lib/Sema/SemaCodeComplete.cpp

if (CandidateRef != IncumbentRef) {
     if (ObjectKind == clang::VK_XValue)
       return CandidateRef == RQ_RValue ? OverloadCompare::Dominates
                                        : OverloadCompare::Dominated;
   }
   // Now the ref qualifiers are the same (or we're in some invalid state).
   // So make some decision based on the qualifiers.
   Qualifiers CandidateQual = Candidate.getMethodQualifiers();
   Qualifiers IncumbentQual = Incumbent.getMethodQualifiers();
-  bool CandidateSuperset = CandidateQual.compatiblyIncludes(IncumbentQual);
-  bool IncumbentSuperset = IncumbentQual.compatiblyIncludes(CandidateQual);
+  bool CandidateSuperset =
+    Candidate.getASTContext().compatiblyIncludes(CandidateQual, IncumbentQual);
+  bool IncumbentSuperset =
+    Candidate.getASTContext().compatiblyIncludes(IncumbentQual, CandidateQual);
   if (CandidateSuperset == IncumbentSuperset)
     return OverloadCompare::BothViable;
   return IncumbentSuperset ? OverloadCompare::Dominates
                            : OverloadCompare::Dominated;
 }
 
 void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
                               NamedDecl *Hiding, bool InBaseClass = false) {

clang/lib/Sema/SemaDeclCXX.cpp

Diag(New->getLocation(),
         << New->getReturnTypeSourceRange();
     Diag(Old->getLocation(), diag::note_overridden_virtual_function)
         << Old->getReturnTypeSourceRange();
     return true;
   }
 
 
   // The new class type must have the same or less qualifiers as the old type.
-  if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
+  if (Context.isMoreQualifiedThan(NewClassTy, OldClassTy)) {
     Diag(New->getLocation(),
          diag::err_covariant_return_type_class_type_more_qualified)
         << New->getDeclName() << NewTy << OldTy
         << New->getReturnTypeSourceRange();
     Diag(Old->getLocation(), diag::note_overridden_virtual_function)
         << Old->getReturnTypeSourceRange();
     return true;
   }

clang/lib/Sema/SemaExceptionSpec.cpp

if (!ExceptionType->isPointerType() || !HandlerType->isPointerType())
       return false;
 
     // Handle the "qualification conversion" portion.
     Qualifiers EQuals, HQuals;
     ExceptionType = Context.getUnqualifiedArrayType(
         ExceptionType->getPointeeType(), EQuals);
     HandlerType = Context.getUnqualifiedArrayType(
         HandlerType->getPointeeType(), HQuals);
-    if (!HQuals.compatiblyIncludes(EQuals))
+    if (!Context.compatiblyIncludes(HQuals, EQuals))
       return false;
 
     if (HandlerType->isVoidType() && ExceptionType->isObjectType())
       return true;
 
     // The only remaining case is a derived-to-base conversion.
   }
 

clang/lib/Sema/SemaExpr.cpp

static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS,
   Qualifiers rhQual = rhptee.getQualifiers();
 
   LangAS ResultAddrSpace = LangAS::Default;
   LangAS LAddrSpace = lhQual.getAddressSpace();
   LangAS RAddrSpace = rhQual.getAddressSpace();
 
   // OpenCL v1.1 s6.5 - Conversion between pointers to distinct address
   // spaces is disallowed.
-  if (lhQual.isAddressSpaceSupersetOf(rhQual))
+  if (S.Context.isAddressSpaceSupersetOf(lhQual, rhQual))
     ResultAddrSpace = LAddrSpace;
-  else if (rhQual.isAddressSpaceSupersetOf(lhQual))
+  else if (S.Context.isAddressSpaceSupersetOf(rhQual, lhQual))
     ResultAddrSpace = RAddrSpace;
   else {
     S.Diag(Loc, diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
         << LHSTy << RHSTy << 2 << LHS.get()->getSourceRange()
         << RHS.get()->getSourceRange();
     return QualType();
   }
 
checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType) {
   // As a special case, 'non-__weak A *' -> 'non-__weak const *' is okay.
   if (lhq.getObjCLifetime() != rhq.getObjCLifetime() &&
       lhq.compatiblyIncludesObjCLifetime(rhq)) {
     // Ignore lifetime for further calculation.
     lhq.removeObjCLifetime();
     rhq.removeObjCLifetime();
   }
 
-  if (!lhq.compatiblyIncludes(rhq)) {
+  if (!S.Context.compatiblyIncludes(lhq, rhq)) {
     // Treat address-space mismatches as fatal.
-    if (!lhq.isAddressSpaceSupersetOf(rhq))
+    if (!S.Context.isAddressSpaceSupersetOf(lhq, rhq))
       return Sema::IncompatiblePointerDiscardsQualifiers;
 
     // It's okay to add or remove GC or lifetime qualifiers when converting to
     // and from void*.
-    else if (lhq.withoutObjCGCAttr().withoutObjCLifetime()
-                        .compatiblyIncludes(
-                                rhq.withoutObjCGCAttr().withoutObjCLifetime())
+    else if (S.Context.compatiblyIncludes(lhq.withoutObjCGCAttr()
+                                             .withoutObjCLifetime(),
+                                          rhq.withoutObjCGCAttr()
+                                             .withoutObjCLifetime())
              && (lhptee->isVoidType() || rhptee->isVoidType()))
       ; // keep old
 
     // Treat lifetime mismatches as fatal.
     else if (lhq.getObjCLifetime() != rhq.getObjCLifetime())
       ConvTy = Sema::IncompatiblePointerDiscardsQualifiers;
 
     // For GCC/MS compatibility, other qualifier mismatches are treated
if (RHSType->isObjCBuiltinType()) {
     if (RHSType->isObjCClassType() && !LHSType->isObjCBuiltinType() &&
         !LHSType->isObjCQualifiedClassType())
       return Sema::IncompatiblePointer;
     return Sema::Compatible;
   }
   QualType lhptee = LHSType->castAs<ObjCObjectPointerType>()->getPointeeType();
   QualType rhptee = RHSType->castAs<ObjCObjectPointerType>()->getPointeeType();
 
-  if (!lhptee.isAtLeastAsQualifiedAs(rhptee) &&
+  if (!S.Context.isAtLeastAsQualifiedAs(lhptee, rhptee) &&
       // make an exception for id<P>
       !LHSType->isObjCQualifiedIdType())
     return Sema::CompatiblePointerDiscardsQualifiers;
 
   if (S.Context.typesAreCompatible(LHSType, RHSType))
     return Sema::Compatible;
   if (LHSType->isObjCQualifiedIdType() || RHSType->isObjCQualifiedIdType())
     return Sema::IncompatibleObjCQualifiedId;
static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc,
   if (!isLHSPointer && !isRHSPointer) return true;
 
   QualType LHSPointeeTy, RHSPointeeTy;
   if (isLHSPointer) LHSPointeeTy = LHSExpr->getType()->getPointeeType();
   if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType();
 
   // if both are pointers check if operation is valid wrt address spaces
   if (isLHSPointer && isRHSPointer) {
-    if (!LHSPointeeTy.isAddressSpaceOverlapping(RHSPointeeTy)) {
+    if (!S.Context.isAddressSpaceOverlapping(
+          LHSPointeeTy.getAddressSpace(),
+          RHSPointeeTy.getAddressSpace())) {
       S.Diag(Loc,
              diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
           << LHSExpr->getType() << RHSExpr->getType() << 1 /*arithmetic op*/
           << LHSExpr->getSourceRange() << RHSExpr->getSourceRange();
       return false;
     }
   }
 
if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(),
           && !LHSIsNull && !RHSIsNull)
         diagnoseFunctionPointerToVoidComparison(*this, Loc, LHS, RHS,
                                                 /*isError*/false);
     } else {
       // Invalid
       diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, /*isError*/false);
     }
     if (LCanPointeeTy != RCanPointeeTy) {
-      // Treat NULL constant as a special case in OpenCL.
-      if (getLangOpts().OpenCL && !LHSIsNull && !RHSIsNull) {
-        if (!LCanPointeeTy.isAddressSpaceOverlapping(RCanPointeeTy)) {
+      if (!LHSIsNull && !RHSIsNull) {
+        if (!Context.isAddressSpaceOverlapping(
+              LCanPointeeTy.getAddressSpace(),
+              RCanPointeeTy.getAddressSpace())) {
           Diag(Loc,
                diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
               << LHSType << RHSType << 0 /* comparison */
               << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
         }
       }
       LangAS AddrSpaceL = LCanPointeeTy.getAddressSpace();
       LangAS AddrSpaceR = RCanPointeeTy.getAddressSpace();

clang/lib/Sema/SemaExprCXX.cpp

case ICK_Complex_Real:
     }
     break;
 
   case ICK_Block_Pointer_Conversion: {
     LangAS AddrSpaceL =
         ToType->castAs<BlockPointerType>()->getPointeeType().getAddressSpace();
     LangAS AddrSpaceR =
         FromType->castAs<BlockPointerType>()->getPointeeType().getAddressSpace();
-    assert(Qualifiers::isAddressSpaceSupersetOf(AddrSpaceL, AddrSpaceR) &&
+    assert(Context.isAddressSpaceSupersetOf(AddrSpaceL, AddrSpaceR) &&
            "Invalid cast");
     CastKind Kind =
         AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
     From = ImpCastExprToType(From, ToType.getUnqualifiedType(), Kind,
                              VK_RValue, /*BasePath=*/nullptr, CCK).get();
     break;
   }
 
static bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
   bool FDerivedFromT = FRec && TRec && FRec != TRec &&
                        Self.IsDerivedFrom(QuestionLoc, FTy, TTy);
   if (FRec && TRec && (FRec == TRec || FDerivedFromT ||
                        Self.IsDerivedFrom(QuestionLoc, TTy, FTy))) {
     //         E1 can be converted to match E2 if the class of T2 is the
     //         same type as, or a base class of, the class of T1, and
     //         [cv2 > cv1].
     if (FRec == TRec || FDerivedFromT) {
-      if (TTy.isAtLeastAsQualifiedAs(FTy)) {
+      if (Self.Context.isAtLeastAsQualifiedAs(TTy, FTy)) {
         InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy);
         InitializationSequence InitSeq(Self, Entity, Kind, From);
         if (InitSeq) {
           HaveConversion = true;
           return false;
         }
 
         if (InitSeq.isAmbiguous())
if (!Steps.empty()) {
       Qualifiers Quals = Qualifiers::fromCVRUMask(Q1.getCVRUQualifiers() |
                                                   Q2.getCVRUQualifiers());
 
       // Under one level of pointer or pointer-to-member, we can change to an
       // unambiguous compatible address space.
       if (Q1.getAddressSpace() == Q2.getAddressSpace()) {
         Quals.setAddressSpace(Q1.getAddressSpace());
       } else if (Steps.size() == 1) {
-        bool MaybeQ1 = Q1.isAddressSpaceSupersetOf(Q2);
-        bool MaybeQ2 = Q2.isAddressSpaceSupersetOf(Q1);
+        bool MaybeQ1 = Context.isAddressSpaceSupersetOf(Q1, Q2);
+        bool MaybeQ2 = Context.isAddressSpaceSupersetOf(Q2, Q1);
         if (MaybeQ1 == MaybeQ2)
           return QualType(); // No unique best address space.
         Quals.setAddressSpace(MaybeQ1 ? Q1.getAddressSpace()
                                       : Q2.getAddressSpace());
       } else {
         return QualType();
       }
 

clang/lib/Sema/SemaFixItUtils.cpp

 
 using namespace clang;
 
 bool ConversionFixItGenerator::compareTypesSimple(CanQualType From,
                                                   CanQualType To,
                                                   Sema &S,
                                                   SourceLocation Loc,
                                                   ExprValueKind FromVK) {
-  if (!To.isAtLeastAsQualifiedAs(From))
+  if (!S.Context.isAtLeastAsQualifiedAs(To, From))
     return false;
 
   From = From.getNonReferenceType();
   To = To.getNonReferenceType();
 
   // If both are pointer types, work with the pointee types.
   if (isa<PointerType>(From) && isa<PointerType>(To)) {
     From = S.Context.getCanonicalType(
         (cast<PointerType>(From))->getPointeeType());
     To = S.Context.getCanonicalType(
         (cast<PointerType>(To))->getPointeeType());
   }
 
   const CanQualType FromUnq = From.getUnqualifiedType();
   const CanQualType ToUnq = To.getUnqualifiedType();
 
   if ((FromUnq == ToUnq || (S.IsDerivedFrom(Loc, FromUnq, ToUnq)) ) &&
-      To.isAtLeastAsQualifiedAs(From))
+      S.Context.isAtLeastAsQualifiedAs(To, From))
     return true;
   return false;
 }
 
 bool ConversionFixItGenerator::tryToFixConversion(const Expr *FullExpr,
                                                   const QualType FromTy,
                                                   const QualType ToTy,
                                                   Sema &S) {

clang/lib/Sema/SemaInit.cpp

static void TryReferenceInitializationCore(Sema &S,
   }
 
   //     - Otherwise, the reference shall be an lvalue reference to a
   //       non-volatile const type (i.e., cv1 shall be const), or the reference
   //       shall be an rvalue reference.
   //       For address spaces, we interpret this to mean that an addr space
   //       of a reference "cv1 T1" is a superset of addr space of "cv2 T2".
   if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile() &&
-                       T1Quals.isAddressSpaceSupersetOf(T2Quals))) {
+                       S.Context.isAddressSpaceSupersetOf(T1Quals, T2Quals))) {
     if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
       Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
     else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
       Sequence.SetOverloadFailure(
                         InitializationSequence::FK_ReferenceInitOverloadFailed,
                                   ConvOvlResult);
     else if (!InitCategory.isLValue())
       Sequence.SetFailed(
-          T1Quals.isAddressSpaceSupersetOf(T2Quals)
+          S.Context.isAddressSpaceSupersetOf(T1Quals, T2Quals)
               ? InitializationSequence::
                     FK_NonConstLValueReferenceBindingToTemporary
               : InitializationSequence::FK_ReferenceInitDropsQualifiers);
     else {
       InitializationSequence::FailureKind FK;
       switch (RefRelationship) {
       case Sema::Ref_Compatible:
         if (Initializer->refersToBitField())
static void TryReferenceInitializationCore(Sema &S,
 
   //        [...] If T1 is reference-related to T2, cv1 must be the
   //        same cv-qualification as, or greater cv-qualification
   //        than, cv2; otherwise, the program is ill-formed.
   unsigned T1CVRQuals = T1Quals.getCVRQualifiers();
   unsigned T2CVRQuals = T2Quals.getCVRQualifiers();
   if ((RefRelationship == Sema::Ref_Related &&
        (T1CVRQuals | T2CVRQuals) != T1CVRQuals) ||
-      !T1Quals.isAddressSpaceSupersetOf(T2Quals)) {
+      !S.Context.isAddressSpaceSupersetOf(T1Quals, T2Quals)) {
     Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
     return;
   }
 
   //   [...] If T1 is reference-related to T2 and the reference is an rvalue
   //   reference, the initializer expression shall not be an lvalue.
   if (RefRelationship >= Sema::Ref_Related && !isLValueRef &&
       InitCategory.isLValue()) {
     Sequence.SetFailed(
                     InitializationSequence::FK_RValueReferenceBindingToLValue);
     return;
   }
 
   Sequence.AddReferenceBindingStep(cv1T1IgnoreAS, /*BindingTemporary=*/true);
 
   if (T1Quals.hasAddressSpace()) {
-    if (!Qualifiers::isAddressSpaceSupersetOf(T1Quals.getAddressSpace(),
-                                              LangAS::Default)) {
+    if (!S.Context.isAddressSpaceSupersetOf(T1Quals.getAddressSpace(),
       Sequence.SetFailed(
           InitializationSequence::FK_ReferenceAddrspaceMismatchTemporary);
       return;
     }
     Sequence.AddQualificationConversionStep(cv1T1, isLValueRef ? VK_LValue
                                                                : VK_XValue);
   }
 }
case FK_ReferenceAddrspaceMismatchTemporary:
     break;
 
   case FK_ReferenceInitDropsQualifiers: {
     QualType SourceType = OnlyArg->getType();
     QualType NonRefType = DestType.getNonReferenceType();
     Qualifiers DroppedQualifiers =
         SourceType.getQualifiers() - NonRefType.getQualifiers();
 
-    if (!NonRefType.getQualifiers().isAddressSpaceSupersetOf(
+    if (!S.Context.isAddressSpaceSupersetOf(NonRefType.getQualifiers(),
                                             SourceType.getQualifiers()))
       S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
           << NonRefType << SourceType << 1 /*addr space*/
           << Args[0]->getSourceRange();
     else if (DroppedQualifiers.hasQualifiers())
       S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
           << NonRefType << SourceType << 0 /*cv quals*/
           << Qualifiers::fromCVRMask(DroppedQualifiers.getCVRQualifiers())
           << DroppedQualifiers.getCVRQualifiers() << Args[0]->getSourceRange();

clang/lib/Sema/SemaOpenMP.cpp

if (auto *VD = filterLookupForUDReductionAndMapper<ValueDecl *>(
           }))
     return SemaRef.BuildDeclRefExpr(VD, VD->getType().getNonReferenceType(),
                                     VK_LValue, Loc);
   if (SemaRef.getLangOpts().CPlusPlus) {
     if (auto *VD = filterLookupForUDReductionAndMapper<ValueDecl *>(
             Lookups, [&SemaRef, Ty, Loc](ValueDecl *D) -> ValueDecl * {
               if (!D->isInvalidDecl() &&
                   SemaRef.IsDerivedFrom(Loc, Ty, D->getType()) &&
-                  !Ty.isMoreQualifiedThan(D->getType()))
+                  !SemaRef.Context.isMoreQualifiedThan(Ty, D->getType()))
                 return D;
               return nullptr;
             })) {
       CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
                          /*DetectVirtual=*/false);
       if (SemaRef.IsDerivedFrom(Loc, Ty, VD->getType(), Paths)) {
         if (!Paths.isAmbiguous(SemaRef.Context.getCanonicalType(
                 VD->getType().getUnqualifiedType()))) {
if (auto *VD = filterLookupForUDReductionAndMapper<ValueDecl *>(
           }))
     return SemaRef.BuildDeclRefExpr(VD, Type, VK_LValue, Loc);
   // Find the first user-defined mapper with a type derived from the desired
   // type.
   if (auto *VD = filterLookupForUDReductionAndMapper<ValueDecl *>(
           Lookups, [&SemaRef, Type, Loc](ValueDecl *D) -> ValueDecl * {
             if (!D->isInvalidDecl() &&
                 SemaRef.IsDerivedFrom(Loc, Type, D->getType()) &&
-                !Type.isMoreQualifiedThan(D->getType()))
+                !SemaRef.Context.isMoreQualifiedThan(Type, D->getType()))
               return D;
             return nullptr;
           })) {
     CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
                        /*DetectVirtual=*/false);
     if (SemaRef.IsDerivedFrom(Loc, Type, VD->getType(), Paths)) {
       if (!Paths.isAmbiguous(SemaRef.Context.getCanonicalType(
               VD->getType().getUnqualifiedType()))) {

clang/lib/Sema/SemaOverload.cpp

 /// Adopt the given qualifiers for the given type.
 static QualType AdoptQualifiers(ASTContext &Context, QualType T, Qualifiers Qs){
   Qualifiers TQs = T.getQualifiers();
 
   // Check whether qualifiers already match.
   if (TQs == Qs)
     return T;
 
-  if (Qs.compatiblyIncludes(TQs))
+  if (Context.compatiblyIncludes(Qs, TQs))
     return Context.getQualifiedType(T, Qs);
 
   return Context.getQualifiedType(T.getUnqualifiedType(), Qs);
 }
 
 /// isObjCPointerConversion - Determines whether this is an
 /// Objective-C pointer conversion. Subroutine of IsPointerConversion,
 /// with the same arguments and return values.
if (Context.hasSameUnqualifiedType(ToObjCPtr->getPointeeType(),
                                        FromObjCPtr->getPointeeType()))
       return false;
 
     // Conversion between Objective-C pointers.
     if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) {
       const ObjCInterfaceType* LHS = ToObjCPtr->getInterfaceType();
       const ObjCInterfaceType* RHS = FromObjCPtr->getInterfaceType();
       if (getLangOpts().CPlusPlus && LHS && RHS &&
-          !ToObjCPtr->getPointeeType().isAtLeastAsQualifiedAs(
-                                                FromObjCPtr->getPointeeType()))
+          !Context.isAtLeastAsQualifiedAs(ToObjCPtr->getPointeeType(),
         return false;
       ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
                                                    ToObjCPtr->getPointeeType(),
                                                          ToType, Context);
       ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
       return true;
     }
 
bool Sema::isObjCWritebackConversion(QualType FromType, QualType ToType,
   Qualifiers FromQuals = FromPointee.getQualifiers();
   if (!FromPointee->isObjCLifetimeType() ||
       (FromQuals.getObjCLifetime() != Qualifiers::OCL_Strong &&
        FromQuals.getObjCLifetime() != Qualifiers::OCL_Weak))
     return false;
 
   // Make sure that we have compatible qualifiers.
   FromQuals.setObjCLifetime(Qualifiers::OCL_Autoreleasing);
-  if (!ToQuals.compatiblyIncludes(FromQuals))
+  if (!Context.compatiblyIncludes(ToQuals, FromQuals))
     return false;
 
   // Remove qualifiers from the pointee type we're converting from; they
   // aren't used in the compatibility check belong, and we'll be adding back
   // qualifiers (with __autoreleasing) if the compatibility check succeeds.
   FromPointee = FromPointee.getUnqualifiedType();
 
   // The unqualified form of the pointee types must be compatible.

 }
 
 /// Perform a single iteration of the loop for checking if a qualification
 /// conversion is valid.
 ///
 /// Specifically, check whether any change between the qualifiers of \p
 /// FromType and \p ToType is permissible, given knowledge about whether every
 /// outer layer is const-qualified.
-static bool isQualificationConversionStep(QualType FromType, QualType ToType,
+static bool isQualificationConversionStep(ASTContext &Context,
+                                          QualType FromType, QualType ToType,
                                           bool CStyle, bool IsTopLevel,
                                           bool &PreviousToQualsIncludeConst,
                                           bool &ObjCLifetimeConversion) {
   Qualifiers FromQuals = FromType.getQualifiers();
   Qualifiers ToQuals = ToType.getQualifiers();
 
   // Ignore __unaligned qualifier if this type is void.
   if (ToType.getUnqualifiedType()->isVoidType())
static bool isQualificationConversionStep(ASTContext &Context,
   if (FromQuals.getObjCGCAttr() != ToQuals.getObjCGCAttr() &&
       (!FromQuals.hasObjCGCAttr() || !ToQuals.hasObjCGCAttr())) {
     FromQuals.removeObjCGCAttr();
     ToQuals.removeObjCGCAttr();
   }
 
   //   -- for every j > 0, if const is in cv 1,j then const is in cv
   //      2,j, and similarly for volatile.
-  if (!CStyle && !ToQuals.compatiblyIncludes(FromQuals))
+  if (!CStyle && !Context.compatiblyIncludes(ToQuals, FromQuals))
     return false;
 
   // If address spaces mismatch:
   //  - in top level it is only valid to convert to addr space that is a
   //    superset in all cases apart from C-style casts where we allow
   //    conversions between overlapping address spaces.
   //  - in non-top levels it is not a valid conversion.
+  // FIXME: This should probably be using isExplicitAddrSpaceConversionLegal,
+  // but we don't know if this is an implicit or explicit conversion.
   if (ToQuals.getAddressSpace() != FromQuals.getAddressSpace() &&
       (!IsTopLevel ||
-       !(ToQuals.isAddressSpaceSupersetOf(FromQuals) ||
-         (CStyle && FromQuals.isAddressSpaceSupersetOf(ToQuals)))))
+       !(Context.isAddressSpaceSupersetOf(ToQuals, FromQuals) ||
+         (CStyle && Context.isExplicitAddrSpaceConversionLegal(FromQuals,
+                                                               ToQuals)))))
     return false;
 
   //   -- if the cv 1,j and cv 2,j are different, then const is in
   //      every cv for 0 < k < j.
   if (!CStyle && FromQuals.getCVRQualifiers() != ToQuals.getCVRQualifiers() &&
       !PreviousToQualsIncludeConst)
     return false;
 
Sema::IsQualificationConversion(QualType FromType, QualType ToType,
 
   // (C++ 4.4p4):
   //   A conversion can add cv-qualifiers at levels other than the first
   //   in multi-level pointers, subject to the following rules: [...]
   bool PreviousToQualsIncludeConst = true;
   bool UnwrappedAnyPointer = false;
   while (Context.UnwrapSimilarTypes(FromType, ToType)) {
     if (!isQualificationConversionStep(
-            FromType, ToType, CStyle, !UnwrappedAnyPointer,
+            Context, FromType, ToType, CStyle, !UnwrappedAnyPointer,
             PreviousToQualsIncludeConst, ObjCLifetimeConversion))
       return false;
     UnwrappedAnyPointer = true;
   }
 
   // We are left with FromType and ToType being the pointee types
   // after unwrapping the original FromType and ToType the same number
   // of times. If we unwrapped any pointers, and if FromType and
if (UnqualT1 == UnqualT2) {
       }
 
       // If the type is an array type, promote the element qualifiers to the
       // type for comparison.
       if (isa<ArrayType>(T1) && T1Quals)
         T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
       if (isa<ArrayType>(T2) && T2Quals)
         T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
-      if (T2.isMoreQualifiedThan(T1))
+      if (S.Context.isMoreQualifiedThan(T2, T1))
         return ImplicitConversionSequence::Better;
-      if (T1.isMoreQualifiedThan(T2))
+      if (S.Context.isMoreQualifiedThan(T1, T2))
         return ImplicitConversionSequence::Worse;
     }
   }
 
   // In Microsoft mode, prefer an integral conversion to a
   // floating-to-integral conversion if the integral conversion
   // is between types of the same size.
   // For example:
while (S.Context.UnwrapSimilarTypes(T1, T2)) {
     // strict subset of qualifiers.
     if (T1.getQualifiers().withoutObjCLifetime() ==
         T2.getQualifiers().withoutObjCLifetime())
       // The qualifiers are the same, so this doesn't tell us anything
       // about how the sequences rank.
       // ObjC ownership quals are omitted above as they interfere with
       // the ARC overload rule.
       ;
-    else if (T2.isMoreQualifiedThan(T1)) {
+    else if (S.Context.isMoreQualifiedThan(T2, T1)) {
       // T1 has fewer qualifiers, so it could be the better sequence.
       if (Result == ImplicitConversionSequence::Worse)
         // Neither has qualifiers that are a subset of the other's
         // qualifiers.
         return ImplicitConversionSequence::Indistinguishable;
 
       Result = ImplicitConversionSequence::Better;
-    } else if (T1.isMoreQualifiedThan(T2)) {
+    } else if (S.Context.isMoreQualifiedThan(T1, T2)) {
       // T2 has fewer qualifiers, so it could be the better sequence.
       if (Result == ImplicitConversionSequence::Better)
         // Neither has qualifiers that are a subset of the other's
         // qualifiers.
         return ImplicitConversionSequence::Indistinguishable;
 
       Result = ImplicitConversionSequence::Worse;
     } else {
do {
 
     // MS compiler ignores __unaligned qualifier for references; do the same.
     T1 = withoutUnaligned(Context, T1);
     T2 = withoutUnaligned(Context, T2);
 
     // If we find a qualifier mismatch, the types are not reference-compatible,
     // but are still be reference-related if they're similar.
     bool ObjCLifetimeConversion = false;
-    if (!isQualificationConversionStep(T2, T1, /*CStyle=*/false, TopLevel,
-                                       PreviousToQualsIncludeConst,
+    if (!isQualificationConversionStep(Context, T2, T1, /*CStyle=*/false,
+                                       TopLevel, PreviousToQualsIncludeConst,
                                        ObjCLifetimeConversion))
       return (ConvertedReferent || Context.hasSimilarType(T1, T2))
                  ? Ref_Related
                  : Ref_Incompatible;
 
     // FIXME: Should we track this for any level other than the first?
     if (ObjCLifetimeConversion)
       Conv |= ReferenceConversions::ObjCLifetime;
if (RefRelationship == Sema::Ref_Related) {
     Qualifiers T2Quals = T2.getQualifiers();
     T1Quals.removeObjCGCAttr();
     T1Quals.removeObjCLifetime();
     T2Quals.removeObjCGCAttr();
     T2Quals.removeObjCLifetime();
     // MS compiler ignores __unaligned qualifier for references; do the same.
     T1Quals.removeUnaligned();
     T2Quals.removeUnaligned();
-    if (!T1Quals.compatiblyIncludes(T2Quals))
+    if (!S.Context.compatiblyIncludes(T1Quals, T2Quals))
       return ICS;
   }
 
   // If at least one of the types is a class type, the types are not
   // related, and we aren't allowed any user conversions, the
   // reference binding fails. This case is important for breaking
   // recursion, since TryImplicitConversion below will attempt to
   // create a temporary through the use of a copy constructor.
TryObjectArgumentInitialization(Sema &S, SourceLocation Loc, QualType FromType,
   // However, when finding an implicit conversion sequence for the argument, we
   // are not allowed to perform user-defined conversions
   // (C++ [over.match.funcs]p5). We perform a simplified version of
   // reference binding here, that allows class rvalues to bind to
   // non-constant references.
 
   // First check the qualifiers.
   QualType FromTypeCanon = S.Context.getCanonicalType(FromType);
   if (ImplicitParamType.getCVRQualifiers()
                                     != FromTypeCanon.getLocalCVRQualifiers() &&
-      !ImplicitParamType.isAtLeastAsQualifiedAs(FromTypeCanon)) {
+      !S.Context.isAtLeastAsQualifiedAs(ImplicitParamType, FromTypeCanon)) {
     ICS.setBad(BadConversionSequence::bad_qualifiers,
                FromType, ImplicitParamType);
     return ICS;
   }
 
+  // FIXME: hasAddressSpace is wrong; this check will be skipped if FromType is
+  // not qualified with an address space, but if there's no implicit conversion
+  // from Default to ImplicitParamType's AS, that's an error.
   if (FromTypeCanon.hasAddressSpace()) {
     Qualifiers QualsImplicitParamType = ImplicitParamType.getQualifiers();
     Qualifiers QualsFromType = FromTypeCanon.getQualifiers();
-    if (!QualsImplicitParamType.isAddressSpaceSupersetOf(QualsFromType)) {
+    if (!S.Context.isAddressSpaceSupersetOf(QualsImplicitParamType,
+                                            QualsFromType)) {
       ICS.setBad(BadConversionSequence::bad_qualifiers,
                  FromType, ImplicitParamType);
       return ICS;
     }
   }
 
   // Check that we have either the same type or a derived type. It
   // affects the conversion rank.
if (Shadow && Args.size() == 1 && Constructor->getNumParams() >= 1 &&
         Candidate.Viable = false;
         Candidate.FailureKind = ovl_fail_inhctor_slice;
         return;
       }
     }
 
     // Check that the constructor is capable of constructing an object in the
     // destination address space.
-    if (!Qualifiers::isAddressSpaceSupersetOf(
+    if (!Context.isAddressSpaceSupersetOf(
             Constructor->getMethodQualifiers().getAddressSpace(),
             CandidateSet.getDestAS())) {
       Candidate.Viable = false;
       Candidate.FailureKind = ovl_fail_object_addrspace_mismatch;
     }
   }
 
   unsigned NumParams = Proto->getNumParams();
else {
     if (CanQual<PointerType> FromPT = CFromTy->getAs<PointerType>())
       if (CanQual<PointerType> ToPT = CToTy->getAs<PointerType>()) {
         CFromTy = FromPT->getPointeeType();
         CToTy = ToPT->getPointeeType();
       }
   }
 
   if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() &&
-      !CToTy.isAtLeastAsQualifiedAs(CFromTy)) {
+      !S.Context.isAtLeastAsQualifiedAs(CToTy, CFromTy)) {
     Qualifiers FromQs = CFromTy.getQualifiers();
     Qualifiers ToQs = CToTy.getQualifiers();
 
     if (FromQs.getAddressSpace() != ToQs.getAddressSpace()) {
       if (isObjectArgument)
         S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace_this)
             << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second
             << FnDesc << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
if (TempFromTy->isIncompleteType()) {
     MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
     return;
   }
 
   // Diagnose base -> derived pointer conversions.
   unsigned BaseToDerivedConversion = 0;
   if (const PointerType *FromPtrTy = FromTy->getAs<PointerType>()) {
     if (const PointerType *ToPtrTy = ToTy->getAs<PointerType>()) {
-      if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
-                                               FromPtrTy->getPointeeType()) &&
+      if (S.Context.isAtLeastAsQualifiedAs(ToPtrTy->getPointeeType(),
           !FromPtrTy->getPointeeType()->isIncompleteType() &&
           !ToPtrTy->getPointeeType()->isIncompleteType() &&
           S.IsDerivedFrom(SourceLocation(), ToPtrTy->getPointeeType(),
                           FromPtrTy->getPointeeType()))
         BaseToDerivedConversion = 1;
     }
   } else if (const ObjCObjectPointerType *FromPtrTy
                                     = FromTy->getAs<ObjCObjectPointerType>()) {
     if (const ObjCObjectPointerType *ToPtrTy
                                         = ToTy->getAs<ObjCObjectPointerType>())
       if (const ObjCInterfaceDecl *FromIface = FromPtrTy->getInterfaceDecl())
         if (const ObjCInterfaceDecl *ToIface = ToPtrTy->getInterfaceDecl())
-          if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
-                                                FromPtrTy->getPointeeType()) &&
+          if (S.Context.isAtLeastAsQualifiedAs(ToPtrTy->getPointeeType(),
               FromIface->isSuperClassOf(ToIface))
             BaseToDerivedConversion = 2;
   } else if (const ReferenceType *ToRefTy = ToTy->getAs<ReferenceType>()) {
-    if (ToRefTy->getPointeeType().isAtLeastAsQualifiedAs(FromTy) &&
+    if (S.Context.isAtLeastAsQualifiedAs(ToRefTy->getPointeeType(), FromTy) &&
         !FromTy->isIncompleteType() &&
         !ToRefTy->getPointeeType()->isIncompleteType() &&
         S.IsDerivedFrom(SourceLocation(), ToRefTy->getPointeeType(), FromTy)) {
       BaseToDerivedConversion = 3;
     } else if (ToTy->isLValueReferenceType() && !FromExpr->isLValue() &&
                ToTy.getNonReferenceType().getCanonicalType() ==
                FromTy.getNonReferenceType().getCanonicalType()) {
       S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_lvalue)
           << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
           << (unsigned)isObjectArgument << I + 1
           << (FromExpr ? FromExpr->getSourceRange() : SourceRange());
       MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
       return;
     }
   }

clang/lib/Sema/SemaTemplateDeduction.cpp

DeduceTemplateArgumentsByTypeMatch(Sema &S,
   if (!(TDF & TDF_IgnoreQualifiers)) {
     if (TDF & TDF_ParamWithReferenceType) {
       if (hasInconsistentOrSupersetQualifiersOf(Param, Arg))
         return Sema::TDK_NonDeducedMismatch;
     } else if (TDF & TDF_ArgWithReferenceType) {
       // C++ [temp.deduct.conv]p4:
       //   If the original A is a reference type, A can be more cv-qualified
       //   than the deduced A
-      if (!Arg.getQualifiers().compatiblyIncludes(Param.getQualifiers()))
+      if (!S.Context.compatiblyIncludes(Arg.getQualifiers(),
+                                        Param.getQualifiers()))
         return Sema::TDK_NonDeducedMismatch;
 
       // Strip out all extra qualifiers from the argument to figure out the
       // type we're converting to, prior to the qualification conversion.
       Qualifiers Quals;
       Arg = S.Context.getUnqualifiedArrayType(Arg, Quals);
       Arg = S.Context.getQualifiedType(Arg, Param.getQualifiers());
     } else if (!IsPossiblyOpaquelyQualifiedType(Param)) {
if (S.getLangOpts().ObjCAutoRefCount &&
           AQuals.getObjCLifetime() == Qualifiers::OCL_None) ||
          (DeducedAQuals.hasConst() &&
           DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone))) {
       AQuals.setObjCLifetime(DeducedAQuals.getObjCLifetime());
     }
 
     if (AQuals == DeducedAQuals) {
       // Qualifiers match; there's nothing to do.
-    } else if (!DeducedAQuals.compatiblyIncludes(AQuals)) {
+    } else if (!S.Context.compatiblyIncludes(DeducedAQuals, AQuals)) {
       return Failed();
     } else {
       // Qualifiers are compatible, so have the argument type adopt the
       // deduced argument type's qualifiers as if we had performed the
       // qualification conversion.
       A = Context.getQualifiedType(A.getUnqualifiedType(), DeducedAQuals);
     }
   }

clang/test/CodeGenCXX/address-space-cast.cpp

void test_cast(char *gen_char_ptr, void *gen_void_ptr, int *gen_int_ptr) {
   // CHECK: %[[cast:.*]] = addrspacecast i8* %{{.*}} to i8 addrspace(5)*
   // CHECK-NEXT: store i8 addrspace(5)* %[[cast]]
   __private__ void *priv_void_ptr = (__private__ void *)gen_char_ptr;
 
   // CHECK: %[[cast:.*]] = addrspacecast i8* %{{.*}} to i8 addrspace(5)*
   // CHECK-NEXT: store i8 addrspace(5)* %[[cast]]
   priv_void_ptr = (__private__ void *)gen_void_ptr;
 
-  // CHECK: %[[cast:.*]] = addrspacecast i32* %{{.*}} to i8 addrspace(5)*
-  // CHECK-NEXT: store i8 addrspace(5)* %[[cast]]
+  // CHECK: %[[cast:.*]] = bitcast i32* %{{.*}} to i8*
+  // CHECK-NEXT: %[[cast2:.*]] = addrspacecast i8* %[[cast]] to i8 addrspace(5)*
+  // CHECK-NEXT: store i8 addrspace(5)* %[[cast2]]
   priv_void_ptr = (__private__ void *)gen_int_ptr;
 
   // CHECK: %[[cast:.*]] = addrspacecast i8* %{{.*}} to i32 addrspace(5)*
   // CHECK-NEXT: store i32 addrspace(5)* %[[cast]]
   __private__ int *priv_int_ptr = (__private__ int *)gen_void_ptr;
 
   // CHECK: %[[cast:.*]] = addrspacecast i8* %{{.*}} to i8 addrspace(5)*
   // CHECK-NEXT: call void @_Z10func_pcharPU3AS5c(i8 addrspace(5)* %[[cast]])
void test_cast(char *gen_char_ptr, void *gen_void_ptr, int *gen_int_ptr) {
   // CHECK: %[[cast:.*]] = addrspacecast i8* %{{.*}} to i8 addrspace(5)*
   // CHECK-NEXT: call void @_Z10func_pvoidPU3AS5v(i8 addrspace(5)* %[[cast]])
   func_pvoid((__private__ void *)gen_char_ptr);
 
   // CHECK: %[[cast:.*]] = addrspacecast i8* %{{.*}} to i8 addrspace(5)*
   // CHECK-NEXT: call void @_Z10func_pvoidPU3AS5v(i8 addrspace(5)* %[[cast]])
   func_pvoid((__private__ void *)gen_void_ptr);
 
-  // CHECK: %[[cast:.*]] = addrspacecast i32* %{{.*}} to i8 addrspace(5)*
-  // CHECK-NEXT: call void @_Z10func_pvoidPU3AS5v(i8 addrspace(5)* %[[cast]])
+  // CHECK: %[[cast:.*]] = bitcast i32* %{{.*}} to i8*
+  // CHECK-NEXT: %[[cast2:.*]] = addrspacecast i8* %[[cast]] to i8 addrspace(5)*
+  // CHECK-NEXT: call void @_Z10func_pvoidPU3AS5v(i8 addrspace(5)* %[[cast2]])
   func_pvoid((__private__ void *)gen_int_ptr);
 
   // CHECK: %[[cast:.*]] = addrspacecast i8* %{{.*}} to i32 addrspace(5)*
   // CHECK-NEXT: call void @_Z9func_pintPU3AS5i(i32 addrspace(5)* %[[cast]])
   func_pint((__private__ int *)gen_void_ptr);
 }

clang/test/Sema/address_space_print_macro.c

 // RUN: %clang_cc1 %s -fsyntax-only -verify
 
 #define AS1 __attribute__((address_space(1)))
 #define AS2 __attribute__((address_space(2), annotate("foo")))
 #define AS_ND __attribute__((address_space(2), noderef))
 
 #define AS(i) address_space(i)
 #define AS3 __attribute__((AS(3)))
 #define AS5 __attribute__((address_space(5))) char
 
 void normal_case() {
   int *p = 0;
   __attribute__((address_space(1))) int *q = p; // expected-error{{initializing '__attribute__((address_space(1))) int *' with an expression of type 'int *' changes address space of pointer}}
 }
 
 char *cmp(AS1 char *x, AS2 char *y) {
-  return x < y ? x : y; // expected-error{{conditional operator with the second and third operands of type  ('AS1 char *' and 'AS2 char *') which are pointers to non-overlapping address spaces}}
+  return x < y ? x : y; // expected-error{{conditional operator with the second and third operands of type  ('AS1 char *' and 'AS2 char *') which are pointers to non-overlapping address spaces}} \
+                        // expected-error{{comparison between  ('AS1 char *' and 'AS2 char *') which are pointers to non-overlapping address spaces}}
 }
 
 __attribute__((address_space(1))) char test_array[10];
 void test3(void) {
   extern void test3_helper(char *p); // expected-note{{passing argument to parameter 'p' here}}
   test3_helper(test_array);          // expected-error{{passing '__attribute__((address_space(1))) char *' to parameter of type 'char *' changes address space of pointer}}
 }
 

clang/test/Sema/address_spaces.c

void access_as_field()
     (void) bar.as_field;
 }
 
 typedef int PR4997 __attribute__((address_space(Foobar))); // expected-error {{use of undeclared identifier 'Foobar'}}
 __attribute__((address_space("12"))) int *i; // expected-error {{'address_space' attribute requires an integer constant}}
 
 // Clang extension doesn't forbid operations on pointers to different address spaces.
 char* cmp(_AS1 char *x,  _AS2 char *y) {
-  return x < y ? x : y; // expected-error{{conditional operator with the second and third operands of type  ('_AS1 char *' and '_AS2 char *') which are pointers to non-overlapping address spaces}}
+  return x < y ? x : y; // expected-error{{conditional operator with the second and third operands of type  ('_AS1 char *' and '_AS2 char *') which are pointers to non-overlapping address spaces}} \
+                        // expected-error{{comparison between  ('_AS1 char *' and '_AS2 char *') which are pointers to non-overlapping address spaces}}
 }
 
 char *sub(_AS1 char *x, _AS2 char *y) {
   return x - y; // expected-error {{arithmetic operation with operands of type  ('_AS1 char *' and '_AS2 char *') which are pointers to non-overlapping address spaces}}
 }
 
 struct SomeStruct {
   int a;