Merge branch 'sycl' into sycl-free-function-illegal-types

Author: dklochkov-emb

.github/workflows/release-binaries.yml

@@ -301,7 +301,7 @@ jobs:
 
     - name: Attest Build Provenance
       id: provenance
-      uses: actions/attest-build-provenance@db473fddc028af60658334401dc6fa3ffd8669fd # v2.3.0
+      uses: actions/attest-build-provenance@e8998f949152b193b063cb0ec769d69d929409be # v2.4.0
       with:
         subject-path: ${{ needs.prepare.outputs.release-binary-filename }}
 

.github/workflows/release-sources.yml

@@ -92,7 +92,7 @@ jobs:
       - name: Attest Build Provenance
         if: github.event_name != 'pull_request'
         id: provenance
-        uses: actions/attest-build-provenance@db473fddc028af60658334401dc6fa3ffd8669fd # v2.3.0
+        uses: actions/attest-build-provenance@e8998f949152b193b063cb0ec769d69d929409be # v2.4.0
         with:
           subject-path: "*.xz"
       - if: github.event_name != 'pull_request'

clang/include/clang/Sema/SemaSYCL.h

@@ -265,6 +265,8 @@ class SemaSYCL : public SemaBase {
 
   llvm::DenseSet<const FunctionDecl *> SYCLKernelFunctions;
 
+  llvm::DenseSet<const FunctionDecl *> FreeFunctionDeclarations;
+
 public:
   SemaSYCL(Sema &S);
 
@@ -357,7 +359,9 @@ class SemaSYCL : public SemaBase {
   void ConstructOpenCLKernel(FunctionDecl *KernelCallerFunc, MangleContext &MC);
   void SetSYCLKernelNames();
   void MarkDevices();
+  void processFreeFunctionDeclaration(const FunctionDecl *FD);
   void ProcessFreeFunction(FunctionDecl *FD);
+  void finalizeFreeFunctionKernels();
 
   /// Get the number of fields or captures within the parsed type.
   ExprResult ActOnSYCLBuiltinNumFieldsExpr(ParsedType PT);

clang/lib/Basic/Targets.cpp

@@ -119,10 +119,6 @@ std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple,
     return nullptr;
 
   case llvm::Triple::UnknownArch:
-    // native_cpu is only known to Clang, not to LLVM.
-    if (Triple.str() == "native_cpu")
-      return std::make_unique<NativeCPUTargetInfo>(Triple, Opts);
-
     return nullptr;
 
   case llvm::Triple::arc:
@@ -843,6 +839,9 @@ std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple,
 
   case llvm::Triple::xtensa:
     return std::make_unique<XtensaTargetInfo>(Triple, Opts);
+
+  case llvm::Triple::native_cpu:
+    return std::make_unique<NativeCPUTargetInfo>(Triple, Opts);
   }
 }
 } // namespace targets

clang/lib/Driver/Driver.cpp

@@ -975,7 +975,10 @@ static bool isValidSYCLTriple(llvm::Triple T) {
     return true;
 
   // 'native_cpu' is valid for Native CPU.
-  if (isSYCLNativeCPU(T))
+  // TODO This checks for the exact spelling of the triple because other
+  // spellings would fail confusingly, trying to find nonexistent builtins. This
+  // should probably be done for NVidia and AMD too.
+  if (T.isNativeCPU() && T.str() == "native_cpu")
     return true;
 
   // Check for invalid SYCL device triple values.
@@ -5565,7 +5568,7 @@ class OffloadingActionBuilder final {
       auto IsAMDGCN = TargetTriple.isAMDGCN();
       auto IsSPIR = TargetTriple.isSPIROrSPIRV();
       bool IsSpirvAOT = TargetTriple.isSPIRAOT();
-      bool IsSYCLNativeCPU = isSYCLNativeCPU(TargetTriple);
+      bool IsNativeCPU = TargetTriple.isNativeCPU();
       for (const auto &Input : ListIndex) {
         // No need for any conversion if we are coming in from the
         // clang-offload-deps or regular compilation path.
@@ -5705,7 +5708,7 @@ class OffloadingActionBuilder final {
         // AOT compilation.
         bool SYCLDeviceLibLinked = false;
         Action *NativeCPULib = nullptr;
-        if (IsSPIR || IsNVPTX || IsAMDGCN || IsSYCLNativeCPU) {
+        if (IsSPIR || IsNVPTX || IsAMDGCN || IsNativeCPU) {
           bool UseJitLink =
               IsSPIR &&
               Args.hasFlag(options::OPT_fsycl_device_lib_jit_link,
@@ -5714,7 +5717,7 @@ class OffloadingActionBuilder final {
           SYCLDeviceLibLinked = addSYCLDeviceLibs(
               TC, SYCLDeviceLibs, UseAOTLink,
               C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment(),
-              IsSYCLNativeCPU, NativeCPULib, BoundArch);
+              IsNativeCPU, NativeCPULib, BoundArch);
         }
         JobAction *LinkSYCLLibs =
             C.MakeAction<LinkJobAction>(SYCLDeviceLibs, types::TY_LLVM_BC);
@@ -5781,11 +5784,11 @@ class OffloadingActionBuilder final {
 
           // reflects whether current target is ahead-of-time and can't
           // support runtime setting of specialization constants
-          bool IsAOT = IsNVPTX || IsAMDGCN || IsSpirvAOT || IsSYCLNativeCPU;
+          bool IsAOT = IsNVPTX || IsAMDGCN || IsSpirvAOT || IsNativeCPU;
 
           // post link is not optional - even if not splitting, always need to
           // process specialization constants
-          types::ID PostLinkOutType = IsSPIR || IsSYCLNativeCPU
+          types::ID PostLinkOutType = IsSPIR || IsNativeCPU
                                           ? types::TY_Tempfiletable
                                           : types::TY_LLVM_BC;
           auto createPostLinkAction = [&]() {
@@ -5796,7 +5799,7 @@ class OffloadingActionBuilder final {
             return TypedPostLinkAction;
           };
           Action *PostLinkAction = createPostLinkAction();
-          if (IsSYCLNativeCPU) {
+          if (IsNativeCPU) {
             if (NativeCPULib) {
               // The native cpu device lib is linked without --only-needed
               // as it contains builtins not referenced in source code but
@@ -9103,7 +9106,7 @@ InputInfoList Driver::BuildJobsForActionNoCache(
       Action::OffloadKind DependentOffloadKind;
       if (UI.DependentOffloadKind == Action::OFK_SYCL &&
           TargetDeviceOffloadKind == Action::OFK_None &&
-          !(isSYCLNativeCPU(C.getDefaultToolChain().getTriple()) &&
+          !(C.getDefaultToolChain().getTriple().isNativeCPU() &&
             UA->getDependentActionsInfo().size() > 1))
         DependentOffloadKind = Action::OFK_Host;
       else
@@ -10000,7 +10003,7 @@ const ToolChain &Driver::getOffloadToolChain(
                                                            *HostTC, Args, Kind);
       break;
     default:
-      if (Kind == Action::OFK_SYCL && isSYCLNativeCPU(Target))
+      if (Kind == Action::OFK_SYCL && Target.isNativeCPU())
         TC = std::make_unique<toolchains::SYCLToolChain>(*this, Target, *HostTC,
                                                          Args);
       break;

clang/lib/Driver/OffloadBundler.cpp

@@ -178,8 +178,7 @@ bool OffloadTargetInfo::isOffloadKindCompatible(
 }
 
 bool OffloadTargetInfo::isTripleValid() const {
-  return !Triple.str().empty() && (Triple.getArch() != Triple::UnknownArch ||
-                                   Triple.str() == "native_cpu---");
+  return !Triple.str().empty() && Triple.getArch() != Triple::UnknownArch;
 }
 
 bool OffloadTargetInfo::operator==(const OffloadTargetInfo &Target) const {

clang/lib/Driver/ToolChains/Clang.cpp

@@ -5560,8 +5560,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
   // Adjust for SYCL NativeCPU compilations.  When compiling in device mode, the
   // first compilation uses the NativeCPU target for LLVM IR generation, the
   // second compilation uses the host target for machine code generation.
-  const bool IsSYCLNativeCPU = isSYCLNativeCPU(Triple);
-  if (IsSYCL && IsSYCLDevice && IsSYCLNativeCPU && AuxTriple &&
+  if (IsSYCL && IsSYCLDevice && Triple.isNativeCPU() && AuxTriple &&
       isa<AssembleJobAction>(JA)) {
     Triple = *AuxTriple;
     TripleStr = Triple.getTriple();
@@ -5696,7 +5695,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
         CmdArgs.push_back("-mllvm");
         CmdArgs.push_back("-sycl-opt");
       }
-      if (IsSYCLNativeCPU) {
+      if (RawTriple.isNativeCPU()) {
         CmdArgs.push_back("-fsycl-is-native-cpu");
         CmdArgs.push_back("-D");
         CmdArgs.push_back("__SYCL_NATIVE_CPU__");
@@ -6077,14 +6076,14 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
         CmdArgs.push_back("-fdirectives-only");
     }
   } else if (isa<AssembleJobAction>(JA)) {
-    if (IsSYCLDevice && !IsSYCLNativeCPU) {
+    if (IsSYCLDevice && !RawTriple.isNativeCPU()) {
       CmdArgs.push_back("-emit-llvm-bc");
     } else {
       CmdArgs.push_back("-emit-obj");
       CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
     }
-    if (IsSYCLDevice && IsSYCLNativeCPU) {
-      // NativeCPU generates an initial LLVM module for an unknown target, then
+    if (IsSYCLDevice && RawTriple.isNativeCPU()) {
+      // NativeCPU generates an initial LLVM module for a dummy target, then
       // compiles that for host. Avoid generating a warning for that.
       CmdArgs.push_back("-Wno-override-module");
       CmdArgs.push_back("-mllvm");
@@ -10886,7 +10885,7 @@ static bool shouldEmitOnlyKernelsAsEntryPoints(const ToolChain &TC,
   if (TCArgs.hasFlag(options::OPT_fno_sycl_remove_unused_external_funcs,
                      options::OPT_fsycl_remove_unused_external_funcs, false))
     return false;
-  if (isSYCLNativeCPU(Triple))
+  if (Triple.isNativeCPU())
     return true;
   // When supporting dynamic linking, non-kernels in a device image can be
   // called.
@@ -10944,7 +10943,7 @@ static void getTripleBasedSYCLPostLinkOpts(const ToolChain &TC,
   if (!Triple.isAMDGCN())
     addArgs(PostLinkArgs, TCArgs, {"-emit-param-info"});
   // Enable program metadata
-  if (Triple.isNVPTX() || Triple.isAMDGCN() || isSYCLNativeCPU(Triple))
+  if (Triple.isNVPTX() || Triple.isAMDGCN() || Triple.isNativeCPU())
     addArgs(PostLinkArgs, TCArgs, {"-emit-program-metadata"});
   if (OutputType != types::TY_LLVM_BC) {
     assert(OutputType == types::TY_Tempfiletable);

clang/lib/Driver/ToolChains/SYCL.cpp

@@ -182,11 +182,9 @@ const char *SYCLInstallationDetector::findLibspirvPath(
   const SmallString<64> Basename =
       getLibSpirvBasename(DeviceTriple, HostTriple);
   auto searchAt = [&](StringRef Path, const Twine &a = "", const Twine &b = "",
-                      const Twine &c = "", const Twine &d = "",
-                      const Twine &e = "") -> const char * {
+                      const Twine &c = "") -> const char * {
     SmallString<128> LibraryPath(Path);
-    llvm::sys::path::append(LibraryPath, a, b, c, d);
-    llvm::sys::path::append(LibraryPath, e, Basename);
+    llvm::sys::path::append(LibraryPath, a, b, c, Basename);
 
     if (Args.hasArgNoClaim(options::OPT__HASH_HASH_HASH) ||
         llvm::sys::fs::exists(LibraryPath))
@@ -195,14 +193,15 @@ const char *SYCLInstallationDetector::findLibspirvPath(
     return nullptr;
   };
 
-  // Otherwise, assume libclc is installed at the same prefix as clang
-  // Expected path w/out install.
-  if (const char *R = searchAt(D.ResourceDir, "..", "..", "clc"))
-    return R;
+  for (const auto &IC : InstallationCandidates) {
+    // Expected path w/out install.
+    if (const char *R = searchAt(IC, "lib", "clc"))
+      return R;
 
-  // Expected path w/ install.
-  if (const char *R = searchAt(D.ResourceDir, "..", "..", "..", "share", "clc"))
-    return R;
+    // Expected path w/ install.
+    if (const char *R = searchAt(IC, "share", "clc"))
+      return R;
+  }
 
   return nullptr;
 }
@@ -838,7 +837,7 @@ SYCL::getDeviceLibraries(const Compilation &C, const llvm::Triple &TargetTriple,
     addSingleLibrary(SYCLDeviceTsanLibs[sanitizer_lib_idx]);
 #endif
 
-  if (isSYCLNativeCPU(TargetTriple))
+  if (TargetTriple.isNativeCPU())
     addLibraries(SYCLNativeCpuDeviceLibs);
 
   return LibraryList;
@@ -1016,7 +1015,7 @@ const char *SYCL::Linker::constructLLVMLinkCommand(
       const bool IsNVPTX = this->getToolChain().getTriple().isNVPTX();
       const bool IsAMDGCN = this->getToolChain().getTriple().isAMDGCN();
       const bool IsSYCLNativeCPU =
-          isSYCLNativeCPU(this->getToolChain().getTriple());
+          this->getToolChain().getTriple().isNativeCPU();
       StringRef LibPostfix = ".bc";
       StringRef NewLibPostfix = ".new.o";
       if (HostTC->getTriple().isWindowsMSVCEnvironment() &&
@@ -1160,7 +1159,7 @@ void SYCL::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   assert((getToolChain().getTriple().isSPIROrSPIRV() ||
           getToolChain().getTriple().isNVPTX() ||
           getToolChain().getTriple().isAMDGCN() ||
-          isSYCLNativeCPU(getToolChain().getTriple())) &&
+          getToolChain().getTriple().isNativeCPU()) &&
          "Unsupported target");
 
   std::string SubArchName =
@@ -1552,7 +1551,7 @@ static ArrayRef<options::ID> getUnsupportedOpts() {
 // Currently supported options by SYCL NativeCPU device compilation
 static inline bool SupportedByNativeCPU(const llvm::Triple &Triple,
                                         const OptSpecifier &Opt) {
-  if (!isSYCLNativeCPU(Triple))
+  if (!Triple.isNativeCPU())
     return false;
 
   switch (Opt.getID()) {
@@ -2001,7 +2000,7 @@ Tool *SYCLToolChain::buildBackendCompiler() const {
 }
 
 Tool *SYCLToolChain::buildLinker() const {
-  assert(getTriple().isSPIROrSPIRV() || isSYCLNativeCPU(getTriple()));
+  assert(getTriple().isSPIROrSPIRV() || getTriple().isNativeCPU());
   return new tools::SYCL::Linker(*this);
 }
 

clang/lib/Driver/ToolChains/SYCL.h

@@ -258,11 +258,6 @@ class LLVM_LIBRARY_VISIBILITY BackendCompiler : public Tool {
 } // end namespace SYCL
 } // end namespace tools
 
-inline bool isSYCLNativeCPU(const llvm::Triple &Triple) {
-  return Triple.getArch() == llvm::Triple::UnknownArch &&
-         Triple.str() == "native_cpu";
-}
-
 namespace toolchains {
 
 class LLVM_LIBRARY_VISIBILITY SYCLToolChain : public ToolChain {
@@ -303,12 +298,12 @@ class LLVM_LIBRARY_VISIBILITY SYCLToolChain : public ToolChain {
 
   bool useIntegratedAs() const override { return true; }
   bool isPICDefault() const override {
-    if (isSYCLNativeCPU(this->getTriple()))
+    if (this->getTriple().isNativeCPU())
       return this->HostTC.isPICDefault();
     return false;
   }
   llvm::codegenoptions::DebugInfoFormat getDefaultDebugFormat() const override {
-    if (isSYCLNativeCPU(this->getTriple()) &&
+    if (this->getTriple().isNativeCPU() &&
         this->HostTC.getTriple().isWindowsMSVCEnvironment())
       return this->HostTC.getDefaultDebugFormat();
     return ToolChain::getDefaultDebugFormat();

clang/lib/Sema/Sema.cpp

@@ -1250,6 +1250,7 @@ void Sema::ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind) {
   }
 
   if (getLangOpts().SYCLIsDevice) {
+    SYCL().finalizeFreeFunctionKernels();
     // Set the names of the kernels, now that the names have settled down. This
     // needs to happen before we generate the integration headers.
     SYCL().SetSYCLKernelNames();