[SYCL] Initial support of Intel FPGA loop attributes

Following attributes are being supported:
intelfpga::ivdep(Safelen)
Applies to a loop. Safelen is a positive integer. If no additional
arguments are provided, it indicates that the backend may assume
that the loop carries no dependences. If a safelen is provided then
the backend may assume that all loop carried dependences have a
dependence distance of at least that length.

Metadata generated:
No safelen provided: "llvm.loop.ivdep.enable"
Safelen provided: "llvm.loop.ivdep.safelen", i32 Safelen

intelfpga::ii(Interval)
Applies to a loop. Indicates that the loop should be pipelined
with an initiation interval. Interval must be a positive integer.
Cannot be applied multiple times to the same loop.

Metadata generated:
"llvm.loop.ii", i32 Interval

intefpga::max_concurrency(NThreads)
Applies to a loop. Indicates that the loop should allow no more
than NThreads or iterations to execute it simultaneously.
NThreads must be a positive integer. Cannot be applied multiple
times to the same loop.

Metadata generated:
"llvm.loop.max_concurrency", i32 NThreads

Signed-off-by: Dmitry Sidorov <[email protected]>

Author: MrSidims

clang/include/clang/Basic/Attr.td

@@ -1387,6 +1387,42 @@ def Mode : Attr {
   let PragmaAttributeSupport = 0;
 }
 
+def IntelFPGAIVDep : Attr {
+  let Spellings = [CXX11<"intelfpga","ivdep">];
+  let Args = [IntArgument<"Safelen">];
+  let LangOpts = [SYCL];
+  let AdditionalMembers = [{
+    static const char *getName() {
+      return "ivdep";
+    }
+  }];
+  let Documentation = [IntelFPGAIVDepAttrDocs];
+}
+
+def IntelFPGAII : Attr {
+  let Spellings = [CXX11<"intelfpga","ii">];
+  let Args = [IntArgument<"Interval">];
+  let LangOpts = [SYCL];
+  let AdditionalMembers = [{
+    static const char *getName() {
+      return "ii";
+    }
+  }];
+  let Documentation = [IntelFPGAIIAttrDocs];
+}
+
+def IntelFPGAMaxConcurrency : Attr {
+  let Spellings = [CXX11<"intelfpga","max_concurrency">];
+  let Args = [IntArgument<"NThreads">];
+  let LangOpts = [SYCL];
+  let AdditionalMembers = [{
+    static const char *getName() {
+      return "max_concurrency";
+    }
+  }];
+  let Documentation = [IntelFPGAMaxConcurrencyAttrDocs];
+}
+
 def IntelFPGALocalNonConstVar : SubsetSubject<Var,
                               [{S->hasLocalStorage() &&
                                 S->getKind() != Decl::ImplicitParam &&

clang/include/clang/Basic/AttrDocs.td

@@ -1740,6 +1740,37 @@ threads or loop iterations.
   }];
 }
 
+def IntelFPGAIVDepAttrDocs : Documentation {
+  let Category = DocCatVariable;
+  let Heading = "ivdep";
+  let Content = [{
+This attribute applies to a loop. If no additional arguments are provided, it
+indicates that the backend may assume that the loop carries no dependences.
+If a safelen is provided then the backend may assume that all loop carried
+dependences have a dependence distance of at least that length.
+  }];
+}
+
+def IntelFPGAIIAttrDocs : Documentation {
+  let Category = DocCatVariable;
+  let Heading = "ii";
+  let Content = [{
+This attribute applies to a loop. Indicates that the loop should be pipelined
+with an initiation interval of N. N must be a positive integer. Cannot be
+applied multiple times to the same loop.
+  }];
+}
+
+def IntelFPGAMaxConcurrencyAttrDocs : Documentation {
+  let Category = DocCatVariable;
+  let Heading = "max_concurrency";
+  let Content = [{
+This attribute applies to a loop. Indicates that the loop should allow no more
+than N threads or iterations to execute it simultaneously. N must be a positive
+integer. Cannot be applied multiple times to the same loop.
+  }];
+}
+
 def RISCVInterruptDocs : Documentation {
   let Category = DocCatFunction;
   let Heading = "interrupt (RISCV)";

clang/include/clang/Basic/DiagnosticParseKinds.td

@@ -1218,6 +1218,11 @@ def err_pragma_cannot_end_force_cuda_host_device : Error<
   "force_cuda_host_device begin">;
 } // end of Parse Issue category.
 
+// Intel FPGA pragmas and attributes support
+// Attribute ivdep, ii, max_concurrency support
+def err_intel_fpga_loop_attrs_on_non_loop : Error<
+  "intelfpga loop attributes must be applied to for, while or do statements">;
+
 let CategoryName = "Modules Issue" in {
 def err_unexpected_module_decl : Error<
   "module declaration can only appear at the top level">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -128,6 +128,8 @@ def err_attribute_argument_not_power_of_two : Error<
   "%0 attribute argument must be a constant power of two greater than zero">;
 def err_intel_fpga_memory_arg_invalid : Error<
   "%0 attribute requires either no argument or one of: %1">;
+def err_intel_fpga_loop_attr_duplication : Error<
+  "duplicate Intel FPGA loop attribute '%0'">;
 
 // C99 variable-length arrays
 def ext_vla : Extension<"variable length arrays are a C99 feature">,

clang/include/clang/Parse/Parser.h

@@ -2519,8 +2519,16 @@ class Parser : public CodeCompletionHandler {
   /// Parses opencl_unroll_hint attribute.
   /// \return false if error happens.
   bool ParseOpenCLUnrollHintAttribute(ParsedAttributes &Attrs);
-  void ParseNullabilityTypeSpecifiers(ParsedAttributes &attrs);
 
+  /// Parses intelfpga:: loop attributes if the language is SYCL
+  bool MaybeParseIntelFPGALoopAttributes(ParsedAttributes &Attrs) {
+    if (getLangOpts().SYCLIsDevice)
+      return ParseIntelFPGALoopAttributes(Attrs);
+    return true;
+  }
+  bool ParseIntelFPGALoopAttributes(ParsedAttributes &Attrs);
+
+  void ParseNullabilityTypeSpecifiers(ParsedAttributes &attrs);
   VersionTuple ParseVersionTuple(SourceRange &Range);
   void ParseAvailabilityAttribute(IdentifierInfo &Availability,
                                   SourceLocation AvailabilityLoc,

clang/lib/CodeGen/CGLoopInfo.cpp

@@ -23,7 +23,9 @@ static MDNode *createMetadata(LLVMContext &Ctx, const LoopAttributes &Attrs,
                               const llvm::DebugLoc &EndLoc, MDNode *&AccGroup) {
 
   if (!Attrs.IsParallel && Attrs.VectorizeWidth == 0 &&
-      Attrs.InterleaveCount == 0 && Attrs.UnrollCount == 0 &&
+      Attrs.InterleaveCount == 0 && Attrs.IVDepEnable == false &&
+      Attrs.IVDepSafelen == 0 && Attrs.IInterval == 0 &&
+      Attrs.MaxConcurrencyNThreads == 0 && Attrs.UnrollCount == 0 &&
       Attrs.UnrollAndJamCount == 0 && !Attrs.PipelineDisabled &&
       Attrs.PipelineInitiationInterval == 0 &&
       Attrs.VectorizeEnable == LoopAttributes::Unspecified &&
@@ -63,6 +65,37 @@ static MDNode *createMetadata(LLVMContext &Ctx, const LoopAttributes &Attrs,
     Args.push_back(MDNode::get(Ctx, Vals));
   }
 
+  // Setting ivdep attribute
+  if (Attrs.IVDepEnable) {
+    Metadata *Vals[] = {MDString::get(Ctx, "llvm.loop.ivdep.enable")};
+    Args.push_back(MDNode::get(Ctx, Vals));
+  }
+
+  // Setting ivdep attribute with safelen
+  if (Attrs.IVDepSafelen > 0) {
+    Metadata *Vals[] = {MDString::get(Ctx, "llvm.loop.ivdep.safelen"),
+                        ConstantAsMetadata::get(ConstantInt::get(
+                            llvm::Type::getInt32Ty(Ctx), Attrs.IVDepSafelen))};
+    Args.push_back(MDNode::get(Ctx, Vals));
+  }
+
+  // Setting ii attribute with an initiation interval
+  if (Attrs.IInterval > 0) {
+    Metadata *Vals[] = {MDString::get(Ctx, "llvm.loop.ii"),
+                        ConstantAsMetadata::get(ConstantInt::get(
+                            llvm::Type::getInt32Ty(Ctx), Attrs.IInterval))};
+    Args.push_back(MDNode::get(Ctx, Vals));
+  }
+
+  // Setting max_concurrency attribute with number of threads
+  if (Attrs.MaxConcurrencyNThreads > 0) {
+    Metadata *Vals[] = {MDString::get(Ctx, "llvm.loop.max_concurrency"),
+                        ConstantAsMetadata::get(ConstantInt::get(
+                            llvm::Type::getInt32Ty(Ctx),
+                            Attrs.MaxConcurrencyNThreads))};
+    Args.push_back(MDNode::get(Ctx, Vals));
+  }
+
   // Setting unroll.count
   if (Attrs.UnrollCount > 0) {
     Metadata *Vals[] = {MDString::get(Ctx, "llvm.loop.unroll.count"),
@@ -152,6 +185,8 @@ static MDNode *createMetadata(LLVMContext &Ctx, const LoopAttributes &Attrs,
 
 LoopAttributes::LoopAttributes(bool IsParallel)
     : IsParallel(IsParallel), VectorizeEnable(LoopAttributes::Unspecified),
+      IVDepEnable(false), IVDepSafelen(0), IInterval(0),
+      MaxConcurrencyNThreads(0),
       UnrollEnable(LoopAttributes::Unspecified),
       UnrollAndJamEnable(LoopAttributes::Unspecified), VectorizeWidth(0),
       InterleaveCount(0), UnrollCount(0), UnrollAndJamCount(0),
@@ -161,6 +196,10 @@ LoopAttributes::LoopAttributes(bool IsParallel)
 void LoopAttributes::clear() {
   IsParallel = false;
   VectorizeWidth = 0;
+  IVDepEnable = false;
+  IVDepSafelen = 0;
+  IInterval = 0;
+  MaxConcurrencyNThreads = 0;
   InterleaveCount = 0;
   UnrollCount = 0;
   UnrollAndJamCount = 0;
@@ -358,6 +397,49 @@ void LoopInfoStack::push(BasicBlock *Header, clang::ASTContext &Ctx,
     }
   }
 
+  // Translate intelfpga loop attributes' arguments to equivalent Attr enums.
+  // It's being handled separately from LoopHintAttrs not to support
+  // legacy GNU attributes and pragma styles.
+  //
+  // For attribute ivdep:
+  // 0 - 'llvm.loop.ivdep.enable' metadata will be emitted
+  // n - 'llvm.loop.ivdep.safelen, i32 n' metadata will be emitted
+  // For attribute ii:
+  // n - 'llvm.loop.ii, i32 n' metadata will be emitted
+  // For attribute max_concurrency:
+  // n - 'llvm.loop.max_concurrency, i32 n' metadata will be emitted
+  for (const auto *Attr : Attrs) {
+    const IntelFPGAIVDepAttr *IntelFPGAIVDep =
+      dyn_cast<IntelFPGAIVDepAttr>(Attr);
+    const IntelFPGAIIAttr *IntelFPGAII =
+      dyn_cast<IntelFPGAIIAttr>(Attr);
+    const IntelFPGAMaxConcurrencyAttr *IntelFPGAMaxConcurrency =
+      dyn_cast<IntelFPGAMaxConcurrencyAttr>(Attr);
+
+    if (!IntelFPGAIVDep && !IntelFPGAII && !IntelFPGAMaxConcurrency)
+      continue;
+
+    if (IntelFPGAIVDep) {
+      unsigned ValueInt = IntelFPGAIVDep->getSafelen();
+      if (ValueInt == 0)
+        setIVDepEnable();
+      else if (ValueInt > 1)
+        setIVDepSafelen(ValueInt);
+    }
+
+    if (IntelFPGAII) {
+      unsigned ValueInt = IntelFPGAII->getInterval();
+      if (ValueInt > 1)
+        setIInterval(ValueInt);
+    }
+
+    if (IntelFPGAMaxConcurrency) {
+      unsigned ValueInt = IntelFPGAMaxConcurrency->getNThreads();
+      if (ValueInt > 1)
+        setMaxConcurrencyNThreads(ValueInt);
+    }
+  }
+
   /// Stage the attributes.
   push(Header, StartLoc, EndLoc);
 }

clang/lib/CodeGen/CGLoopInfo.h

@@ -57,6 +57,18 @@ struct LoopAttributes {
   /// Value for llvm.loop.interleave.count metadata.
   unsigned InterleaveCount;
 
+  /// Value for llvm.loop.ivdep.enable metadata.
+  bool IVDepEnable;
+
+  /// Value for llvm.loop.ivdep.safelen metadata.
+  unsigned IVDepSafelen;
+
+  /// Value for llvm.loop.ii metadata.
+  unsigned IInterval;
+
+  /// Value for llvm.loop.max_concurrency metadata.
+  unsigned MaxConcurrencyNThreads;
+
   /// llvm.unroll.
   unsigned UnrollCount;
 
@@ -170,6 +182,20 @@ class LoopInfoStack {
   /// Set the interleave count for the next loop pushed.
   void setInterleaveCount(unsigned C) { StagedAttrs.InterleaveCount = C; }
 
+  /// Set flag of ivdep for the next loop pushed.
+  void setIVDepEnable() { StagedAttrs.IVDepEnable = true; }
+
+  /// Set value of safelen count for the next loop pushed.
+  void setIVDepSafelen(unsigned C) { StagedAttrs.IVDepSafelen = C; }
+
+  /// Set value of an initiation interval for the next loop pushed.
+  void setIInterval(unsigned C) { StagedAttrs.IInterval = C; }
+
+  /// Set value of threads for the next loop pushed.
+  void setMaxConcurrencyNThreads(unsigned C) {
+    StagedAttrs.MaxConcurrencyNThreads = C;
+  }
+
   /// Set the unroll count for the next loop pushed.
   void setUnrollCount(unsigned C) { StagedAttrs.UnrollCount = C; }
 

clang/lib/Parse/ParseStmt.cpp

@@ -100,7 +100,8 @@ Parser::ParseStatementOrDeclaration(StmtVector &Stmts,
 
   ParsedAttributesWithRange Attrs(AttrFactory);
   MaybeParseCXX11Attributes(Attrs, nullptr, /*MightBeObjCMessageSend*/ true);
-  if (!MaybeParseOpenCLUnrollHintAttribute(Attrs))
+  if (!MaybeParseOpenCLUnrollHintAttribute(Attrs) ||
+      !MaybeParseIntelFPGALoopAttributes(Attrs))
     return StmtError();
 
   StmtResult Res = ParseStatementOrDeclarationAfterAttributes(
@@ -2370,3 +2371,21 @@ bool Parser::ParseOpenCLUnrollHintAttribute(ParsedAttributes &Attrs) {
   }
   return true;
 }
+
+bool Parser::ParseIntelFPGALoopAttributes(ParsedAttributes &Attrs) {
+  MaybeParseCXX11Attributes(Attrs);
+
+  if (Attrs.empty())
+    return true;
+
+  if (Attrs.begin()->getKind() != ParsedAttr::AT_IntelFPGAIVDep &&
+      Attrs.begin()->getKind() != ParsedAttr::AT_IntelFPGAII &&
+      Attrs.begin()->getKind() != ParsedAttr::AT_IntelFPGAMaxConcurrency)
+    return true;
+
+  if (!(Tok.is(tok::kw_for) || Tok.is(tok::kw_while) || Tok.is(tok::kw_do))) {
+    Diag(Tok, diag::err_intel_fpga_loop_attrs_on_non_loop);
+    return false;
+  }
+  return true;
+}