[SYCL][FPGA] Add io_pipe_id attribute

This attirubte is applicabale to pipe storage decl.
It's expected to be used only in SYCL headers to distinguish
I/O pipes from ordinar pipes and from each other.

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

Author: MrSidims

clang/include/clang/Basic/Attr.td

@@ -1823,6 +1823,15 @@ def SYCLFPGAPipe : TypeAttr {
   let Documentation = [SYCLFPGAPipeDocs];
 }
 
+def SYCLIntelPipeIO : Attr {
+  let Spellings = [GNU<"io_pipe_id">];
+  let Args = [ExprArgument<"ID">];
+  let LangOpts = [SYCLIsDevice, SYCLIsHost];
+  let Subjects = SubjectList<[Var]>;
+  let Documentation = [SYCLIntelPipeIOAttrDocs];
+  let PragmaAttributeSupport = 0;
+}
+
 // Variadic integral arguments.
 def IntelFPGABankBits : Attr {
   let Spellings = [CXX11<"intelfpga", "bank_bits">];

clang/include/clang/Basic/AttrDocs.td

@@ -2033,6 +2033,20 @@ write only. Expected to be used only in SYCL headers.
   }];
 }
 
+def SYCLIntelPipeIOAttrDocs : Documentation {
+  let Category = DocCatVariable;
+  let Heading = "IO pipe ID";
+  let Content = [{
+Add I/O attribute to SYCL pipe declaration to declare a special I/O pipe to
+interface with input or output features of an FPGA. These features might include
+network interfaces, PCIe, cameras, or other data capture or processing devices
+or protocols.
+
+The io_pipe_id(id) attribute specifies the I/O feature of an accelerator board
+with which a pipe interfaces. The id argument is the name of the I/O interface.
+  }];
+}
+
 def SYCLIntelFPGAIVDepAttrDocs : Documentation {
   let Category = DocCatVariable;
   let Heading = "ivdep";

clang/include/clang/Sema/Sema.h

@@ -9708,6 +9708,10 @@ class Sema final {
   void addAMDGPUWavesPerEUAttr(Decl *D, const AttributeCommonInfo &CI,
                                Expr *Min, Expr *Max);
 
+  /// addSYCLIntelPipeIOAttr - Adds a pipe I/O attribute to a particular
+  /// declaration.
+  void addSYCLIntelPipeIOAttr(Decl *D, const AttributeCommonInfo &CI, Expr *ID);
+
   bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type);
 
   //===--------------------------------------------------------------------===//

clang/lib/CodeGen/CodeGenModule.cpp

@@ -3479,6 +3479,32 @@ bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) {
   return true;
 }
 
+static void maybeEmitPipeStorageMetadata(const VarDecl *D,
+                                         llvm::GlobalVariable *GV,
+                                         CodeGenModule &CGM) {
+  // TODO: Applicable only on pipe storages. Currently they are defined
+  // as structures inside of SYCL headers. Add a check for pipe_storage_t
+  // when it ready.
+  QualType PipeTy = D->getType();
+  if (!PipeTy->isStructureType())
+    return;
+
+  if (auto *IOAttr = D->getAttr<SYCLIntelPipeIOAttr>()) {
+    llvm::APSInt ID(32);
+    llvm::LLVMContext &Context = CGM.getLLVMContext();
+    bool IsValid =
+        IOAttr->getID()->isIntegerConstantExpr(ID, D->getASTContext());
+    assert(IsValid && "Not an integer constant expression");
+    (void)IsValid;
+
+    llvm::Metadata *AttrMDArgs[] = {
+        llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
+            llvm::Type::getInt32Ty(Context), ID.getSExtValue()))};
+    GV->setMetadata(IOAttr->getSpelling(),
+                    llvm::MDNode::get(Context, AttrMDArgs));
+  }
+}
+
 /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
 /// create and return an llvm GlobalVariable with the specified type.  If there
 /// is something in the module with the specified name, return it potentially
@@ -3668,6 +3694,10 @@ CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
         : (LangOpts.OpenCL ? LangAS::opencl_global : LangAS::Default);
   assert(getContext().getTargetAddressSpace(ExpectedAS) ==
          Ty->getPointerAddressSpace());
+
+  if (LangOpts.SYCLIsDevice)
+    maybeEmitPipeStorageMetadata(D, GV, *this);
+
   if (AddrSpace != ExpectedAS)
     return getTargetCodeGenInfo().performAddrSpaceCast(*this, GV, AddrSpace,
                                                        ExpectedAS, Ty);
@@ -4319,6 +4349,9 @@ void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D,
   if (CGDebugInfo *DI = getModuleDebugInfo())
     if (getCodeGenOpts().hasReducedDebugInfo())
       DI->EmitGlobalVariable(GV, D);
+
+  if (LangOpts.SYCLIsDevice)
+    maybeEmitPipeStorageMetadata(D, GV, *this);
 }
 
 void CodeGenModule::EmitExternalVarDeclaration(const VarDecl *D) {

clang/lib/Sema/SemaDeclAttr.cpp

@@ -5516,6 +5516,47 @@ static void handlePatchableFunctionEntryAttr(Sema &S, Decl *D,
                  PatchableFunctionEntryAttr(S.Context, AL, Count, Offset));
 }
 
+void Sema::addSYCLIntelPipeIOAttr(Decl *D, const AttributeCommonInfo &Attr,
+                                  Expr *E) {
+  VarDecl *VD = cast<VarDecl>(D);
+  QualType Ty = VD->getType();
+  // TODO: Applicable only on pipe storages. Currently they are defined
+  // as structures inside of SYCL headers. Add a check for pipe_storage_t
+  // when it is ready.
+  if (!Ty->isStructureType()) {
+    Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
+        << Attr.getAttrName() << "SYCL pipe storage declaration";
+    return;
+  }
+
+  if (!E->isInstantiationDependent()) {
+    llvm::APSInt ArgVal(32);
+    if (!E->isIntegerConstantExpr(ArgVal, getASTContext())) {
+      Diag(E->getExprLoc(), diag::err_attribute_argument_type)
+          << Attr.getAttrName() << AANT_ArgumentIntegerConstant
+          << E->getSourceRange();
+      return;
+    }
+    int32_t ArgInt = ArgVal.getSExtValue();
+    if (ArgInt < 0) {
+      Diag(E->getExprLoc(), diag::err_attribute_requires_positive_integer)
+          << Attr.getAttrName() << /*non-negative*/ 1;
+      return;
+    }
+  }
+
+  D->addAttr(::new (Context) SYCLIntelPipeIOAttr(Context, Attr, E));
+}
+
+static void handleSYCLIntelPipeIOAttr(Sema &S, Decl *D,
+                                      const ParsedAttr &Attr) {
+  if (D->isInvalidDecl())
+    return;
+
+  Expr *E = Attr.getArgAsExpr(0);
+  S.addSYCLIntelPipeIOAttr(D, Attr, E);
+}
+
 static bool ArmMveAliasValid(unsigned BuiltinID, StringRef AliasName) {
   if (AliasName.startswith("__arm_"))
     AliasName = AliasName.substr(6);
@@ -8040,6 +8081,9 @@ static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
   case ParsedAttr::AT_IntelFPGABankBits:
     handleIntelFPGABankBitsAttr(S, D, AL);
     break;
+  case ParsedAttr::AT_SYCLIntelPipeIO:
+    handleSYCLIntelPipeIOAttr(S, D, AL);
+    break;
 
   case ParsedAttr::AT_AnyX86NoCallerSavedRegisters:
     handleSimpleAttribute<AnyX86NoCallerSavedRegistersAttr>(S, D, AL);

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

@@ -553,6 +553,17 @@ static void instantiateIntelFPGABankBitsAttr(
   S.AddIntelFPGABankBitsAttr(New, *Attr, Args.data(), Args.size());
 }
 
+static void instantiateSYCLIntelPipeIOAttr(
+    Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
+    const SYCLIntelPipeIOAttr *Attr, Decl *New) {
+  // The ID expression is a constant expression.
+  EnterExpressionEvaluationContext Unevaluated(
+      S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
+  ExprResult Result = S.SubstExpr(Attr->getID(), TemplateArgs);
+  if (!Result.isInvalid())
+    S.addSYCLIntelPipeIOAttr(New, *Attr, Result.getAs<Expr>());
+}
+
 void Sema::InstantiateAttrsForDecl(
     const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Tmpl,
     Decl *New, LateInstantiatedAttrVec *LateAttrs,
@@ -686,6 +697,10 @@ void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
       instantiateIntelFPGABankBitsAttr(*this, TemplateArgs, IntelFPGABankBits,
                                        New);
     }
+    if (const auto *SYCLIntelPipeIO = dyn_cast<SYCLIntelPipeIOAttr>(TmplAttr)) {
+      instantiateSYCLIntelPipeIOAttr(*this, TemplateArgs, SYCLIntelPipeIO, New);
+      continue;
+    }
 
     // Existing DLL attribute on the instantiation takes precedence.
     if (TmplAttr->getKind() == attr::DLLExport ||

clang/test/CodeGenSYCL/fpga_pipes.cpp

@@ -11,6 +11,39 @@ RPipeTy RPipeCreator();
 template <typename PipeTy>
 void foo(PipeTy Pipe) {}
 
+struct PipeStorageTy {
+  int Size;
+};
+
+// CHECK:  @{{.*}}Storage = {{.*}} !io_pipe_id ![[ID0:[0-9]+]]
+constexpr PipeStorageTy
+    Storage __attribute__((io_pipe_id(1))) = {1};
+
+// CHECK:  @{{.*}}TempStorage{{.*}} = {{.*}} !io_pipe_id ![[ID1:[0-9]+]]
+template <int N>
+constexpr PipeStorageTy
+    TempStorage __attribute__((io_pipe_id(N))) = {2};
+
+void boo(PipeStorageTy PipeStorage);
+
+template <int ID>
+struct ethernet_pipe {
+  static constexpr int id = ID;
+};
+
+// CHECK:  @{{.*}}PipeStorage{{.*}} = {{.*}} !io_pipe_id ![[ID2:[0-9]+]]
+template <typename name>
+class pipe {
+public:
+  static void read() {
+    boo(PipeStorage);
+  }
+
+private:
+  static constexpr PipeStorageTy
+      PipeStorage __attribute__((io_pipe_id(name::id))) = {3};
+};
+
 template <typename name, typename Func>
 __attribute__((sycl_kernel)) void kernel_single_task(Func kernelFunc) {
   kernelFunc();
@@ -24,7 +57,12 @@ int main() {
     RPipeTy rpipe = RPipeCreator();
     foo<WPipeTy>(wpipe);
     foo<RPipeTy>(rpipe);
+    boo(Storage);
+    boo(TempStorage<2>);
+    pipe<ethernet_pipe<42>>::read();
   });
   return 0;
 }
-
+// CHECK: ![[ID0]] = !{i32 1}
+// CHECK: ![[ID1]] = !{i32 2}
+// CHECK: ![[ID2]] = !{i32 42}

clang/test/SemaSYCL/fpga_pipes.cpp

@@ -14,3 +14,35 @@ using type4 = __attribute__((pipe(0))) const int;
 
 // expected-error@+1{{'pipe' attribute takes one argument}}
 using type5 = __attribute__((pipe)) const int;
+
+struct pipe_storage {};
+
+// no error expected
+const pipe_storage Storage1 __attribute__((io_pipe_id(1)));
+
+// expected-error@+1{{'io_pipe_id' attribute requires a non-negative integral compile time constant expression}}
+const pipe_storage Storage2 __attribute__((io_pipe_id(-11)));
+
+// expected-error@+1{{'io_pipe_id' attribute requires an integer constant}}
+const pipe_storage Storage3 __attribute__((io_pipe_id("abc")));
+
+// expected-error@+1{{'io_pipe_id' attribute only applies to SYCL pipe storage declaration}}
+int Storage4 __attribute__((io_pipe_id(5)));
+
+// expected-error@+2{{'io_pipe_id' attribute requires a non-negative integral compile time constant expression}}
+template <int N>
+pipe_storage Storage5 __attribute__((io_pipe_id(N)));
+
+template <typename name, typename Func>
+__attribute__((sycl_kernel)) void kernel_single_task(Func kernelFunc) {
+  kernelFunc();
+}
+
+void foo(pipe_storage PS) {}
+
+int main() {
+  // no error expected
+  foo(Storage5<2>);
+  // expected-note@+1{{in instantiation of variable template specialization 'Storage5' requested here}}
+  foo(Storage5<-1>);
+}