[OpenCL] Defines helper function for OpenCL default address space

[Topotuna]

Summary

Helper function getDefaultPointeeOpenCLAddrSpace() introduced to
ASTContext class. It returns default OpenCL address space
depending on language version and enabled features. If generic
address space is supported, the helper function returns value
LangAS::opencl_generic. Otherwise, value LangAS::opencl_private
is returned. Code refactoring changes performed in several suitable
places.

[Topotuna]

Current change is an initial draft. More code refactoring will be performed and change summary provided in near future.

[Topotuna]

Code refactored inside clang/lib/AST/Expr.cpp. Commit message added.

[Anastasia]

clang/include/clang/AST/ASTContext.h

1366

We should probably rename this to getDefaultPointeeOpenCLAddrSpace because this only reflects the default address space for the pointer types.

clang/lib/AST/Expr.cpp

3782–3783

Let's add Ctx.getLangOpts().OpenCL check at the start to make sure this only runs for OpenCL.

[Topotuna]

Helper function renamed for clarity. Additional check added to if statement to ensure it is only carried out in OpenCL.

[Topotuna]

Both comments addressed. Personally, I would shuffle words around to rename helper function as getDefaultOpenCLPointeeAddrSpace or getOpenCLDefaultPointeeAddrSpace. Although I am not sure if there are some assumed naming conventions in Clang. Originally, I was following the name of getDefaultCXXMethodAddrSpace.

[Anastasia]

In D109874#3011792, @Topotuna wrote:

Both comments addressed. Personally, I would shuffle words around to rename helper function as getDefaultOpenCLPointeeAddrSpace or getOpenCLDefaultPointeeAddrSpace. Although I am not sure if there are some assumed naming conventions in Clang. Originally, I was following the name of getDefaultCXXMethodAddrSpace.

I agree this naming scheme makes more sense.

[Anastasia]

LGTM! Thanks

Feel free to adjust the naming scheme either in the same commit or separately.

clang/include/clang/AST/ASTContext.h

public:
   QualType getBlockDescriptorExtendedType() const;
 
   /// Map an AST Type to an OpenCLTypeKind enum value.
   OpenCLTypeKind getOpenCLTypeKind(const Type *T) const;
 
   /// Get address space for OpenCL type.
   LangAS getOpenCLTypeAddrSpace(const Type *T) const;
 
+  /// Returns default address space based on OpenCL version and enabled features
+  inline LangAS getDefaultOpenCLPointeeAddrSpace() {
+    return LangOpts.OpenCLGenericAddressSpace ? LangAS::opencl_generic
+                                              : LangAS::opencl_private;
+  }
+
   void setcudaConfigureCallDecl(FunctionDecl *FD) {
     cudaConfigureCallDecl = FD;
   }
 
   FunctionDecl *getcudaConfigureCallDecl() {
     return cudaConfigureCallDecl;
   }
 

clang/lib/AST/Expr.cpp

if (!Ctx.getLangOpts().CPlusPlus) {
       // Check that it is a cast to void*.
       if (const PointerType *PT = CE->getType()->getAs<PointerType>()) {
         QualType Pointee = PT->getPointeeType();
         Qualifiers Qs = Pointee.getQualifiers();
         // Only (void*)0 or equivalent are treated as nullptr. If pointee type
         // has non-default address space it is not treated as nullptr.
         // (__generic void*)0 in OpenCL 2.0 should not be treated as nullptr
         // since it cannot be assigned to a pointer to constant address space.
-        if ((Ctx.getLangOpts().OpenCLVersion >= 200 &&
-             Pointee.getAddressSpace() == LangAS::opencl_generic) ||
-            (Ctx.getLangOpts().OpenCL &&
-             Ctx.getLangOpts().OpenCLVersion < 200 &&
-             Pointee.getAddressSpace() == LangAS::opencl_private))
+        if (Ctx.getLangOpts().OpenCL &&
+            Pointee.getAddressSpace() == Ctx.getDefaultOpenCLPointeeAddrSpace())
           Qs.removeAddressSpace();
 
         if (Pointee->isVoidType() && Qs.empty() && // to void*
             CE->getSubExpr()->getType()->isIntegerType()) // from int
           return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
       }
     }
   } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {

clang/lib/Sema/Sema.cpp

NamedDecl *Sema::getCurFunctionOrMethodDecl() {
   DeclContext *DC = getFunctionLevelDeclContext();
   if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
     return cast<NamedDecl>(DC);
   return nullptr;
 }
 
 LangAS Sema::getDefaultCXXMethodAddrSpace() const {
   if (getLangOpts().OpenCL)
-    return LangAS::opencl_generic;
+    return getASTContext().getDefaultOpenCLPointeeAddrSpace();
   return LangAS::Default;
 }
 
 void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
   // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
   // and yet we also use the current diag ID on the DiagnosticsEngine. This has
   // been made more painfully obvious by the refactor that introduced this
   // function, but it is possible that the incoming argument can be

clang/lib/Sema/SemaTemplateDeduction.cpp

if (ParamRefType) {
     if (ArgType->isIncompleteArrayType())
       ArgType = S.getCompletedType(Arg);
 
     // 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()) {
-      if (S.getLangOpts().OpenCL  && !ArgType.hasAddressSpace())
-        ArgType = S.Context.getAddrSpaceQualType(ArgType, LangAS::opencl_generic);
+      if (S.getLangOpts().OpenCL && !ArgType.hasAddressSpace())
+        ArgType = S.Context.getAddrSpaceQualType(
+            ArgType, S.Context.getDefaultOpenCLPointeeAddrSpace());
       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,

clang/lib/Sema/SemaType.cpp

 }
 
 // Helper to deduce addr space of a pointee type in OpenCL mode.
 static QualType deduceOpenCLPointeeAddrSpace(Sema &S, QualType PointeeType) {
   if (!PointeeType->isUndeducedAutoType() && !PointeeType->isDependentType() &&
       !PointeeType->isSamplerT() &&
       !PointeeType.hasAddressSpace())
     PointeeType = S.getASTContext().getAddrSpaceQualType(
-        PointeeType, S.getLangOpts().OpenCLGenericAddressSpace
-                         ? LangAS::opencl_generic
-                         : LangAS::opencl_private);
+        PointeeType, S.getASTContext().getDefaultOpenCLPointeeAddrSpace());
   return PointeeType;
 }
 
 /// Build a pointer type.
 ///
 /// \param T The type to which we'll be building a pointer.
 ///
 /// \param Loc The location of the entity whose type involves this