[OpenCL] Fixed missing address space for templated copy constructor

[olestrohm]

Summary

When you have a templated constructor with an R-value reference the compiler implicitly creates a copy and move constructor through the template constructor, and the copy constructor created this way was missing an address space in the reference parameter. I've come up with this fix that deduces the address space for the reference parameter right before it's created, and a corresponding test.

The test is quite big, but rep_outer is necessary to force the compiler to create the copy constructor, and the two template structs are partly for readability.

[Anastasia]

clang/lib/Sema/SemaTemplateDeduction.cpp

3820

I feel we can just add an address space explicitly since we are creating the type here for a known use case. However, does Arg actually have an address space? I am just unsure whether we should use generic address space or concrete address space.

[olestrohm]

clang/lib/Sema/SemaTemplateDeduction.cpp

3820

No, there are no known address spaces at this point for the test case I've got. But as far as I understand the function isn't only used for the case we look at here, but there may be case where the argument has an address space.

[Anastasia]

clang/lib/Sema/SemaTemplateDeduction.cpp

3820

Ok since there are no known cases for named address spaces now, we could just use generic. We can always extend this later if we find that any other address space is needed.

[olestrohm]

The code now directly adds the __generic address space to the pointee type.

[Anastasia]

LGTM! Thanks

clang/lib/Sema/SemaTemplateDeduction.cpp

if (ArgType->isIncompleteArrayType()) {
       S.completeExprArrayBound(Arg);
       ArgType = Arg->getType();
     }
 
     // C++1z [temp.deduct.call]p3:
     //   If P is a forwarding reference and the argument is an lvalue, the type
     //   "lvalue reference to A" is used in place of A for type deduction.
     if (isForwardingReference(QualType(ParamRefType, 0), FirstInnerIndex) &&
-        Arg->isLValue())
+        Arg->isLValue()) {
+      if (S.getLangOpts().OpenCL)
+        ArgType = S.Context.getAddrSpaceQualType(ArgType, LangAS::opencl_generic);
       ArgType = S.Context.getLValueReferenceType(ArgType);
+    }
   } else {
     // C++ [temp.deduct.call]p2:
     //   If P is not a reference type:
     //   - If A is an array type, the pointer type produced by the
     //     array-to-pointer standard conversion (4.2) is used in place of
     //     A for type deduction; otherwise,
     if (ArgType->isArrayType())
       ArgType = S.Context.getArrayDecayedType(ArgType);

clang/test/SemaOpenCLCXX/address-space-templates.cl

T *foo2(T *i) {
   return i;
 }
 
 template <typename T>
 void foo3() {
   __private T ii; // expected-error{{conflicting address space qualifiers are provided between types '__private T' and '__global int'}}
 }
 
+template <class _Tp> struct remove_reference         { typedef _Tp type; };
+template <class _Tp> struct remove_reference<_Tp &>  { typedef _Tp type; };
+template <class _Tp> struct as_pointer {
+    typedef typename remove_reference<_Tp>::type* type;
+};
+
+struct rep {
+  // CHECK |-CXXConstructorDecl {{.*}} rep 'void (const __generic rep &__private) __generic'
+  template<class U, class = typename as_pointer<U>::type>
+  rep(U&& v) {}
+};
+
+struct rep_outer : private rep {
+  rep_outer()
+    : rep(0) {}
+};
+
 void bar() {
   S<const __global int> sintgl; // expected-note{{in instantiation of template class 'S<const __global int>' requested here}}
 
   foo1<__local int>(1); // expected-error{{no matching function for call to 'foo1'}}
   foo2<__global int>(0);
   foo3<__global int>(); // expected-note{{in instantiation of function template specialization 'foo3<__global int>' requested here}}
+  rep_outer r;
 }