[SYCL][FPGA] Add support for loop count attribute.

clang/include/clang/Basic/Attr.td

@@ -1975,6 +1975,29 @@ def : MutualExclusions<[SYCLIntelFPGAIVDep,
 def : MutualExclusions<[SYCLIntelFPGAMaxConcurrency,
                         SYCLIntelFPGADisableLoopPipelining]>;
 
+def SYCLIntelFPGALoopCount : StmtAttr {
+  let Spellings = [CXX11<"intel", "loop_count_min">,
+                   CXX11<"intel", "loop_count_max">,
+                   CXX11<"intel", "loop_count_avg">];
+  let Subjects = SubjectList<[ForStmt, CXXForRangeStmt, WhileStmt, DoStmt],
+                             ErrorDiag, "'for', 'while', and 'do' statements">;
+  let Accessors = [Accessor<"isMin", [CXX11<"intel", "loop_count_min">]>,
+                   Accessor<"isMax", [CXX11<"intel", "loop_count_max">]>,
+                   Accessor<"isAvg", [CXX11<"intel", "loop_count_avg">]>];
+  let Args = [ExprArgument<"NTripCount">];
+  let LangOpts = [SYCLIsDevice, SilentlyIgnoreSYCLIsHost];
+  let HasCustomTypeTransform = 1;
+  let AdditionalMembers = [{
+    enum CountKind { loop_count_min, loop_count_max, loop_count_avg };
+    CountKind getCountKind() const {
+      return isMin() ? loop_count_min :
+             isMax() ? loop_count_max :
+             loop_count_avg;
+    }
+  }];
+  let Documentation = [SYCLIntelFPGALoopCountAttrDocs];
+}
+
 def : MutualExclusions<[SYCLIntelFPGAMaxConcurrency,
                         SYCLIntelFPGADisableLoopPipelining]>;
 

clang/include/clang/Basic/AttrDocs.td

@@ -2951,6 +2951,43 @@ or ``ivdep``.
   }];
 }
 
+def SYCLIntelFPGALoopCountAttrDocs : Documentation {
+  let Category = DocCatVariable;
+  let Heading = "intel::loop_count_min, intel::loop_count_max, intel::loop_count_avg";
+  let Content = [{
+The "loop_count" attribute specifies the minimum, maximum, or average number of
+iterations for a for loop. In addition, a list of commonly occurring values
+can be specified to help the compiler generate multiple versions and perform
+complete unrolling.
+
+.. code-block:: c++
+
+  void foo() {
+    int a[10];
+    [[intel::loop_count_min(40)] for (int i = 0; i < 10; ++i) a[i] = 0;
+  }
+
+  void zoo() {
+    int a[10];
+    [[intel::loop_count_max(40)] for (int i = 0; i < 10; ++i) a[i] = 0;
+  }
+
+  void goo() {
+    int a[10];
+    [[intel::loop_count_min(10)]
+    [[intel::loop_count_max(40)]
+    [[intel::loop_count_avg(15)]
+    for (int i = 0; i < 10; ++i) a[i] = 0;
+  }
+
+  template<int N>
+  void bar() {
+    [[intel::loop_count_avg(N)]] for(;;) { }
+  }
+
+  }];
+}
+
 def SYCLIntelFPGAMaxInterleavingAttrDocs : Documentation {
   let Category = DocCatVariable;
   let Heading = "intel::max_interleaving";

clang/include/clang/Sema/Sema.h

@@ -2121,6 +2121,9 @@ class Sema final {
   OpenCLUnrollHintAttr *
   BuildOpenCLLoopUnrollHintAttr(const AttributeCommonInfo &A, Expr *E);
 
+  SYCLIntelFPGALoopCountAttr *
+  BuildSYCLIntelFPGALoopCount(const AttributeCommonInfo &CI, Expr *E);
+
   bool CheckQualifiedFunctionForTypeId(QualType T, SourceLocation Loc);
 
   bool CheckFunctionReturnType(QualType T, SourceLocation Loc);
@@ -13439,7 +13442,8 @@ FPGALoopAttrT *Sema::BuildSYCLIntelFPGALoopAttr(const AttributeCommonInfo &A,
                A.getParsedKind() ==
                    ParsedAttr::AT_SYCLIntelFPGAMaxInterleaving ||
                A.getParsedKind() ==
-                   ParsedAttr::AT_SYCLIntelFPGASpeculatedIterations) {
+                   ParsedAttr::AT_SYCLIntelFPGASpeculatedIterations ||
+               A.getParsedKind() == ParsedAttr::AT_SYCLIntelFPGALoopCount) {
       if (Val < 0) {
         Diag(E->getExprLoc(), diag::err_attribute_requires_positive_integer)
             << A.getAttrName() << /* non-negative */ 1;

clang/lib/CodeGen/CGLoopInfo.cpp

@@ -553,10 +553,10 @@ MDNode *LoopInfo::createMetadata(
 
   // Setting max_concurrency attribute with number of threads
   if (Attrs.SYCLMaxConcurrencyEnable) {
-    Metadata *Vals[] = {MDString::get(Ctx, "llvm.loop.max_concurrency.count"),
-                        ConstantAsMetadata::get(ConstantInt::get(
-                            llvm::Type::getInt32Ty(Ctx),
-                            Attrs.SYCLMaxConcurrencyNThreads))};
+    Metadata *Vals[] = {
+        MDString::get(Ctx, "llvm.loop.max_concurrency.count"),
+        ConstantAsMetadata::get(ConstantInt::get(
+            llvm::Type::getInt32Ty(Ctx), Attrs.SYCLMaxConcurrencyNThreads))};
     LoopProperties.push_back(MDNode::get(Ctx, Vals));
   }
 
@@ -605,6 +605,16 @@ MDNode *LoopInfo::createMetadata(
     LoopProperties.push_back(MDNode::get(Ctx, Vals));
   }
 
+  if (Attrs.SYCLIntelFPGALoopCountEnable) {
+    for (int i = 0; i < Attrs.SYCLIntelFPGALoopCountVariant.size(); i++) {
+      Metadata *Vals[] = {
+          MDString::get(Ctx, Attrs.SYCLIntelFPGALoopCountVariant[i]),
+          ConstantAsMetadata::get(
+              ConstantInt::get(llvm::Type::getInt32Ty(Ctx),
+                               Attrs.SYCLIntelFPGALoopCountValue[i]))};
+      LoopProperties.push_back(MDNode::get(Ctx, Vals));
+    }
+  }
   LoopProperties.insert(LoopProperties.end(), AdditionalLoopProperties.begin(),
                         AdditionalLoopProperties.end());
   return createFullUnrollMetadata(Attrs, LoopProperties, HasUserTransforms);
@@ -621,10 +631,12 @@ LoopAttributes::LoopAttributes(bool IsParallel)
       SYCLLoopCoalesceNLevels(0), SYCLLoopPipeliningDisable(false),
       SYCLMaxInterleavingEnable(false), SYCLMaxInterleavingNInvocations(0),
       SYCLSpeculatedIterationsEnable(false),
-      SYCLSpeculatedIterationsNIterations(0), UnrollCount(0),
-      UnrollAndJamCount(0), DistributeEnable(LoopAttributes::Unspecified),
-      PipelineDisabled(false), PipelineInitiationInterval(0),
-      SYCLNofusionEnable(false), MustProgress(false) {}
+      SYCLSpeculatedIterationsNIterations(0),
+      SYCLIntelFPGALoopCountEnable(false), SYCLIntelFPGALoopCountValue(0),
+      SYCLIntelFPGALoopCountVariant(0), UnrollCount(0), UnrollAndJamCount(0),
+      DistributeEnable(LoopAttributes::Unspecified), PipelineDisabled(false),
+      PipelineInitiationInterval(0), SYCLNofusionEnable(false),
+      MustProgress(false) {}
 
 void LoopAttributes::clear() {
   IsParallel = false;
@@ -643,6 +655,9 @@ void LoopAttributes::clear() {
   SYCLMaxInterleavingNInvocations = 0;
   SYCLSpeculatedIterationsEnable = false;
   SYCLSpeculatedIterationsNIterations = 0;
+  SYCLIntelFPGALoopCountEnable = false;
+  SYCLIntelFPGALoopCountVariant.clear();
+  SYCLIntelFPGALoopCountValue.clear();
   UnrollCount = 0;
   UnrollAndJamCount = 0;
   VectorizeEnable = LoopAttributes::Unspecified;
@@ -680,8 +695,11 @@ LoopInfo::LoopInfo(BasicBlock *Header, const LoopAttributes &Attrs,
       Attrs.SYCLMaxInterleavingNInvocations == 0 &&
       Attrs.SYCLSpeculatedIterationsEnable == false &&
       Attrs.SYCLSpeculatedIterationsNIterations == 0 &&
-      Attrs.UnrollCount == 0 && Attrs.UnrollAndJamCount == 0 &&
-      !Attrs.PipelineDisabled && Attrs.PipelineInitiationInterval == 0 &&
+      Attrs.SYCLIntelFPGALoopCountEnable == 0 &&
+      Attrs.SYCLIntelFPGALoopCountVariant.empty() &&
+      Attrs.SYCLIntelFPGALoopCountValue.empty() && Attrs.UnrollCount == 0 &&
+      Attrs.UnrollAndJamCount == 0 && !Attrs.PipelineDisabled &&
+      Attrs.PipelineInitiationInterval == 0 &&
       Attrs.VectorizePredicateEnable == LoopAttributes::Unspecified &&
       Attrs.VectorizeEnable == LoopAttributes::Unspecified &&
       Attrs.UnrollEnable == LoopAttributes::Unspecified &&
@@ -1030,6 +1048,20 @@ void LoopInfoStack::push(BasicBlock *Header, clang::ASTContext &Ctx,
                                         ->getSExtValue());
     }
 
+    if (const auto *IntelFPGALoopCountAvg =
+            dyn_cast<SYCLIntelFPGALoopCountAttr>(A)) {
+      setSYCLIntelFPGALoopCountEnable();
+      setSYCLIntelFPGALoopCountValue(IntelFPGALoopCountAvg->getNTripCount()
+                                         ->getIntegerConstantExpr(Ctx)
+                                         ->getSExtValue());
+      const char *var = IntelFPGALoopCountAvg->isMax()
+                            ? "llvm.loop.intel.loopcount_max"
+                            : IntelFPGALoopCountAvg->isMin()
+                                  ? "llvm.loop.intel.loopcount_min"
+                                  : "llvm.loop.intel.loopcount_avg";
+      setSYCLIntelFPGALoopCountVariant(var);
+    }
+
     if (const auto *IntelFPGALoopCoalesce =
             dyn_cast<SYCLIntelFPGALoopCoalesceAttr>(A)) {
       if (auto *LCE = IntelFPGALoopCoalesce->getNExpr())

clang/lib/CodeGen/CGLoopInfo.h

@@ -15,6 +15,7 @@
 #define LLVM_CLANG_LIB_CODEGEN_CGLOOPINFO_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/Value.h"
@@ -117,6 +118,15 @@ struct LoopAttributes {
   /// Value for llvm.loop.max_concurrency.count metadata.
   unsigned SYCLMaxConcurrencyNThreads;
 
+  /// Flag for llvm.loop.intel.loopcount metadata.
+  bool SYCLIntelFPGALoopCountEnable;
+
+  /// Value for llvm.loop.intel.loopcount value metadata.
+  llvm::SmallVector<unsigned int, 2> SYCLIntelFPGALoopCountValue;
+
+  /// Value for llvm.loop.intel.loopcount variant(min/max/avg) metadata.
+  llvm::SmallVector<const char *, 2> SYCLIntelFPGALoopCountVariant;
+
   /// Flag for llvm.loop.coalesce metadata.
   bool SYCLLoopCoalesceEnable;
 
@@ -404,6 +414,21 @@ class LoopInfoStack {
     StagedAttrs.SYCLSpeculatedIterationsNIterations = C;
   }
 
+  /// Set flag of loopcount for the next loop pushed.
+  void setSYCLIntelFPGALoopCountEnable() {
+    StagedAttrs.SYCLIntelFPGALoopCountEnable = true;
+  }
+
+  /// Set value of loopcount value for the next loop pushed.
+  void setSYCLIntelFPGALoopCountValue(unsigned C) {
+    StagedAttrs.SYCLIntelFPGALoopCountValue.push_back(C);
+  }
+
+  /// Set value of loopcount variant for the next loop pushed.
+  void setSYCLIntelFPGALoopCountVariant(const char *var) {
+    StagedAttrs.SYCLIntelFPGALoopCountVariant.push_back(var);
+  }
+
   /// Set the unroll count for the next loop pushed.
   void setUnrollCount(unsigned C) { StagedAttrs.UnrollCount = C; }
 

clang/lib/Sema/SemaStmtAttr.cpp

@@ -243,6 +243,68 @@ static Attr *handleIntelFPGAIVDepAttr(Sema &S, Stmt *St, const ParsedAttr &A) {
       NumArgs == 2 ? A.getArgAsExpr(1) : nullptr);
 }
 
+static void
+CheckForDuplicateSYCLIntelLoopCountAttrs(Sema &S,
+                                         ArrayRef<const Attr *> Attrs) {
+  // Create a list of SYCLIntelFPGALoopCount attributes only.
+  SmallVector<const SYCLIntelFPGALoopCountAttr *, 8> OnlyLoopCountAttrs;
+  llvm::transform(
+      Attrs, std::back_inserter(OnlyLoopCountAttrs), [](const Attr *A) {
+        return dyn_cast_or_null<const SYCLIntelFPGALoopCountAttr>(A);
+      });
+  OnlyLoopCountAttrs.erase(
+      std::remove(OnlyLoopCountAttrs.begin(), OnlyLoopCountAttrs.end(),
+                  static_cast<const SYCLIntelFPGALoopCountAttr *>(nullptr)),
+      OnlyLoopCountAttrs.end());
+  if (OnlyLoopCountAttrs.empty())
+    return;
+
+  unsigned int MinCount = 0;
+  unsigned int MaxCount = 0;
+  unsigned int AvgCount = 0;
+  for (const auto *A : OnlyLoopCountAttrs) {
+    const SYCLIntelFPGALoopCountAttr *At =
+        dyn_cast<SYCLIntelFPGALoopCountAttr>(A);
+    switch (At->getCountKind()) {
+    case SYCLIntelFPGALoopCountAttr::CountKind::loop_count_min:
+      MinCount++;
+      break;
+    case SYCLIntelFPGALoopCountAttr::CountKind::loop_count_max:
+      MaxCount++;
+      break;
+    case SYCLIntelFPGALoopCountAttr::CountKind::loop_count_avg:
+      AvgCount++;
+      break;
+    }
+    if (MinCount > 1 || MaxCount > 1 || AvgCount > 1)
+      S.Diag(A->getLocation(), diag::err_sycl_loop_attr_duplication) << 1 << A;
+  }
+}
+
+static SYCLIntelFPGALoopCountAttr *
+handleIntelFPGALoopCountAttr(Sema &S, Stmt *St, const ParsedAttr &A) {
+  Expr *E = A.getArgAsExpr(0);
+  if (E && !E->isInstantiationDependent()) {
+    Optional<llvm::APSInt> ArgVal =
+        E->getIntegerConstantExpr(S.getASTContext());
+
+    if (!ArgVal) {
+      S.Diag(E->getExprLoc(), diag::err_attribute_argument_type)
+          << A.getAttrName() << AANT_ArgumentIntegerConstant
+          << E->getSourceRange();
+      return nullptr;
+    }
+
+    if (ArgVal->getSExtValue() < 0) {
+      S.Diag(E->getExprLoc(), diag::err_attribute_requires_positive_integer)
+          << A.getAttrName() << /* non-negative */ 1;
+      return nullptr;
+    }
+  }
+  return new (S.Context)
+      SYCLIntelFPGALoopCountAttr(S.Context, A, A.getArgAsExpr(0));
+}
+
 static Attr *handleIntelFPGANofusionAttr(Sema &S, Stmt *St,
                                          const ParsedAttr &A) {
   return new (S.Context) SYCLIntelFPGANofusionAttr(S.Context, A);
@@ -558,6 +620,7 @@ static void CheckForIncompatibleSYCLLoopAttributes(
                                                                          Attrs);
   CheckForDuplicationSYCLLoopAttribute<SYCLIntelFPGASpeculatedIterationsAttr>(
       S, Attrs);
+  CheckForDuplicateSYCLIntelLoopCountAttrs(S, Attrs);
   CheckForDuplicationSYCLLoopAttribute<LoopUnrollHintAttr>(S, Attrs, false);
   CheckRedundantSYCLIntelFPGAIVDepAttrs(S, Attrs);
   CheckForDuplicationSYCLLoopAttribute<SYCLIntelFPGANofusionAttr>(S, Attrs);
@@ -687,6 +750,8 @@ static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const ParsedAttr &A,
   case ParsedAttr::AT_SYCLIntelFPGASpeculatedIterations:
     return handleIntelFPGALoopAttr<SYCLIntelFPGASpeculatedIterationsAttr>(S, St,
                                                                           A);
+  case ParsedAttr::AT_SYCLIntelFPGALoopCount:
+    return handleIntelFPGALoopCountAttr(S, St, A);
   case ParsedAttr::AT_OpenCLUnrollHint:
   case ParsedAttr::AT_LoopUnrollHint:
     return handleLoopUnrollHint(S, St, A, Range);

clang/lib/Sema/SemaTemplateInstantiate.cpp

@@ -1093,6 +1093,8 @@ namespace {
     const SYCLIntelFPGASpeculatedIterationsAttr *
     TransformSYCLIntelFPGASpeculatedIterationsAttr(
         const SYCLIntelFPGASpeculatedIterationsAttr *SI);
+    const SYCLIntelFPGALoopCountAttr *
+    TransformSYCLIntelFPGALoopCountAttr(const SYCLIntelFPGALoopCountAttr *SI);
 
     ExprResult TransformPredefinedExpr(PredefinedExpr *E);
     ExprResult TransformDeclRefExpr(DeclRefExpr *E);
@@ -1618,6 +1620,15 @@ TemplateInstantiator::TransformSYCLIntelFPGASpeculatedIterationsAttr(
           *SI, TransformedExpr);
 }
 
+const SYCLIntelFPGALoopCountAttr *
+TemplateInstantiator::TransformSYCLIntelFPGALoopCountAttr(
+    const SYCLIntelFPGALoopCountAttr *LCA) {
+  Expr *TransformedExpr =
+      getDerived().TransformExpr(LCA->getNTripCount()).get();
+  return getSema().BuildSYCLIntelFPGALoopAttr<SYCLIntelFPGALoopCountAttr>(
+      *LCA, TransformedExpr);
+}
+
 const LoopUnrollHintAttr *TemplateInstantiator::TransformLoopUnrollHintAttr(
     const LoopUnrollHintAttr *LU) {
   Expr *TransformedExpr =

clang/test/CodeGenSYCL/intel-fpga-loops.cpp

@@ -14,6 +14,9 @@
 // CHECK: br label %for.cond2,  !llvm.loop ![[MD_MI_2:[0-9]+]]
 // CHECK: br label %for.cond,   !llvm.loop ![[MD_SI:[0-9]+]]
 // CHECK: br label %for.cond2,  !llvm.loop ![[MD_SI_2:[0-9]+]]
+// CHECK: br label %for.cond, !llvm.loop ![[MD_LCA:[0-9]+]]
+// CHECK: br label %for.cond2, !llvm.loop ![[MD_LCA_1:[0-9]+]]
+// CHECK: br label %for.cond13, !llvm.loop ![[MD_LCA_2:[0-9]+]]
 
 void disable_loop_pipelining() {
   int a[10];
@@ -109,6 +112,25 @@ void speculated_iterations() {
       a[i] = 0;
 }
 
+template <int A>
+void loop_count_control() {
+  int a[10];
+  // CHECK: ![[MD_LCA]] = distinct !{![[MD_LCA]], ![[MP:[0-9]+]], ![[MD_loop_count_avg:[0-9]+]]}
+  // CHECK-NEXT: ![[MD_loop_count_avg]] = !{!"llvm.loop.intel.loopcount_avg", i32 12}
+  [[intel::loop_count_avg(A)]] for (int i = 0; i != 10; ++i)
+      a[i] = 0;
+  // CHECK: ![[MD_LCA_1]] = distinct !{![[MD_LCA_1]], ![[MP:[0-9]+]], ![[MD_loop_count_max:[0-9]+]]}
+  // CHECK-NEXT: ![[MD_loop_count_max]] = !{!"llvm.loop.intel.loopcount_max", i32 4}
+  [[intel::loop_count_max(4)]] for (int i = 0; i != 10; ++i)
+      a[i] = 0;
+  // CHECK: ![[MD_LCA_2]] = distinct !{![[MD_LCA_2]], ![[MP:[0-9]+]], ![[MD_loop_count_min:[0-9]+]], ![[MD_loop_count_max_1:[0-9]+]], ![[MD_loop_count_avg_1:[0-9]+]]}
+  // CHECK: ![[MD_loop_count_min]] = !{!"llvm.loop.intel.loopcount_min", i32 4}
+  // CHECK: ![[MD_loop_count_max_1]] = !{!"llvm.loop.intel.loopcount_max", i32 40}
+  // CHECK-NEXT: ![[MD_loop_count_avg_1]] = !{!"llvm.loop.intel.loopcount_avg", i32 21}
+  [[intel::loop_count_min(4)]] [[intel::loop_count_max(40)]] [[intel::loop_count_avg(21)]] for (int i = 0; i != 10; ++i)
+      a[i] = 0;
+}
+
 template <typename name, typename Func>
 __attribute__((sycl_kernel)) void kernel_single_task(const Func &kernelFunc) {
   kernelFunc();
@@ -123,6 +145,7 @@ int main() {
     loop_coalesce<2>();
     max_interleaving<3>();
     speculated_iterations<4>();
+    loop_count_control<12>();
   });
   return 0;
 }