[SYCL-Upstreaming] Add support for host kernel launch stmt generation

clang/include/clang/AST/ComputeDependence.h

@@ -84,6 +84,7 @@ class CXXParenListInitExpr;
 class TypeTraitExpr;
 class ConceptSpecializationExpr;
 class SYCLUniqueStableNameExpr;
+class UnresolvedSYCLKernelLaunchExpr;
 class PredefinedExpr;
 class CallExpr;
 class OffsetOfExpr;
@@ -179,6 +180,7 @@ ExprDependence computeDependence(ConceptSpecializationExpr *E,
                                  bool ValueDependent);
 
 ExprDependence computeDependence(SYCLUniqueStableNameExpr *E);
+ExprDependence computeDependence(UnresolvedSYCLKernelLaunchExpr *E);
 ExprDependence computeDependence(PredefinedExpr *E);
 ExprDependence computeDependence(CallExpr *E, ArrayRef<Expr *> PreArgs);
 ExprDependence computeDependence(OffsetOfExpr *E);

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -2999,6 +2999,7 @@ DEF_TRAVERSE_STMT(ParenListExpr, {})
 DEF_TRAVERSE_STMT(SYCLUniqueStableNameExpr, {
   TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
 })
+DEF_TRAVERSE_STMT(UnresolvedSYCLKernelLaunchExpr, {})
 DEF_TRAVERSE_STMT(OpenACCAsteriskSizeExpr, {})
 DEF_TRAVERSE_STMT(PredefinedExpr, {})
 DEF_TRAVERSE_STMT(ShuffleVectorExpr, {})

clang/include/clang/AST/StmtSYCL.h

@@ -99,6 +99,59 @@ class SYCLKernelCallStmt : public Stmt {
   }
 };
 
+// UnresolvedSYCLKernelLaunchExpr a call to the kernel launch function for a
+// kernel that has not been instantiated yet. This Expr should be transformed to
+// a CallExpr once the kernel and its name is known.
+class UnresolvedSYCLKernelLaunchExpr : public Expr {
+  friend class ASTStmtReader;
+  QualType KernelNameType;
+  SourceLocation Loc;
+  // This is either UnresolvedLookupExpr or UnresolvedMemberExpr.
+  Expr *IdExpr = nullptr;
+  UnresolvedSYCLKernelLaunchExpr(SourceLocation L, QualType ExprTy,
+                                 QualType KNT, Expr *_IdExpr)
+      : Expr(UnresolvedSYCLKernelLaunchExprClass, ExprTy, VK_PRValue,
+             OK_Ordinary),
+        KernelNameType(KNT), Loc(L), IdExpr(_IdExpr) {
+    setDependence(computeDependence(this));
+  }
+
+  void setKernelNameType(QualType T) { KernelNameType = T; }
+  void setLocation(SourceLocation L) { Loc = L; }
+  void setIdExpr(Expr *Id) { IdExpr = Id; }
+
+public:
+  static UnresolvedSYCLKernelLaunchExpr *Create(const ASTContext &C,
+                                                QualType ExprTy, QualType KNT,
+                                                SourceLocation Loc,
+                                                Expr *IdExpr) {
+    return new (C) UnresolvedSYCLKernelLaunchExpr(Loc, ExprTy, KNT, IdExpr);
+  }
+
+  static UnresolvedSYCLKernelLaunchExpr *CreateEmpty(const ASTContext &C) {
+    return new (C)
+        UnresolvedSYCLKernelLaunchExpr({}, C.VoidTy, C.VoidTy, nullptr);
+  }
+
+  QualType getKernelNameType() const { return KernelNameType; }
+  Expr *getIdExpr() const { return IdExpr; }
+  SourceLocation getLocation() const { return Loc; }
+
+  SourceLocation getBeginLoc() const { return Loc; }
+  SourceLocation getEndLoc() const { return Loc; }
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == UnresolvedSYCLKernelLaunchExprClass;
+  }
+  // Iterators
+  child_range children() {
+    return child_range(child_iterator(), child_iterator());
+  }
+
+  const_child_range children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
+};
+
 } // end namespace clang
 
 #endif // LLVM_CLANG_AST_STMTSYCL_H

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -13015,6 +13015,15 @@ def err_sycl_entry_point_return_type : Error<
 def err_sycl_entry_point_deduced_return_type : Error<
   "the %0 attribute only applies to functions with a non-deduced 'void' return"
   " type">;
+def err_sycl_host_no_launch_function : Error<
+  "unable to find suitable 'sycl_enqueue_kernel_launch' function for host code "
+  "synthesis">;
+def warn_sycl_device_no_host_launch_function : Warning<
+  "unable to find suitable 'sycl_enqueue_kernel_launch' function for host code "
+  "synthesis">,
+  InGroup<DiagGroup<"sycl-host-launcher">>;
+def note_sycl_host_launch_function : Note<
+  "define 'sycl_enqueue_kernel_launch' function template to fix this problem">;
 
 def warn_cuda_maxclusterrank_sm_90 : Warning<
   "maxclusterrank requires sm_90 or higher, CUDA arch provided: %0, ignoring "

clang/include/clang/Basic/StmtNodes.td

@@ -59,6 +59,7 @@ def CoreturnStmt : StmtNode<Stmt>;
 def Expr : StmtNode<ValueStmt, 1>;
 def PredefinedExpr : StmtNode<Expr>;
 def SYCLUniqueStableNameExpr : StmtNode<Expr>;
+def UnresolvedSYCLKernelLaunchExpr : StmtNode<Expr>;
 def DeclRefExpr : StmtNode<Expr>;
 def IntegerLiteral : StmtNode<Expr>;
 def FixedPointLiteral : StmtNode<Expr>;

clang/include/clang/Sema/ScopeInfo.h

@@ -245,6 +245,8 @@ class FunctionScopeInfo {
   /// The set of GNU address of label extension "&&label".
   llvm::SmallVector<AddrLabelExpr *, 4> AddrLabels;
 
+  CompoundStmt *SYCLKernelLaunchStmt = nullptr;
+
 public:
   /// Represents a simple identification of a weak object.
   ///

clang/include/clang/Sema/SemaSYCL.h

@@ -66,7 +66,11 @@ class SemaSYCL : public SemaBase {
 
   void CheckSYCLExternalFunctionDecl(FunctionDecl *FD);
   void CheckSYCLEntryPointFunctionDecl(FunctionDecl *FD);
-  StmtResult BuildSYCLKernelCallStmt(FunctionDecl *FD, CompoundStmt *Body);
+  StmtResult BuildSYCLKernelCallStmt(FunctionDecl *FD, CompoundStmt *Body,
+                                     CompoundStmt *LaunchStmt);
+  CompoundStmt *BuildSYCLKernelLaunchStmt(FunctionDecl *FD, QualType KNT);
+  ExprResult createSYCLKernelLaunchCall(const SYCLKernelInfo *SKI, Expr *IdExpr,
+                                        SourceLocation Loc);
 };
 
 } // namespace clang

clang/include/clang/Serialization/ASTBitCodes.h

@@ -2040,6 +2040,9 @@ enum StmtCode {
   // SYCLUniqueStableNameExpr
   EXPR_SYCL_UNIQUE_STABLE_NAME,
 
+  // UnresolvedSYCLKernelName
+  EXPR_UNRESOLVED_SYCL_KERNEL_LAUNCH,
+
   // OpenACC Constructs/Exprs
   STMT_OPENACC_COMPUTE_CONSTRUCT,
   STMT_OPENACC_LOOP_CONSTRUCT,

clang/lib/AST/ComputeDependence.cpp

@@ -16,6 +16,7 @@
 #include "clang/AST/ExprConcepts.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExprOpenMP.h"
+#include "clang/AST/StmtSYCL.h"
 #include "clang/Basic/ExceptionSpecificationType.h"
 #include "llvm/ADT/ArrayRef.h"
 
@@ -634,6 +635,10 @@ ExprDependence clang::computeDependence(SYCLUniqueStableNameExpr *E) {
       E->getTypeSourceInfo()->getType()->getDependence());
 }
 
+ExprDependence clang::computeDependence(UnresolvedSYCLKernelLaunchExpr *E) {
+  return toExprDependenceAsWritten(E->getKernelNameType()->getDependence());
+}
+
 ExprDependence clang::computeDependence(PredefinedExpr *E) {
   return toExprDependenceForImpliedType(E->getType()->getDependence());
 }

clang/lib/AST/Expr.cpp

@@ -3697,6 +3697,7 @@ bool Expr::HasSideEffects(const ASTContext &Ctx,
   case PackIndexingExprClass:
   case HLSLOutArgExprClass:
   case OpenACCAsteriskSizeExprClass:
+  case UnresolvedSYCLKernelLaunchExprClass:
     // These never have a side-effect.
     return false;
 

clang/lib/AST/ExprConstant.cpp

@@ -17760,6 +17760,7 @@ static ICEDiag CheckICE(const Expr* E, const ASTContext &Ctx) {
   case Expr::DependentCoawaitExprClass:
   case Expr::CoyieldExprClass:
   case Expr::SYCLUniqueStableNameExprClass:
+  case Expr::UnresolvedSYCLKernelLaunchExprClass:
   case Expr::CXXParenListInitExprClass:
   case Expr::HLSLOutArgExprClass:
     return ICEDiag(IK_NotICE, E->getBeginLoc());

clang/lib/AST/ItaniumMangle.cpp

@@ -5019,6 +5019,7 @@ void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity,
   case Expr::AtomicExprClass:
   case Expr::SourceLocExprClass:
   case Expr::EmbedExprClass:
+  case Expr::UnresolvedSYCLKernelLaunchExprClass:
   case Expr::BuiltinBitCastExprClass: {
     NotPrimaryExpr();
     if (!NullOut) {

clang/lib/AST/StmtPrinter.cpp

@@ -1428,6 +1428,13 @@ void StmtPrinter::VisitSYCLUniqueStableNameExpr(
   OS << ")";
 }
 
+void StmtPrinter::VisitUnresolvedSYCLKernelLaunchExpr(
+    UnresolvedSYCLKernelLaunchExpr *Node) {
+  OS << "sycl_kernel_name(";
+  Node->getKernelNameType().print(OS, Policy);
+  OS << ")";
+}
+
 void StmtPrinter::VisitPredefinedExpr(PredefinedExpr *Node) {
   OS << PredefinedExpr::getIdentKindName(Node->getIdentKind());
 }

clang/lib/AST/StmtProfile.cpp

@@ -1374,6 +1374,11 @@ void StmtProfiler::VisitSYCLUniqueStableNameExpr(
   VisitType(S->getTypeSourceInfo()->getType());
 }
 
+void StmtProfiler::VisitUnresolvedSYCLKernelLaunchExpr(
+    const UnresolvedSYCLKernelLaunchExpr *S) {
+  VisitExpr(S);
+}
+
 void StmtProfiler::VisitPredefinedExpr(const PredefinedExpr *S) {
   VisitExpr(S);
   ID.AddInteger(llvm::to_underlying(S->getIdentKind()));

clang/lib/Sema/SemaDecl.cpp

@@ -15754,7 +15754,6 @@ Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D,
   if (!Bases.empty())
     OpenMP().ActOnFinishedFunctionDefinitionInOpenMPDeclareVariantScope(Dcl,
                                                                         Bases);
-
   return Dcl;
 }
 
@@ -16167,6 +16166,20 @@ Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D,
 
   maybeAddDeclWithEffects(FD);
 
+  if (FD && !FD->isInvalidDecl() &&
+      FD->hasAttr<SYCLKernelEntryPointAttr>() && FnBodyScope) {
+    // Building KernelLaunchStmt requires performing an unqualified lookup which
+    // can only be done correctly while the stack of parsing scopes is alive, so
+    // we do it here when we start parsing function body even if it is a
+    // templated function.
+    const auto *SKEPAttr = FD->getAttr<SYCLKernelEntryPointAttr>();
+    if (!SKEPAttr->isInvalidAttr()) {
+      CompoundStmt *LaunchStmt =
+          SYCL().BuildSYCLKernelLaunchStmt(FD, SKEPAttr->getKernelName());
+      getCurFunction()->SYCLKernelLaunchStmt = LaunchStmt;
+    }
+  }
+
   return D;
 }
 
@@ -16368,9 +16381,14 @@ Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body, bool IsInstantiation,
       SKEPAttr->setInvalidAttr();
     }
 
-    if (Body && !FD->isTemplated() && !SKEPAttr->isInvalidAttr()) {
-      StmtResult SR =
-          SYCL().BuildSYCLKernelCallStmt(FD, cast<CompoundStmt>(Body));
+    auto *BodyCompound = dyn_cast_or_null<CompoundStmt>(Body);
+    // If Body is not a compound, that was a templated function and we don't
+    // need to build SYCLKernelCallStmt for it since it was already created by
+    // template instantiator.
+    if (BodyCompound && !SKEPAttr->isInvalidAttr()) {
+      StmtResult SR = SYCL().BuildSYCLKernelCallStmt(
+          FD->isTemplated() ? nullptr : FD, BodyCompound,
+          getCurFunction()->SYCLKernelLaunchStmt);
       if (SR.isInvalid())
         return nullptr;
       Body = SR.get();

clang/lib/Sema/SemaExceptionSpec.cpp

@@ -1379,6 +1379,7 @@ CanThrowResult Sema::canThrow(const Stmt *S) {
   case Expr::UnaryExprOrTypeTraitExprClass:
   case Expr::UnresolvedLookupExprClass:
   case Expr::UnresolvedMemberExprClass:
+  case Expr::UnresolvedSYCLKernelLaunchExprClass:
     // FIXME: Many of the above can throw.
     return CT_Cannot;