[C++4OpenCL] Initialize temporaries in the private address space

[olestrohm]

Summary

This patch fixes initializing temporaries, which are currently initialized without an address space, meaning that no constructor can ever be applicable.
This is also working towards putting temporaries in the private address space.

Fixes the second issue in PR43296.

[Anastasia]

clang/include/clang/Sema/Initialization.h

341

I wonder if we should instead change the check:

!Type.hasAddressSpace()

into an assert?

I also wonder if it makes sense to assert that if it has an address space it should be private?

[olestrohm]

I made the check into an assert as suggested.

[Anastasia]

LGTM! Thanks

clang/include/clang/Sema/Initialization.h

public:
   }
 
   /// Create the initialization entity for a temporary.
   static InitializedEntity InitializeTemporary(QualType Type) {
     return InitializeTemporary(nullptr, Type);
   }
 
   /// Create the initialization entity for a temporary.
-  static InitializedEntity InitializeTemporary(TypeSourceInfo *TypeInfo) {
-    return InitializeTemporary(TypeInfo, TypeInfo->getType());
+  static InitializedEntity InitializeTemporary(ASTContext &Context,
+                                               TypeSourceInfo *TypeInfo) {
+    QualType Type = TypeInfo->getType();
+    if (Context.getLangOpts().OpenCLCPlusPlus) {
+      assert(!Type.hasAddressSpace() && "Temporary already has address space!");
+      Type = Context.getAddrSpaceQualType(Type, LangAS::opencl_private);
+    }
+
+    return InitializeTemporary(TypeInfo, Type);
   }
 
   /// Create the initialization entity for a temporary.
   static InitializedEntity InitializeTemporary(TypeSourceInfo *TypeInfo,
                                                QualType Type) {
     InitializedEntity Result(EK_Temporary, SourceLocation(), Type);
     Result.TypeInfo = TypeInfo;
     return Result;

clang/lib/Sema/SemaExprCXX.cpp

Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo,
   QualType Ty = TInfo->getType();
   SourceLocation TyBeginLoc = TInfo->getTypeLoc().getBeginLoc();
 
   assert((!ListInitialization ||
           (Exprs.size() == 1 && isa<InitListExpr>(Exprs[0]))) &&
          "List initialization must have initializer list as expression.");
   SourceRange FullRange = SourceRange(TyBeginLoc, RParenOrBraceLoc);
 
-  InitializedEntity Entity = InitializedEntity::InitializeTemporary(TInfo);
+  InitializedEntity Entity =
+      InitializedEntity::InitializeTemporary(Context, TInfo);
   InitializationKind Kind =
       Exprs.size()
           ? ListInitialization
                 ? InitializationKind::CreateDirectList(
                       TyBeginLoc, LParenOrBraceLoc, RParenOrBraceLoc)
                 : InitializationKind::CreateDirect(TyBeginLoc, LParenOrBraceLoc,
                                                    RParenOrBraceLoc)
           : InitializationKind::CreateValue(TyBeginLoc, LParenOrBraceLoc,
case clang::TT_IsTriviallyConstructible: {
     }
 
     // Perform the initialization in an unevaluated context within a SFINAE
     // trap at translation unit scope.
     EnterExpressionEvaluationContext Unevaluated(
         S, Sema::ExpressionEvaluationContext::Unevaluated);
     Sema::SFINAETrap SFINAE(S, /*AccessCheckingSFINAE=*/true);
     Sema::ContextRAII TUContext(S, S.Context.getTranslationUnitDecl());
-    InitializedEntity To(InitializedEntity::InitializeTemporary(Args[0]));
+    InitializedEntity To(
+        InitializedEntity::InitializeTemporary(S.Context, Args[0]));
     InitializationKind InitKind(InitializationKind::CreateDirect(KWLoc, KWLoc,
                                                                  RParenLoc));
     InitializationSequence Init(S, To, InitKind, ArgExprs);
     if (Init.Failed())
       return false;
 
     ExprResult Result = Init.Perform(S, To, InitKind, ArgExprs);
     if (Result.isInvalid() || SFINAE.hasErrorOccurred())

clang/test/SemaOpenCLCXX/addrspace-constructors.clcpp

 };
 
 kernel void k() {
   __constant X cx1;
   __constant X cx2(1);
   __local X lx;
   __private X x;
 
+  __private X tx = X();
+
   __private Y py;
   __constant Y cy1; // expected-error{{variable in constant address space must be initialized}}
   __constant Y cy2(1); // expected-error{{no matching constructor for initialization of '__constant Y'}}
 }
 
 struct Z {
   int z;
   // The address space is deduced to be __generic if omitted

clang/test/SemaOpenCLCXX/temporaries.clcpp

+// RUN: %clang_cc1 %s -pedantic -ast-dump | FileCheck %s
+
+struct X {
+  X() __private = default;
+};
+
+// CHECK: VarDecl {{.*}} gx
+// CHECK: CXXTemporaryObjectExpr {{.*}} '__private X'
+__global X gx = X();
+
+void k() {
+  // CHECK: VarDecl {{.*}} x1
+  // CHECK: CXXTemporaryObjectExpr {{.*}} '__private X'
+  X x1 = X();
+
+  // CHECK: VarDecl {{.*}} x2
+  // CHECK: CXXConstructExpr {{.*}} 'const __private X'
+  const X x2;
+}