Fix diagnostic for addr spaces in reference binding

[Anastasia]

Summary

Extend reference binding behavior to account for address spaces. This change also fixes the diagnostic wording (for qualifier mismatch in reference binding) and simplifies it by using Qualifiers print method.

[rjmccall]

include/clang/Basic/DiagnosticSemaKinds.td

1831

We say that references are bound to objects, not that objects are bound to references.

lib/Sema/SemaInit.cpp

4628

I think the comment should go after the quote in the main comment above, i.e. something like "For address spaces, we interpret this to mean..."

Also, this clause is part of the parenthesized group and should be indented consistently.

[ebevhan]

So static_cast permits conversions from AS1 to AS2 where that conversion is implicitly allowed, and the new addrspace_cast would permit conversions from AS1 to AS2 where it is explicitly allowed. That seems like it fits in rather well with the idea in D57464 regarding support for specifying permitted AS conversions in target.

How about nested pointers, such as __X int * * -> __Y int * * or __X int * __Y * -> int * __Y *? static_cast has some ruleset for how to deal with qualifiers in nested pointers, I think, but I'm not sure how the rules for ASes should be here.

There's also C-style casts. Will addrspace_cast be added to the C-style cast rules somewhere?

(I should probably have commented on the original RFC)

[Anastasia]

In D58060#1396416, @ebevhan wrote:

So static_cast permits conversions from AS1 to AS2 where that conversion is implicitly allowed, and the new addrspace_cast would permit conversions from AS1 to AS2 where it is explicitly allowed. That seems like it fits in rather well with the idea in D57464 regarding support for specifying permitted AS conversions in target.

How about nested pointers, such as __X int * * -> __Y int * * or __X int * __Y * -> int * __Y *? static_cast has some ruleset for how to deal with qualifiers in nested pointers, I think, but I'm not sure how the rules for ASes should be here.

We had discussion related to this with John earlier. And I documented it in this bug: https://bugs.llvm.org/show_bug.cgi?id=39674

There's also C-style casts. Will addrspace_cast be added to the C-style cast rules somewhere?

(I should probably have commented on the original RFC)

Yes, exactly. I am working on a patch now that separates the address space casting out into a function to be used in C-style cast only as a first step (because I would like to disallow accidental unsafe address space conversions in reinterpret_cast). Then we would just need to add parsing of a new cast operator and mapping into the new function.

[Anastasia]

• Changed the diagnostic for binding reference and combined with existing similar one. That affected more tests however.
• Changed comment explaining address space behavior in the reference initialization.
• Reformatted.

[ebevhan]

In D58060#1396565, @Anastasia wrote:

We had discussion related to this with John earlier. And I documented it in this bug: https://bugs.llvm.org/show_bug.cgi?id=39674

I think we observed something similar to this downstream in C, and I might have a patch(es) that fixes it.

Yes, exactly. I am working on a patch now that separates the address space casting out into a function to be used in C-style cast only as a first step (because I would like to disallow accidental unsafe address space conversions in reinterpret_cast). Then we would just need to add parsing of a new cast operator and mapping into the new function.

Okay, sounds good!

[Anastasia]

Btw, I have changed the diagnostic wording... does this change make sense now?

[Anastasia]

• Fixed incorrect diagnostic in address space mismatch case when binding reference to a temporary value of a constant with incompatible type. Added missing test case.

[ebevhan]

test/SemaOpenCLCXX/address-space-references.cl

8

Is there a reason the declaration is commented out? If it's just a problem with the resolution, wouldn't it still be possible to have the declaration here anyway?

[Anastasia]

Un-commented the line in the test

[Anastasia]

test/SemaOpenCLCXX/address-space-references.cl

8

Hmm... actually not at all! I commented it to show that this could work better... but FIXME is good enough to indicate this!

[Anastasia]

@rjmccall or @ebevhan do you have any more feedback for this patch?

Btw, it has now dependency with https://reviews.llvm.org/D61318

[Anastasia]

Due to my recent commits I had to changed this slightly so it is now under a new review: https://reviews.llvm.org/D62914

include/clang/Basic/DiagnosticSemaKinds.td

 def err_lvalue_reference_bind_to_temporary : Error<
   "%select{non-const|volatile}0 lvalue reference %diff{to type $ cannot bind "
   "to a temporary of type $|cannot bind to incompatible temporary}1,2">;
 def err_lvalue_reference_bind_to_unrelated : Error<
   "%select{non-const|volatile}0 lvalue reference "
   "%diff{to type $ cannot bind to a value of unrelated type $|"
   "cannot bind to a value of unrelated type}1,2">;
 def err_reference_bind_drops_quals : Error<
-  "binding value %diff{of type $ to reference to type $|to reference}0,1 "
-  "drops %select{<<ERROR>>|'const'|'restrict'|'const' and 'restrict'|"
-  "'volatile'|'const' and 'volatile'|'restrict' and 'volatile'|"
-  "'const', 'restrict', and 'volatile'}2 qualifier%plural{1:|2:|4:|:s}2">;
+  "binding reference %diff{of type $ to value of type $|to value}0,1 "
+  "%select{drops %3 qualifier%plural{1:|2:|4:|:s}4|changes address space}2">;
 def err_reference_bind_failed : Error<
   "reference %diff{to %select{type|incomplete type}1 $ could not bind to an "
   "%select{rvalue|lvalue}2 of type $|could not bind to %select{rvalue|lvalue}2 of "
   "incompatible type}0,3">;
 def err_reference_bind_init_list : Error<
   "reference to type %0 cannot bind to an initializer list">;
 def err_init_list_bad_dest_type : Error<
   "%select{|non-aggregate }0type %1 cannot be initialized with an initializer "
   "list">;
 def warn_cxx2a_compat_aggregate_init_with_ctors : Warning<

lib/Sema/SemaInit.cpp

if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() &&
             InitializationSequence::FK_ReferenceInitOverloadFailed,
             ConvOvlResult);
     }
   }
 
   //     - 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.
-  if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) {
+  //       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))) {
     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(
-          InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
+          T1Quals.isAddressSpaceSupersetOf(T2Quals)
+              ? InitializationSequence::
+                    FK_NonConstLValueReferenceBindingToTemporary
+              : InitializationSequence::FK_ReferenceInitDropsQualifiers);
     else {
       InitializationSequence::FailureKind FK;
       switch (RefRelationship) {
       case Sema::Ref_Compatible:
         if (Initializer->refersToBitField())
           FK = InitializationSequence::
               FK_NonConstLValueReferenceBindingToBitfield;
         else if (Initializer->refersToVectorElement())
case FK_RValueReferenceBindingToLValue:
     break;
 
   case FK_ReferenceInitDropsQualifiers: {
     QualType SourceType = OnlyArg->getType();
     QualType NonRefType = DestType.getNonReferenceType();
     Qualifiers DroppedQualifiers =
         SourceType.getQualifiers() - NonRefType.getQualifiers();
 
+    if (!NonRefType.getQualifiers().isAddressSpaceSupersetOf(
+            SourceType.getQualifiers()))
       S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
-      << SourceType
-      << NonRefType
-      << DroppedQualifiers.getCVRQualifiers()
+          << NonRefType << SourceType << 1 /*addr space*/
           << Args[0]->getSourceRange();
+    else
+      S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
+          << NonRefType << SourceType << 0 /*cv quals*/
+          << Qualifiers::fromCVRMask(DroppedQualifiers.getCVRQualifiers())
+          << DroppedQualifiers.getCVRQualifiers() << Args[0]->getSourceRange();
     break;
   }
 
   case FK_ReferenceInitFailed:
     S.Diag(Kind.getLocation(), diag::err_reference_bind_failed)
       << DestType.getNonReferenceType()
       << DestType.getNonReferenceType()->isIncompleteType()
       << OnlyArg->isLValue()

test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-0x.cpp

namespace std_example_2 {
   } x;
   const A& r = x;
   int&& rri = static_cast<int&&>(i);
   B&& rrb = x;
   int&& rri2 = X(); // expected-error{{no viable conversion from 'std_example_2::X' to 'int'}}
 
   const double& rcd2 = 2;
   double&& rrd = 2;
-  const volatile int cvi = 1; 
-  const int& r2 = cvi; // expected-error{{binding value of type 'const volatile int' to reference to type 'const int' drops 'volatile' qualifier}}
+  const volatile int cvi = 1;
+  const int& r2 = cvi; // expected-error{{binding reference of type 'const int' to value of type 'const volatile int' drops 'volatile' qualifier}}
 
   double d;
   double&& rrd2 = d; // expected-error{{rvalue reference to type 'double' cannot bind to lvalue of type 'double'}}
   double&& rrd3 = i;
 }
 
 namespace argument_passing {
   void base_rvalue_ref(Base&&);

test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-var.cpp

void bind_lvalue_to_lvalue(Base b, Derived d,
   long &lr = i; // expected-error{{non-const lvalue reference to type 'long' cannot bind to a value of unrelated type 'int'}}
 }
 
 void bind_lvalue_quals(volatile Base b, volatile Derived d,
                        volatile const Base bvc, volatile const Derived dvc,
                        volatile const int ivc) {
   volatile Base &bvr1 = b;
   volatile Base &bvr2 = d;
-  volatile Base &bvr3 = bvc; // expected-error{{binding value of type 'const volatile Base' to reference to type 'volatile Base' drops 'const' qualifier}}
-  volatile Base &bvr4 = dvc; // expected-error{{binding value of type 'const volatile Derived' to reference to type 'volatile Base' drops 'const' qualifier}}
-  
-  volatile int &ir = ivc; // expected-error{{binding value of type 'const volatile int' to reference to type 'volatile int' drops 'const' qualifier}}
+  volatile Base &bvr3 = bvc; // expected-error{{binding reference of type 'volatile Base' to value of type 'const volatile Base' drops 'const' qualifier}}
+  volatile Base &bvr4 = dvc; // expected-error{{binding reference of type 'volatile Base' to value of type 'const volatile Derived' drops 'const' qualifier}}
+  volatile int &ir = ivc; // expected-error{{binding reference of type 'volatile int' to value of type 'const volatile int' drops 'const' qualifier}}
 
   const volatile Base &bcvr1 = b;
   const volatile Base &bcvr2 = d;
 }
 
 void bind_lvalue_to_rvalue() {
   Base &br1 = Base(); // expected-error{{non-const lvalue reference to type 'Base' cannot bind to a temporary of type 'Base'}}
   Base &br2 = Derived(); // expected-error{{non-const lvalue reference to type 'Base' cannot bind to a temporary of type 'Derived'}}

 void bind_const_lvalue_to_rvalue() {
   const Base &br1 = create<Base>();
   const Base &br2 = create<Derived>();
   const Derived &dr1 = create<Base>(); // expected-error{{no viable conversion}}
 
   const Base &br3 = create<const Base>();
   const Base &br4 = create<const Derived>();
 
-  const Base &br5 = create<const volatile Base>(); // expected-error{{binding value of type 'const volatile Base' to reference to type 'const Base' drops 'volatile' qualifier}}
-  const Base &br6 = create<const volatile Derived>(); // expected-error{{binding value of type 'const volatile Derived' to reference to type 'const Base' drops 'volatile' qualifier}}
+  const Base &br5 = create<const volatile Base>();    // expected-error{{binding reference of type 'const Base' to value of type 'const volatile Base' drops 'volatile' qualifier}}
+  const Base &br6 = create<const volatile Derived>(); // expected-error{{binding reference of type 'const Base' to value of type 'const volatile Derived' drops 'volatile' qualifier}}
 
   const int &ir = create<int>();
 }
 
 // Second bullet: const lvalue reference binds to the result of a conversion.
 void bind_const_lvalue_to_class_conv_temporary() {
   const Base &br1 = ConvertibleToBase();
   const Base &br2 = ConvertibleToDerived();
 }
 void bind_lvalue_to_conv_rvalue_ambig(ConvertibleToBothDerived both) {
   const Derived &dr1 = both;
   const Base &br1 = both; // expected-error{{reference initialization of type 'const Base &' with initializer of type 'ConvertibleToBothDerived' is ambiguous}}
 }

test/CXX/expr/expr.post/expr.static.cast/p3-p4-0x.cpp

void test(A &a, B &b) {
   A &&ar1 = static_cast<A&&>(prvalue<B>());
   A &&ar2 = static_cast<A&&>(lvalue<C>());
   A &&ar3 = static_cast<A&&>(xvalue<C>());
   A &&ar4 = static_cast<A&&>(prvalue<C>());
   A &&ar5 = static_cast<A&&>(lvalue<D>());
   A &&ar6 = static_cast<A&&>(xvalue<D>());
   A &&ar7 = static_cast<A&&>(prvalue<D>());
 
-  A &&ar8 = static_cast<A&&>(prvalue<const A>()); // expected-error {{binding value of type 'const A' to reference to type 'A' drops 'const' qualifier}}
-  A &&ar9 = static_cast<A&&>(lvalue<const A>()); // expected-error {{cannot cast from lvalue of type 'const A'}}
+  A &&ar8 = static_cast<A&&>(prvalue<const A>()); // expected-error {{binding reference of type 'A' to value of type 'const A' drops 'const' qualifier}}
+  A &&ar9 = static_cast<A&&>(lvalue<const A>());  // expected-error {{cannot cast from lvalue of type 'const A'}}
   A &&ar10 = static_cast<A&&>(xvalue<const A>()); // expected-error {{cannot cast from rvalue of type 'const A'}}
 
   const A &&ar11 = static_cast<const A&&>(prvalue<A>());
   const A &&ar12 = static_cast<const A&&>(prvalue<B>());
   const A &&ar13 = static_cast<const A&&>(lvalue<C>());
   const A &&ar14 = static_cast<const A&&>(xvalue<C>());
   const A &&ar15 = static_cast<const A&&>(prvalue<C>());
   const A &&ar16 = static_cast<const A&&>(lvalue<D>());
 
-  const A &&ar17 = static_cast<const A&&>(prvalue<A const volatile>()); // expected-error {{binding value of type 'const volatile A' to reference to type 'const A' drops 'volatile' qualifier}}
+  const A &&ar17 = static_cast<const A&&>(prvalue<A const volatile>()); // expected-error {{binding reference of type 'const A' to value of type 'const volatile A' drops 'volatile' qualifier}}
 }

test/CXX/expr/expr.prim/expr.prim.lambda/p16.cpp

void test_capture(X x) {
 
   [x] {
     [&x] {
       [x] { // expected-error{{call to deleted constructor of 'const X'}}
       }();
     }();
   }();
 
-  int a; 
-  [=]{ 
-    [&] { 
-      int &x = a;  // expected-error{{binding value of type 'const int' to reference to type 'int' drops 'const' qualifier}}
-      int &x2 = a;  // expected-error{{binding value of type 'const int' to reference to type 'int' drops 'const' qualifier}}
-    }(); 
-  }(); 
+  int a;
+  [=] {
+    [&] {
+      int &x = a;  // expected-error{{binding reference of type 'int' to value of type 'const int' drops 'const' qualifier}}
+      int &x2 = a; // expected-error{{binding reference of type 'int' to value of type 'const int' drops 'const' qualifier}}
+    }();
+  }();
 
-  [=]{ 
-    [&a] { 
-      [&] { 
-        int &x = a;  // expected-error{{binding value of type 'const int' to reference to type 'int' drops 'const' qualifier}}
-        int &x2 = a;  // expected-error{{binding value of type 'const int' to reference to type 'int' drops 'const' qualifier}}
+  [=] {
+    [&a] {
+      [&] {
+        int &x = a;  // expected-error{{binding reference of type 'int' to value of type 'const int' drops 'const' qualifier}}
+        int &x2 = a; // expected-error{{binding reference of type 'int' to value of type 'const int' drops 'const' qualifier}}
       }();
-    }(); 
-  }(); 
+    }();
+  }();
 }

test/Misc/diag-template-diffing.cpp

 struct is_const {
     constexpr operator int() const { return 10; }
 };
 
 using T = condition<(is_const())>;
 void foo(const T &t) {
   T &t2 = t;
 }
-// CHECK-ELIDE-NOTREE: binding value of type 'const condition<...>' to reference to type 'condition<...>' drops 'const' qualifier
+// CHECK-ELIDE-NOTREE: binding reference of type 'condition<...>' to value of type 'const condition<...>' drops 'const' qualifier
 }
 
 namespace BoolArgumentBitExtended {
 template <bool B> struct BoolT {};
 
 template <typename T> void foo(T) {}
 
 void test() {

test/SemaCXX/builtins-arm.cpp

 // RUN: %clang_cc1 -triple armv7 -fsyntax-only -verify %s
 
 // va_list on ARM AAPCS is struct { void* __ap }.
 int test1(const __builtin_va_list &ap) {
-  return __builtin_va_arg(ap, int); // expected-error {{binding value of type 'const __builtin_va_list' to reference to type '__builtin_va_list' drops 'const' qualifier}}
+  return __builtin_va_arg(ap, int); // expected-error {{binding reference of type '__builtin_va_list' to value of type 'const __builtin_va_list' drops 'const' qualifier}}
 }

test/SemaCXX/err_reference_bind_drops_quals.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 #define restrict __restrict__
 typedef int* ptr;
 void test1(ptr p, const ptr cp, restrict ptr rp, const restrict ptr crp,
            volatile ptr vp, const volatile ptr cvp, restrict volatile ptr rvp,
            const restrict volatile ptr crvp) {
   ptr& p1 = p;
-  ptr& p2 = cp; // expected-error {{drops 'const' qualifier}}
-  ptr& p3 = rp; // expected-error {{drops 'restrict' qualifier}}
-  ptr& p4 = crp; // expected-error {{drops 'const' and 'restrict' qualifiers}}
-  ptr& p5 = vp; // expected-error {{drops 'volatile' qualifier}}
-  ptr& p6 = cvp; // expected-error {{drops 'const' and 'volatile' qualifiers}}
-  ptr& p7 = rvp; // expected-error {{drops 'restrict' and 'volatile' qualifiers}}
-  ptr& p8 = crvp; // expected-error {{drops 'const', 'restrict', and 'volatile' qualifiers}}
+  ptr& p2 = cp;   // expected-error {{drops 'const' qualifier}}
+  ptr& p3 = rp;   // expected-error {{drops '__restrict' qualifier}}
+  ptr& p4 = crp;  // expected-error {{drops 'const __restrict' qualifiers}}
+  ptr& p5 = vp;   // expected-error {{drops 'volatile' qualifier}}
+  ptr& p6 = cvp;  // expected-error {{drops 'const volatile' qualifiers}}
+  ptr& p7 = rvp;  // expected-error {{drops 'volatile __restrict' qualifiers}}
+  ptr& p8 = crvp; // expected-error {{drops 'const volatile __restrict' qualifiers}}
 
   const ptr& cp1 = p;
   const ptr& cp2 = cp;
-  const ptr& cp3 = rp; // expected-error {{drops 'restrict' qualifier}}
-  const ptr& cp4 = crp; // expected-error {{drops 'restrict' qualifier}}
-  const ptr& cp5 = vp; // expected-error {{drops 'volatile' qualifier}}
-  const ptr& cp6 = cvp; // expected-error {{drops 'volatile' qualifier}}
-  const ptr& cp7 = rvp; // expected-error {{drops 'restrict' and 'volatile' qualifiers}}
-  const ptr& cp8 = crvp; // expected-error {{drops 'restrict' and 'volatile' qualifiers}}
+  const ptr& cp3 = rp;   // expected-error {{drops '__restrict' qualifier}}
+  const ptr& cp4 = crp;  // expected-error {{drops '__restrict' qualifier}}
+  const ptr& cp5 = vp;   // expected-error {{drops 'volatile' qualifier}}
+  const ptr& cp6 = cvp;  // expected-error {{drops 'volatile' qualifier}}
+  const ptr& cp7 = rvp;  // expected-error {{drops 'volatile __restrict' qualifiers}}
+  const ptr& cp8 = crvp; // expected-error {{drops 'volatile __restrict' qualifiers}}
 
   const volatile ptr& cvp1 = p;
   const volatile ptr& cvp2 = cp;
-  const volatile ptr& cvp3 = rp; // expected-error {{drops 'restrict' qualifier}}
-  const volatile ptr& cvp4 = crp; // expected-error {{drops 'restrict' qualifier}}
+  const volatile ptr& cvp3 = rp;  // expected-error {{drops '__restrict' qualifier}}
+  const volatile ptr& cvp4 = crp; // expected-error {{drops '__restrict' qualifier}}
   const volatile ptr& cvp5 = vp;
   const volatile ptr& cvp6 = cvp;
-  const volatile ptr& cvp7 = rvp; // expected-error {{drops 'restrict' qualifier}}
-  const volatile ptr& cvp8 = crvp; // expected-error {{drops 'restrict' qualifier}}
+  const volatile ptr& cvp7 = rvp;  // expected-error {{drops '__restrict' qualifier}}
+  const volatile ptr& cvp8 = crvp; // expected-error {{drops '__restrict' qualifier}}
 
   const restrict volatile ptr& crvp1 = p;
   const restrict volatile ptr& crvp2 = cp;
   const restrict volatile ptr& crvp3 = rp;
   const restrict volatile ptr& crvp4 = crp;
   const restrict volatile ptr& crvp5 = vp;
   const restrict volatile ptr& crvp6 = cvp;
   const restrict volatile ptr& crvp7 = rvp;
   const restrict volatile ptr& crvp8 = crvp;
 }

test/SemaCXX/references.cpp

void test4() {
   double& rd3 = i; // expected-error{{non-const lvalue reference to type 'double' cannot bind to a value of unrelated type 'int'}}
 
   const A& rca = fB();
 }
 
 void test5() {
   //  const double& rcd2 = 2; // rcd2 refers to temporary with value 2.0
   const volatile int cvi = 1;
-  const int& r = cvi; // expected-error{{binding value of type 'const volatile int' to reference to type 'const int' drops 'volatile' qualifier}}
+  const int& r = cvi; // expected-error{{binding reference of type 'const int' to value of type 'const volatile int' drops 'volatile' qualifier}}
 
 #if __cplusplus >= 201103L
-  const int& r2{cvi}; // expected-error{{binding value of type 'const volatile int' to reference to type 'const int' drops 'volatile' qualifier}}
+  const int& r2{cvi}; // expected-error{{binding reference of type 'const int' to value of type 'const volatile int' drops 'volatile' qualifier}}
 
   const int a = 2;
-  int& r3{a}; // expected-error{{binding value of type 'const int' to reference to type 'int' drops 'const'}}
+  int& r3{a}; // expected-error{{binding reference of type 'int' to value of type 'const int' drops 'const' qualifier}}
 
   const int&& r4{a}; // expected-error{{rvalue reference to type 'const int' cannot bind to lvalue of type 'const int'}}
 
   void func();
   void func(int);
   int &ptr1 = {func}; // expected-error{{address of overloaded function 'func' does not match required type 'int'}}
   int &&ptr2{func}; // expected-error{{address of overloaded function 'func' does not match required type 'int'}}
   // expected-note@-4{{candidate function}}

test/SemaOpenCLCXX/address-space-castoperators.cpp

+//RUN: %clang_cc1 %s -triple spir-unknown-unknown -cl-std=c++ -pedantic -verify
+
+void test_ref(int &gen, __global const int &glob) {
+  static_cast<__global int &>(gen);         // expected-error{{binding reference of type '__global int' to value of type '__generic int' changes address space}}
+  static_cast<__global const int &>(gen);   //expected-error{{binding reference of type 'const __global int' to value of type '__generic int' changes address space}}
+  static_cast<__global int &>(glob);        //expected-error{{binding reference of type '__global int' to value of type 'const __global int' drops 'const' qualifier}}
+  static_cast<__local int &>(glob);         //expected-error{{binding reference of type '__local int' to value of type 'const __global int' changes address space}}
+  static_cast<__generic const int &>(glob); //expected-warning{{expression result unused}}
+}
+
+void test_ptr(int *gen, __global const int *glob) {
+  static_cast<__global int *>(gen);         // expected-error{{static_cast from '__generic int *' to '__global int *' is not allowed}}
+  static_cast<__global const int *>(gen);   //expected-error{{static_cast from '__generic int *' to 'const __global int *' is not allowed}}
+  static_cast<__global int *>(glob);        //expected-error{{static_cast from 'const __global int *' to '__global int *' is not allowed}}
+  static_cast<__local int *>(glob);         //expected-error{{static_cast from 'const __global int *' to '__local int *' is not allowed}}
+  static_cast<__generic const int *>(glob); //expected-warning{{expression result unused}}
+}

test/SemaOpenCLCXX/address-space-references.cl

+// RUN: %clang_cc1 %s -triple spir-unknown-unknown -cl-std=c++ -pedantic -verify -fsyntax-only
+
+int bar(const __global unsigned int &i); // expected-note{{passing argument to parameter 'i' here}}
+//FIXME: With the overload below the call should be resolved
+// successfully. However, current overload resolution logic
+// can't detect this case and therefore fails.
+int bar(const unsigned int &i);
+
+void foo() {
+  bar(1) // expected-error{{binding reference of type 'const __global unsigned int' to value of type 'int' changes address space}}
+}