Array elements are now passed as individual parameters.

Author: rdeodhar

clang/lib/Sema/SemaSYCL.cpp

@@ -688,22 +688,6 @@ static ParamDesc makeParamDesc(ASTContext &Ctx, const CXXBaseSpecifier &Src,
                          Ctx.getTrivialTypeSourceInfo(Ty));
 }
 
-// Create a new class around a field - used to wrap arrays.
-static RecordDecl *wrapAnArray(ASTContext &Ctx, const QualType ArgTy,
-                               FieldDecl *&Field) {
-  RecordDecl *NewClass = Ctx.buildImplicitRecord("wrapped_array");
-  NewClass->startDefinition();
-  Field = FieldDecl::Create(
-      Ctx, NewClass, SourceLocation(), SourceLocation(),
-      /*Id=*/nullptr, ArgTy,
-      Ctx.getTrivialTypeSourceInfo(ArgTy, SourceLocation()),
-      /*BW=*/nullptr, /*Mutable=*/false, /*InitStyle=*/ICIS_NoInit);
-  Field->setAccess(AS_public);
-  NewClass->addDecl(Field);
-  NewClass->completeDefinition();
-  return NewClass;
-}
-
 /// \return the target of given SYCL accessor type
 static target getAccessTarget(const ClassTemplateSpecializationDecl *AccTy) {
   return static_cast<target>(
@@ -799,15 +783,21 @@ static void VisitField(CXXRecordDecl *Owner, RangeTy &&Item, QualType ItemTy,
                        Handlers &... handlers) {
   if (Util::isSyclAccessorType(ItemTy))
     KF_FOR_EACH(handleSyclAccessorType, Item, ItemTy);
-  if (Util::isSyclStreamType(ItemTy))
+  else if (Util::isSyclStreamType(ItemTy))
     KF_FOR_EACH(handleSyclStreamType, Item, ItemTy);
-  if (ItemTy->isStructureOrClassType())
+  else if (ItemTy->isStructureOrClassType())
     VisitAccessorWrapper(Owner, Item, ItemTy->getAsCXXRecordDecl(),
                          handlers...);
-  if (ItemTy->isArrayType())
+  else if (ItemTy->isArrayType())
     VisitArrayElements(Item, ItemTy, handlers...);
 }
 
+template <typename RangeTy, typename... Handlers>
+static void VisitScalarField(CXXRecordDecl *Owner, RangeTy &&Item, QualType ItemTy,
+  Handlers &... handlers) {
+  KF_FOR_EACH(handleScalarType, Item, ItemTy);
+}
+
 template <typename RangeTy, typename... Handlers>
 static void VisitArrayElements(RangeTy Item, QualType FieldTy,
                                Handlers &... handlers) {
@@ -816,7 +806,10 @@ static void VisitArrayElements(RangeTy Item, QualType FieldTy,
   int64_t ElemCount = CAT->getSize().getSExtValue();
   std::initializer_list<int>{(handlers.enterArray(), 0)...};
   for (int64_t Count = 0; Count < ElemCount; Count++) {
-    VisitField(nullptr, Item, ET, handlers...);
+    if (ET->isScalarType())
+      VisitScalarField(nullptr, Item, ET, handlers...);
+    else
+      VisitField(nullptr, Item, ET, handlers...);
     (void)std::initializer_list<int>{(handlers.nextElement(ET), 0)...};
   }
   (void)std::initializer_list<int>{(handlers.leaveArray(ET, ElemCount), 0)...};
@@ -919,6 +912,9 @@ template <typename Derived> class SyclKernelFieldHandler {
   virtual bool handleReferenceType(FieldDecl *, QualType) { return true; }
   virtual bool handlePointerType(FieldDecl *, QualType) { return true; }
   virtual bool handleArrayType(FieldDecl *, QualType) { return true; }
+  virtual bool handleScalarType(const CXXBaseSpecifier &, QualType) {
+    return true;
+  }
   virtual bool handleScalarType(FieldDecl *, QualType) { return true; }
   // Most handlers shouldn't be handling this, just the field checker.
   virtual bool handleOtherType(FieldDecl *, QualType) { return true; }
@@ -1003,7 +999,8 @@ class SyclKernelFieldChecker
 
 public:
   SyclKernelFieldChecker(Sema &S)
-      : SyclKernelFieldHandler(S), Diag(S.getASTContext().getDiagnostics()) {}
+      : SyclKernelFieldHandler(S), Diag(S.getASTContext().getDiagnostics()) {
+  }
   bool isValid() { return !IsInvalid; }
 
   bool handleReferenceType(FieldDecl *FD, QualType FieldTy) final {
@@ -1052,6 +1049,10 @@ class SyclKernelDeclCreator
   size_t LastParamIndex = 0;
 
   void addParam(const FieldDecl *FD, QualType FieldTy) {
+    const ConstantArrayType *CAT =
+      SemaRef.getASTContext().getAsConstantArrayType(FieldTy);
+    if (CAT)
+      FieldTy = CAT->getElementType();
     ParamDesc newParamDesc = makeParamDesc(FD, FieldTy);
     addParam(newParamDesc, FieldTy);
   }
@@ -1068,7 +1069,6 @@ class SyclKernelDeclCreator
         SemaRef.getASTContext(), KernelDecl, SourceLocation(), SourceLocation(),
         std::get<1>(newParamDesc), std::get<0>(newParamDesc),
         std::get<2>(newParamDesc), SC_None, /*DefArg*/ nullptr);
-
     NewParam->setScopeInfo(0, Params.size());
     NewParam->setIsUsed();
 
@@ -1131,7 +1131,8 @@ class SyclKernelDeclCreator
       : SyclKernelFieldHandler(S),
         KernelDecl(createKernelDecl(S.getASTContext(), Name, Loc, IsInline,
                                     IsSIMDKernel)),
-        ArgChecker(ArgChecker), FuncContext(SemaRef, KernelDecl) {}
+        ArgChecker(ArgChecker), FuncContext(SemaRef, KernelDecl) {
+  }
 
   ~SyclKernelDeclCreator() {
     ASTContext &Ctx = SemaRef.getASTContext();
@@ -1189,18 +1190,12 @@ class SyclKernelDeclCreator
     return true;
   }
 
-  bool handleArrayType(FieldDecl *FD, QualType FieldTy) final {
-    RecordDecl *NewClass = wrapAnArray(SemaRef.getASTContext(), FieldTy, FD);
-    QualType ST = SemaRef.getASTContext().getRecordType(NewClass);
-    addParam(FD, ST);
-    return true;
-  }
-
   bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
     addParam(FD, FieldTy);
     return true;
   }
 
+  //FIXME Remove this function when structs are replaced by their fields
   bool handleStructType(FieldDecl *FD, QualType FieldTy) final {
     addParam(FD, FieldTy);
     return true;
@@ -1225,6 +1220,8 @@ class SyclKernelDeclCreator
     return ArrayRef<ParmVarDecl *>(std::begin(Params) + LastParamIndex,
                                    std::end(Params));
   }
+
+  using SyclKernelFieldHandler::handleScalarType;
 };
 
 class SyclKernelBodyCreator
@@ -1309,11 +1306,9 @@ class SyclKernelBodyCreator
     return Result;
   }
 
-  void createExprForStructOrScalar(FieldDecl *FD) {
+  Expr *createInitExpr(FieldDecl *FD) {
     ParmVarDecl *KernelParameter =
         DeclCreator.getParamVarDeclsForCurrentField()[0];
-    InitializedEntity Entity =
-        InitializedEntity::InitializeMember(FD, &VarEntity);
     QualType ParamType = KernelParameter->getOriginalType();
     Expr *DRE = SemaRef.BuildDeclRefExpr(KernelParameter, ParamType, VK_LValue,
                                          SourceLocation());
@@ -1323,32 +1318,49 @@ class SyclKernelBodyCreator
       DRE = ImplicitCastExpr::Create(SemaRef.Context, FD->getType(),
                                      CK_AddressSpaceConversion, DRE, nullptr,
                                      VK_RValue);
+    return DRE;
+  }
+
+  void createExprForStructOrScalar(FieldDecl *FD) {
+    InitializedEntity Entity =
+        InitializedEntity::InitializeMember(FD, &VarEntity);
     InitializationKind InitKind =
         InitializationKind::CreateCopy(SourceLocation(), SourceLocation());
+    Expr *DRE = createInitExpr(FD);
     InitializationSequence InitSeq(SemaRef, Entity, InitKind, DRE);
-
     ExprResult MemberInit = InitSeq.Perform(SemaRef, Entity, InitKind, DRE);
     InitExprs.push_back(MemberInit.get());
   }
 
-  void createExprForArray(FieldDecl *FD) {
-    ParmVarDecl *KernelParameter =
-        DeclCreator.getParamVarDeclsForCurrentField()[0];
-    QualType ParamType = KernelParameter->getOriginalType();
-    CXXRecordDecl *WrapperStruct = ParamType->getAsCXXRecordDecl();
-    // The first and only field of the wrapper struct is the array
-    FieldDecl *Array = *(WrapperStruct->field_begin());
-    Expr *DRE = SemaRef.BuildDeclRefExpr(KernelParameter, ParamType, VK_LValue,
-                                         SourceLocation());
-    Expr *InitExpr = BuildMemberExpr(DRE, Array);
-    InitializationKind InitKind = InitializationKind::CreateDirect(
-        SourceLocation(), SourceLocation(), SourceLocation());
-    InitializedEntity Entity = InitializedEntity::InitializeLambdaCapture(
-        nullptr, Array->getType(), SourceLocation());
-    InitializationSequence InitSeq(SemaRef, Entity, InitKind, InitExpr);
-    ExprResult MemberInit =
-        InitSeq.Perform(SemaRef, Entity, InitKind, InitExpr);
-    InitExprs.push_back(MemberInit.get());
+  void createExprForScalarElement(FieldDecl *FD, QualType FieldTy) {
+    InitializedEntity ArrayEntity =
+        InitializedEntity::InitializeMember(FD, &VarEntity);
+    InitializationKind InitKind =
+        InitializationKind::CreateCopy(SourceLocation(), SourceLocation());
+    Expr *DRE = createInitExpr(FD);
+    Expr *Idx = dyn_cast<ArraySubscriptExpr>(MemberExprBases.back())->getIdx();
+    llvm::APSInt Result;
+    SemaRef.VerifyIntegerConstantExpression(Idx, &Result);
+    uint64_t IntIdx = Result.getZExtValue();
+    InitializedEntity Entity = InitializedEntity::InitializeElement(
+        SemaRef.getASTContext(), IntIdx, ArrayEntity);
+    InitializationSequence InitSeq(SemaRef, Entity, InitKind, DRE);
+    ExprResult MemberInit = InitSeq.Perform(SemaRef, Entity, InitKind, DRE);
+    llvm::SmallVector<Expr *, 16> ArrayInitExprs;
+    if (IntIdx > 0) {
+      // Continue with the current InitList
+      InitListExpr *ILE = cast<InitListExpr>(InitExprs.back());
+      InitExprs.pop_back();
+      llvm::ArrayRef<Expr *> L = ILE->inits();
+      for (size_t I = 0; I < L.size(); I++)
+        ArrayInitExprs.push_back(L[I]);
+    }
+    ArrayInitExprs.push_back(MemberInit.get());
+    Expr *ILE = new (SemaRef.getASTContext())
+        InitListExpr(SemaRef.getASTContext(), SourceLocation(), ArrayInitExprs,
+                     SourceLocation());
+    ILE->setType(FD->getType());
+    InitExprs.push_back(ILE);
   }
 
   void createSpecialMethodCall(const CXXRecordDecl *SpecialClass, Expr *Base,
@@ -1479,18 +1491,17 @@ class SyclKernelBodyCreator
     return true;
   }
 
+  //FIXME Remove this function when structs are replaced by their fields
   bool handleStructType(FieldDecl *FD, QualType FieldTy) final {
     createExprForStructOrScalar(FD);
     return true;
   }
 
   bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
-    createExprForStructOrScalar(FD);
-    return true;
-  }
-
-  bool handleArrayType(FieldDecl *FD, QualType FieldTy) final {
-    createExprForArray(FD);
+    if (dyn_cast<ArraySubscriptExpr>(MemberExprBases.back()))
+      createExprForScalarElement(FD, FieldTy);
+    else
+      createExprForStructOrScalar(FD);
     return true;
   }
 
@@ -1531,6 +1542,7 @@ class SyclKernelBodyCreator
 
   using SyclKernelFieldHandler::enterArray;
   using SyclKernelFieldHandler::enterField;
+  using SyclKernelFieldHandler::handleScalarType;
   using SyclKernelFieldHandler::leaveField;
 };
 
@@ -1547,13 +1559,9 @@ class SyclKernelIntHeaderCreator
     uint64_t Size;
     const ConstantArrayType *CAT =
         SemaRef.getASTContext().getAsConstantArrayType(ArgTy);
-    if (CAT) {
-      QualType ET = CAT->getElementType();
-      Size = static_cast<size_t>(CAT->getSize().getZExtValue()) *
-             SemaRef.getASTContext().getTypeSizeInChars(ET).getQuantity();
-    } else {
-      Size = SemaRef.getASTContext().getTypeSizeInChars(ArgTy).getQuantity();
-    }
+    if (CAT)
+      ArgTy = CAT->getElementType();
+    Size = SemaRef.getASTContext().getTypeSizeInChars(ArgTy).getQuantity();
     Header.addParamDesc(Kind, static_cast<unsigned>(Size),
                         static_cast<unsigned>(CurOffset));
   }
@@ -1630,12 +1638,7 @@ class SyclKernelIntHeaderCreator
     return true;
   }
 
-  bool handleArrayType(FieldDecl *FD, QualType FieldTy) final {
-    wrapAnArray(SemaRef.getASTContext(), FieldTy, FD);
-    addParam(FD, FD->getType(), SYCLIntegrationHeader::kind_std_layout);
-    return true;
-  }
-
+  //FIXME Remove this function when structs are replaced by their fields
   bool handleStructType(FieldDecl *FD, QualType FieldTy) final {
     addParam(FD, FieldTy, SYCLIntegrationHeader::kind_std_layout);
     return true;
@@ -1692,6 +1695,8 @@ class SyclKernelIntHeaderCreator
     }
     CurOffset -= ArraySize;
   }
+
+  using SyclKernelFieldHandler::handleScalarType;
 };
 } // namespace