Merge from 'sycl' to 'sycl-web'

Author: iclsrc

buildbot/dependency.conf

@@ -3,8 +3,8 @@
 ocl_cpu_rt_ver=2020.10.4.0.15
 # https://github.com/intel/llvm/releases/download/2020-03/win-oclcpuexp-2020.10.4.0.15_rel.zip
 ocl_cpu_rt_ver_win=2020.10.4.0.15
-# https://github.com/intel/compute-runtime/releases/tag/20.12.16259
-ocl_gpu_rt_ver=l0-20.12.16259
+# https://github.com/intel/compute-runtime/releases/tag/20.19.16754
+ocl_gpu_rt_ver=20.19.16754
 # https://downloadcenter.intel.com/download/29557/Intel-Graphics-Windows-10-DCH-Drivers
 ocl_gpu_rt_ver_win=ci-neo-015900
 intel_sycl_ver=build
@@ -20,7 +20,7 @@ fpga_ver_win=20200216_000000
 [DRIVER VERSIONS]
 cpu_driver_lin=2020.10.4.0.15
 cpu_driver_win=2020.10.4.0.15
-gpu_driver_lin=20.12.16259
+gpu_driver_lin=20.19.16754
 gpu_driver_win=ci-neo-015900
 fpga_driver_lin=2020.9.2.0
 fpga_driver_win=2020.9.2.0

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -10816,7 +10816,6 @@ def err_sycl_restrict : Error<
   "}0">;
 def err_sycl_virtual_types : Error<
   "No class with a vtable can be used in a SYCL kernel or any code included in the kernel">;
-def note_sycl_used_here : Note<"used here">;
 def note_sycl_recursive_function_declared_here: Note<"function implemented using recursion declared here">;
 def err_sycl_non_trivially_copy_ctor_dtor_type
     : Error<"kernel parameter has non-trivially %select{copy "

clang/include/clang/Sema/Sema.h

@@ -319,7 +319,8 @@ class SYCLIntegrationHeader {
   };
 
 public:
-  SYCLIntegrationHeader(DiagnosticsEngine &Diag, bool UnnamedLambdaSupport);
+  SYCLIntegrationHeader(DiagnosticsEngine &Diag, bool UnnamedLambdaSupport,
+                        Sema &S);
 
   /// Emits contents of the header into given stream.
   void emit(raw_ostream &Out);
@@ -424,6 +425,8 @@ class SYCLIntegrationHeader {
 
   /// Whether header is generated with unnamed lambda support
   bool UnnamedLambdaSupport;
+
+  Sema &S;
 };
 
 /// Keeps track of expected type during expression parsing. The type is tied to
@@ -12588,7 +12591,7 @@ class Sema final {
   SYCLIntegrationHeader &getSyclIntegrationHeader() {
     if (SyclIntHeader == nullptr)
       SyclIntHeader = std::make_unique<SYCLIntegrationHeader>(
-          getDiagnostics(), getLangOpts().SYCLUnnamedLambda);
+          getDiagnostics(), getLangOpts().SYCLUnnamedLambda, *this);
     return *SyclIntHeader.get();
   }
 

clang/lib/CodeGen/CGSYCLRuntime.cpp

@@ -20,6 +20,8 @@
 using namespace clang;
 using namespace CodeGen;
 
+namespace {
+
 /// Various utilities.
 /// TODO partially duplicates functionality from SemaSYCL.cpp, can be shared.
 class Util {
@@ -52,6 +54,8 @@ const char *WG_SCOPE_MD_ID = "work_group_scope";
 const char *WI_SCOPE_MD_ID = "work_item_scope";
 const char *PFWI_MD_ID = "parallel_for_work_item";
 
+} // anonymous namespace
+
 bool CGSYCLRuntime::actOnFunctionStart(const FunctionDecl &FD,
                                        llvm::Function &F) {
   SYCLScopeAttr *Scope = FD.getAttr<SYCLScopeAttr>();

clang/lib/Driver/Driver.cpp

@@ -3549,12 +3549,21 @@ class OffloadingActionBuilder final {
           for (auto SDA : SYCLDeviceActions)
             SYCLLinkBinaryList.push_back(SDA);
           if (WrapDeviceOnlyBinary) {
-            auto *DeviceLinkAction =
-              C.MakeAction<LinkJobAction>(SYCLLinkBinaryList, types::TY_Image);
-            // Wrap the binary when -fsycl-link is given
-            SYCLLinkBinary =
-                C.MakeAction<OffloadWrapperJobAction>(DeviceLinkAction,
-                                                      types::TY_Object);
+            // -fsycl-link behavior does the following to the unbundled device
+            // binaries:
+            //   1) Link them together using llvm-link
+            //   2) Pass the linked binary through sycl-post-link
+            //   3) Translate final .bc file to .spv
+            //   4) Wrap the binary with the offload wrapper which can be used
+            //      by any compilation link step.
+            auto *DeviceLinkAction = C.MakeAction<LinkJobAction>(
+                SYCLLinkBinaryList, types::TY_Image);
+            auto *PostLinkAction = C.MakeAction<SYCLPostLinkJobAction>(
+                DeviceLinkAction, types::TY_LLVM_BC);
+            auto *TranslateAction = C.MakeAction<SPIRVTranslatorJobAction>(
+                PostLinkAction, types::TY_Image);
+            SYCLLinkBinary = C.MakeAction<OffloadWrapperJobAction>(
+                TranslateAction, types::TY_Object);
           } else {
             auto *Link = C.MakeAction<LinkJobAction>(SYCLLinkBinaryList,
                                                          types::TY_Image);

clang/lib/Sema/SemaSYCL.cpp

@@ -54,6 +54,8 @@ enum KernelInvocationKind {
 const static std::string InitMethodName = "__init";
 const static std::string FinalizeMethodName = "__finalize";
 
+namespace {
+
 /// Various utilities.
 class Util {
 public:
@@ -91,6 +93,8 @@ class Util {
                                      ArrayRef<Util::DeclContextDesc> Scopes);
 };
 
+} // anonymous namespace
+
 // This information is from Section 4.13 of the SYCL spec
 // https://www.khronos.org/registry/SYCL/specs/sycl-1.2.1.pdf
 // This function returns false if the math lib function
@@ -206,19 +210,9 @@ static bool isZeroSizedArray(QualType Ty) {
   return false;
 }
 
-static Sema::DeviceDiagBuilder
-emitDeferredDiagnosticAndNote(Sema &S, SourceRange Loc, unsigned DiagID,
-                              SourceRange UsedAtLoc) {
-  Sema::DeviceDiagBuilder builder =
-      S.SYCLDiagIfDeviceCode(Loc.getBegin(), DiagID);
-  if (UsedAtLoc.isValid())
-    S.SYCLDiagIfDeviceCode(UsedAtLoc.getBegin(), diag::note_sycl_used_here);
-  return builder;
-}
-
-static void checkSYCLVarType(Sema &S, QualType Ty, SourceRange Loc,
-                             llvm::DenseSet<QualType> Visited,
-                             SourceRange UsedAtLoc = SourceRange()) {
+static void checkSYCLType(Sema &S, QualType Ty, SourceRange Loc,
+                          llvm::DenseSet<QualType> Visited,
+                          SourceRange UsedAtLoc = SourceRange()) {
   // Not all variable types are supported inside SYCL kernels,
   // for example the quad type __float128 will cause errors in the
   // SPIR-V translation phase.
@@ -229,16 +223,21 @@ static void checkSYCLVarType(Sema &S, QualType Ty, SourceRange Loc,
   // different location than the variable declaration and we need to
   // inform the user of both, e.g. struct member usage vs declaration.
 
+  bool Emitting = false;
+
   //--- check types ---
 
   // zero length arrays
-  if (isZeroSizedArray(Ty))
-    emitDeferredDiagnosticAndNote(S, Loc, diag::err_typecheck_zero_array_size,
-                                  UsedAtLoc);
+  if (isZeroSizedArray(Ty)) {
+    S.SYCLDiagIfDeviceCode(Loc.getBegin(), diag::err_typecheck_zero_array_size);
+    Emitting = true;
+  }
 
   // variable length arrays
-  if (Ty->isVariableArrayType())
-    emitDeferredDiagnosticAndNote(S, Loc, diag::err_vla_unsupported, UsedAtLoc);
+  if (Ty->isVariableArrayType()) {
+    S.SYCLDiagIfDeviceCode(Loc.getBegin(), diag::err_vla_unsupported);
+    Emitting = true;
+  }
 
   // Sub-reference array or pointer, then proceed with that type.
   while (Ty->isAnyPointerType() || Ty->isArrayType())
@@ -249,9 +248,14 @@ static void checkSYCLVarType(Sema &S, QualType Ty, SourceRange Loc,
       Ty->isSpecificBuiltinType(BuiltinType::UInt128) ||
       Ty->isSpecificBuiltinType(BuiltinType::LongDouble) ||
       (Ty->isSpecificBuiltinType(BuiltinType::Float128) &&
-       !S.Context.getTargetInfo().hasFloat128Type()))
-    emitDeferredDiagnosticAndNote(S, Loc, diag::err_type_unsupported, UsedAtLoc)
+       !S.Context.getTargetInfo().hasFloat128Type())) {
+    S.SYCLDiagIfDeviceCode(Loc.getBegin(), diag::err_type_unsupported)
         << Ty.getUnqualifiedType().getCanonicalType();
+    Emitting = true;
+  }
+
+  if (Emitting && UsedAtLoc.isValid())
+    S.SYCLDiagIfDeviceCode(UsedAtLoc.getBegin(), diag::note_used_here);
 
   //--- now recurse ---
   // Pointers complicate recursion. Add this type to Visited.
@@ -260,16 +264,15 @@ static void checkSYCLVarType(Sema &S, QualType Ty, SourceRange Loc,
     return;
 
   if (const auto *ATy = dyn_cast<AttributedType>(Ty))
-    return checkSYCLVarType(S, ATy->getModifiedType(), Loc, Visited);
+    return checkSYCLType(S, ATy->getModifiedType(), Loc, Visited);
 
   if (const auto *RD = Ty->getAsRecordDecl()) {
     for (const auto &Field : RD->fields())
-      checkSYCLVarType(S, Field->getType(), Field->getSourceRange(), Visited,
-                       Loc);
+      checkSYCLType(S, Field->getType(), Field->getSourceRange(), Visited, Loc);
   } else if (const auto *FPTy = dyn_cast<FunctionProtoType>(Ty)) {
     for (const auto &ParamTy : FPTy->param_types())
-      checkSYCLVarType(S, ParamTy, Loc, Visited);
-    checkSYCLVarType(S, FPTy->getReturnType(), Loc, Visited);
+      checkSYCLType(S, ParamTy, Loc, Visited);
+    checkSYCLType(S, FPTy->getReturnType(), Loc, Visited);
   }
 }
 
@@ -280,7 +283,7 @@ void Sema::checkSYCLDeviceVarDecl(VarDecl *Var) {
   SourceRange Loc = Var->getLocation();
   llvm::DenseSet<QualType> Visited;
 
-  checkSYCLVarType(*this, Ty, Loc, Visited);
+  checkSYCLType(*this, Ty, Loc, Visited);
 }
 
 class MarkDeviceFunction : public RecursiveASTVisitor<MarkDeviceFunction> {
@@ -801,6 +804,22 @@ class SyclKernelFieldChecker
   bool IsInvalid = false;
   DiagnosticsEngine &Diag;
 
+  void checkAccessorType(QualType Ty, SourceRange Loc) {
+    assert(Util::isSyclAccessorType(Ty) &&
+           "Should only be called on SYCL accessor types.");
+
+    const RecordDecl *RecD = Ty->getAsRecordDecl();
+    if (const ClassTemplateSpecializationDecl *CTSD =
+            dyn_cast<ClassTemplateSpecializationDecl>(RecD)) {
+      const TemplateArgumentList &TAL = CTSD->getTemplateArgs();
+      TemplateArgument TA = TAL.get(0);
+      const QualType TemplateArgTy = TA.getAsType();
+
+      llvm::DenseSet<QualType> Visited;
+      checkSYCLType(SemaRef, TemplateArgTy, Loc, Visited);
+    }
+  }
+
 public:
   SyclKernelFieldChecker(Sema &S)
       : SyclKernelFieldHandler(S), Diag(S.getASTContext().getDiagnostics()) {}
@@ -832,6 +851,15 @@ class SyclKernelFieldChecker
     }
   }
 
+  void handleSyclAccessorType(const CXXBaseSpecifier &BS,
+                              QualType FieldTy) final {
+    checkAccessorType(FieldTy, BS.getBeginLoc());
+  }
+
+  void handleSyclAccessorType(FieldDecl *FD, QualType FieldTy) final {
+    checkAccessorType(FieldTy, FD->getLocation());
+  }
+
   // We should be able to handle this, so we made it part of the visitor, but
   // this is 'to be implemented'.
   void handleArrayType(FieldDecl *FD, QualType FieldTy) final {
@@ -1454,7 +1482,6 @@ void Sema::ConstructOpenCLKernel(FunctionDecl *KernelCallerFunc,
 }
 
 void Sema::MarkDevice(void) {
-  // Let's mark all called functions with SYCL Device attribute.
   // Create the call graph so we can detect recursion and check the validity
   // of new operator overrides. Add the kernel function itself in case
   // it is recursive.
@@ -1540,7 +1567,9 @@ Sema::DeviceDiagBuilder Sema::SYCLDiagIfDeviceCode(SourceLocation Loc,
          "Should only be called during SYCL compilation");
   FunctionDecl *FD = dyn_cast<FunctionDecl>(getCurLexicalContext());
   DeviceDiagBuilder::Kind DiagKind = [this, FD] {
-    if (ConstructingOpenCLKernel || !FD)
+    if (ConstructingOpenCLKernel)
+      return DeviceDiagBuilder::K_ImmediateWithCallStack;
+    if (!FD)
       return DeviceDiagBuilder::K_Nop;
     if (getEmissionStatus(FD) == Sema::FunctionEmissionStatus::Emitted)
       return DeviceDiagBuilder::K_ImmediateWithCallStack;
@@ -1863,6 +1892,9 @@ static void printArguments(ASTContext &Ctx, raw_ostream &ArgOS,
                            ArrayRef<TemplateArgument> Args,
                            const PrintingPolicy &P);
 
+static std::string getKernelNameTypeString(QualType T, ASTContext &Ctx,
+                                           const PrintingPolicy &TypePolicy);
+
 static void printArgument(ASTContext &Ctx, raw_ostream &ArgOS,
                           TemplateArgument Arg, const PrintingPolicy &P) {
   switch (Arg.getKind()) {
@@ -1888,8 +1920,7 @@ static void printArgument(ASTContext &Ctx, raw_ostream &ArgOS,
     TypePolicy.SuppressTypedefs = true;
     TypePolicy.SuppressTagKeyword = true;
     QualType T = Arg.getAsType();
-    QualType FullyQualifiedType = TypeName::getFullyQualifiedType(T, Ctx, true);
-    ArgOS << FullyQualifiedType.getAsString(TypePolicy);
+    ArgOS << getKernelNameTypeString(T, Ctx, TypePolicy);
     break;
   }
   default:
@@ -1903,6 +1934,10 @@ static void printArguments(ASTContext &Ctx, raw_ostream &ArgOS,
   for (unsigned I = 0; I < Args.size(); I++) {
     const TemplateArgument &Arg = Args[I];
 
+    // If argument is an empty pack argument, skip printing comma and argument.
+    if (Arg.getKind() == TemplateArgument::ArgKind::Pack && !Arg.pack_size())
+      continue;
+
     if (I != 0)
       ArgOS << ", ";
 
@@ -1918,36 +1953,36 @@ static void printTemplateArguments(ASTContext &Ctx, raw_ostream &ArgOS,
   ArgOS << ">";
 }
 
-static std::string getKernelNameTypeString(QualType T) {
+static std::string getKernelNameTypeString(QualType T, ASTContext &Ctx,
+                                           const PrintingPolicy &TypePolicy) {
+
+  QualType FullyQualifiedType = TypeName::getFullyQualifiedType(T, Ctx, true);
 
   const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
 
   if (!RD)
-    return getCPPTypeString(T);
+    return eraseAnonNamespace(FullyQualifiedType.getAsString(TypePolicy));
 
   // If kernel name type is a template specialization with enum type
   // template parameters, enumerators in name type string should be
   // replaced  with their underlying value since the enum definition
   // is not visible in integration header.
   if (const auto *TSD = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
-    LangOptions LO;
-    PrintingPolicy P(LO);
-    P.SuppressTypedefs = true;
     SmallString<64> Buf;
     llvm::raw_svector_ostream ArgOS(Buf);
 
     // Print template class name
-    TSD->printQualifiedName(ArgOS, P, /*WithGlobalNsPrefix*/ true);
+    TSD->printQualifiedName(ArgOS, TypePolicy, /*WithGlobalNsPrefix*/ true);
 
     // Print template arguments substituting enumerators
     ASTContext &Ctx = RD->getASTContext();
     const TemplateArgumentList &Args = TSD->getTemplateArgs();
-    printTemplateArguments(Ctx, ArgOS, Args.asArray(), P);
+    printTemplateArguments(Ctx, ArgOS, Args.asArray(), TypePolicy);
 
     return eraseAnonNamespace(ArgOS.str().str());
   }
 
-  return getCPPTypeString(T);
+  return eraseAnonNamespace(FullyQualifiedType.getAsString(TypePolicy));
 }
 
 void SYCLIntegrationHeader::emit(raw_ostream &O) {
@@ -2066,9 +2101,11 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
         O << "', '" << c;
       O << "'> {\n";
     } else {
-
+      LangOptions LO;
+      PrintingPolicy P(LO);
+      P.SuppressTypedefs = true;
       O << "template <> struct KernelInfo<"
-        << getKernelNameTypeString(K.NameType) << "> {\n";
+        << getKernelNameTypeString(K.NameType, S.getASTContext(), P) << "> {\n";
     }
     O << "  DLL_LOCAL\n";
     O << "  static constexpr const char* getName() { return \"" << K.Name
@@ -2137,8 +2174,9 @@ void SYCLIntegrationHeader::addSpecConstant(StringRef IDName, QualType IDType) {
 }
 
 SYCLIntegrationHeader::SYCLIntegrationHeader(DiagnosticsEngine &_Diag,
-                                             bool _UnnamedLambdaSupport)
-    : Diag(_Diag), UnnamedLambdaSupport(_UnnamedLambdaSupport) {}
+                                             bool _UnnamedLambdaSupport,
+                                             Sema &_S)
+    : Diag(_Diag), UnnamedLambdaSupport(_UnnamedLambdaSupport), S(_S) {}
 
 // -----------------------------------------------------------------------------
 // Utility class methods