Merge branch 'sycl' into refactorcache

Author: sergey-semenov

clang/include/clang/Basic/Attr.td

@@ -494,6 +494,7 @@ def TargetAnyX86 : TargetArch<["x86", "x86_64"]>;
 def TargetSPIRV : TargetArch<["spirv", "spirv32", "spirv64"]>;
 def TargetWebAssembly : TargetArch<["wasm32", "wasm64"]>;
 def TargetNVPTX : TargetArch<["nvptx", "nvptx64"]>;
+def TargetNativeCPU : TargetArch<["native_cpu"]>;
 def TargetWindows : TargetSpec {
   let OSes = ["Win32"];
 }
@@ -4530,6 +4531,11 @@ def RISCVVLSCC: DeclOrTypeAttr, TargetSpecificAttr<TargetRISCV> {
  let Documentation = [RISCVVLSCCDocs];
 }
 
+def NativeCPULibclcCall : DeclOrTypeAttr, TargetSpecificAttr<TargetNativeCPU> {
+  let Spellings = [Clang<"libclc_call", 0>];
+  let Documentation = [Undocumented];
+}
+
 def Target : InheritableAttr {
   let Spellings = [GCC<"target">];
   let Args = [StringArgument<"featuresStr">];

clang/include/clang/Basic/TargetInfo.h

@@ -1711,6 +1711,11 @@ class TargetInfo : public TransferrableTargetInfo,
     return CC_C;
   }
 
+  /// Gets the calling convention for libclc built-ins for the given target.
+  virtual CallingConv getLibclcCallingConv() const {
+    return getDefaultCallingConv();
+  }
+
   /// Get the default atomic options.
   AtomicOptions getAtomicOpts() const { return AtomicOpts; }
 

clang/include/clang/Driver/Options.td

@@ -5959,7 +5959,7 @@ def no_offloadlib
     : Flag<["--"], "no-offloadlib">,
       MarshallingInfoFlag<LangOpts<"NoGPULib">>,
       Visibility<[ClangOption, CC1Option, FlangOption, FC1Option]>,
-      HelpText<"Do not link device library for CUDA/HIP device compilation">;
+      HelpText<"Do not link device library for CUDA/HIP/SYCL device compilation">;
 def offloadlib : Flag<["--"], "offloadlib">,
                  Visibility<[ClangOption, CC1Option, FlangOption, FC1Option]>,
                  HelpText<"Link device libraries for GPU device compilation">;

clang/lib/AST/Type.cpp

@@ -4341,6 +4341,7 @@ bool AttributedType::isCallingConv() const {
   case attr::PreserveNone:
   case attr::RISCVVectorCC:
   case attr::RISCVVLSCC:
+  case attr::NativeCPULibclcCall:
     return true;
   }
   llvm_unreachable("invalid attr kind");

clang/lib/AST/TypePrinter.cpp

@@ -2125,6 +2125,9 @@ void TypePrinter::printAttributedAfter(const AttributedType *T,
   case attr::RISCVVLSCC:
     OS << "riscv_vls_cc";
     break;
+  case attr::NativeCPULibclcCall:
+    OS << "libclc_call";
+    break;
   case attr::NoDeref:
     OS << "noderef";
     break;

clang/lib/Basic/Targets/NativeCPU.h

@@ -49,7 +49,12 @@ class LLVM_LIBRARY_VISIBILITY NativeCPUTargetInfo final : public TargetInfo {
 
   void setSupportedOpenCLOpts() override { supportAllOpenCLOpts(); }
 
+  CallingConv getLibclcCallingConv() const override { return CC_SpirFunction; }
+
   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
+    if (CC == CC_SpirFunction)
+      return CCCR_OK;
+
     if (HostTarget)
       return HostTarget->checkCallingConvention(CC);
 

clang/lib/CodeGen/CGCall.cpp

@@ -334,6 +334,9 @@ static CallingConv getCallingConventionForDecl(const ObjCMethodDecl *D,
     }
   }
 
+  if (D->hasAttr<NativeCPULibclcCallAttr>())
+    return CC_SpirFunction;
+
   return CC_C;
 }
 

clang/lib/CodeGen/Targets/NativeCPU.cpp

@@ -20,6 +20,8 @@ class NativeCPUABIInfo : public DefaultABIInfo {
 public:
   NativeCPUABIInfo(CodeGen::CodeGenTypes &CGT, const ABIInfo *HostABIInfo)
       : DefaultABIInfo(CGT), HostABIInfo(HostABIInfo) {}
+
+  void computeInfo(CGFunctionInfo &FI) const override;
 };
 
 class NativeCPUTargetCodeGenInfo : public TargetCodeGenInfo {
@@ -37,6 +39,17 @@ class NativeCPUTargetCodeGenInfo : public TargetCodeGenInfo {
 };
 } // namespace
 
+void NativeCPUABIInfo::computeInfo(CGFunctionInfo &FI) const {
+  if (HostABIInfo &&
+      FI.getCallingConvention() != llvm::CallingConv::SPIR_FUNC) {
+    HostABIInfo->computeInfo(FI);
+    return;
+  }
+
+  DefaultABIInfo::computeInfo(FI);
+  FI.setEffectiveCallingConvention(llvm::CallingConv::C);
+}
+
 std::unique_ptr<TargetCodeGenInfo> CodeGen::createNativeCPUTargetCodeGenInfo(
     CodeGenModule &CGM,
     std::unique_ptr<TargetCodeGenInfo> HostTargetCodeGenInfo) {

clang/lib/Driver/Driver.cpp

@@ -5647,10 +5647,9 @@ class OffloadingActionBuilder final {
         } else
           FullLinkObjects = LinkObjects;
 
-        // FIXME: Link all wrapper and fallback device libraries as default,
-        // When spv online link is supported by all backends, the fallback
-        // device libraries are only needed when current toolchain is using
-        // AOT compilation.
+        // TODO: spv online link is deprecated and will be removed in the
+        // future, need to remove the logic handling jit link when the option
+        // is removed in compiler.
         bool SYCLDeviceLibLinked = false;
         Action *NativeCPULib = nullptr;
         if (IsSPIR || IsNVPTX || IsAMDGCN || IsNativeCPU) {

clang/lib/Driver/ToolChains/SYCL.cpp

@@ -434,9 +434,7 @@ addSYCLDeviceSanitizerLibs(const Compilation &C, bool IsSpirvAOT,
   const llvm::opt::ArgList &Args = C.getArgs();
   enum { JIT = 0, AOT_CPU, AOT_DG2, AOT_PVC };
   auto addSingleLibrary = [&](StringRef DeviceLibName) {
-    SmallString<128> LibName(DeviceLibName);
-    llvm::sys::path::replace_extension(LibName, LibSuffix);
-    LibraryList.push_back(Args.MakeArgString(LibName));
+    LibraryList.push_back(Args.MakeArgString(Twine(DeviceLibName) + LibSuffix));
   };
 
   // This function is used to check whether there is only one GPU device
@@ -561,8 +559,13 @@ addSYCLDeviceSanitizerLibs(const Compilation &C, bool IsSpirvAOT,
 }
 #endif
 
-SmallVector<std::string, 8>
-SYCL::getDeviceLibraries(const Compilation &C, const llvm::Triple &TargetTriple,
+// Get the list of SYCL device libraries to link with user's device image if
+// some deprecated options are used including: -f[no-]sycl-device-lib=xxx,
+// -f[no-]sycl-device-lib-jit-link.
+// TODO: remove getDeviceLibrariesLegacy when we remove deprecated options
+// related to sycl device library link.
+static SmallVector<std::string, 8>
+getDeviceLibrariesLegacy(const Compilation &C, const llvm::Triple &TargetTriple,
                          bool IsSpirvAOT) {
   SmallVector<std::string, 8> LibraryList;
   const llvm::opt::ArgList &Args = C.getArgs();
@@ -740,6 +743,111 @@ SYCL::getDeviceLibraries(const Compilation &C, const llvm::Triple &TargetTriple,
   return LibraryList;
 }
 
+// Get the list of SYCL device libraries to link with user's device image.
+SmallVector<std::string, 8>
+SYCL::getDeviceLibraries(const Compilation &C, const llvm::Triple &TargetTriple,
+                         bool IsSpirvAOT) {
+  SmallVector<std::string, 8> LibraryList;
+  const llvm::opt::ArgList &Args = C.getArgs();
+  if (Args.getLastArg(options::OPT_fsycl_device_lib_EQ,
+                      options::OPT_fno_sycl_device_lib_EQ) ||
+      Args.getLastArg(options::OPT_fsycl_device_lib_jit_link,
+                      options::OPT_fno_sycl_device_lib_jit_link))
+    return getDeviceLibrariesLegacy(C, TargetTriple, IsSpirvAOT);
+
+  bool NoOffloadLib =
+      !Args.hasFlag(options::OPT_offloadlib, options::OPT_no_offloadlib, true);
+  if (TargetTriple.isNVPTX()) {
+    if (!NoOffloadLib)
+      LibraryList.push_back(
+          Args.MakeArgString("devicelib-nvptx64-nvidia-cuda.bc"));
+    return LibraryList;
+  }
+
+  if (TargetTriple.isAMDGCN()) {
+    if (!NoOffloadLib)
+      LibraryList.push_back(
+          Args.MakeArgString("devicelib-amdgcn-amd-amdhsa.bc"));
+    return LibraryList;
+  }
+
+  // Ignore no-offloadlib for NativeCPU device library, it provides some
+  // critical builtins which must be linked with user's device image.
+  if (TargetTriple.isNativeCPU()) {
+    LibraryList.push_back(Args.MakeArgString("libsycl-nativecpu_utils.bc"));
+    return LibraryList;
+  }
+
+  using SYCLDeviceLibsList = SmallVector<StringRef>;
+  const SYCLDeviceLibsList SYCLDeviceLibs = {"libsycl-crt",
+                                             "libsycl-complex",
+                                             "libsycl-complex-fp64",
+                                             "libsycl-cmath",
+                                             "libsycl-cmath-fp64",
+#if defined(_WIN32)
+                                             "libsycl-msvc-math",
+#endif
+                                             "libsycl-imf",
+                                             "libsycl-imf-fp64",
+                                             "libsycl-imf-bf16",
+                                             "libsycl-fallback-cassert",
+                                             "libsycl-fallback-cstring",
+                                             "libsycl-fallback-complex",
+                                             "libsycl-fallback-complex-fp64",
+                                             "libsycl-fallback-cmath",
+                                             "libsycl-fallback-cmath-fp64",
+                                             "libsycl-fallback-imf",
+                                             "libsycl-fallback-imf-fp64",
+                                             "libsycl-fallback-imf-bf16"};
+  bool IsWindowsMSVCEnv =
+      C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
+  bool IsNewOffload = C.getDriver().getUseNewOffloadingDriver();
+  StringRef LibSuffix = ".bc";
+  if (IsNewOffload)
+    // For new offload model, we use packaged .bc files.
+    LibSuffix = IsWindowsMSVCEnv ? ".new.obj" : ".new.o";
+  auto addLibraries = [&](const SYCLDeviceLibsList &LibsList) {
+    for (const StringRef &Lib : LibsList) {
+      LibraryList.push_back(Args.MakeArgString(Twine(Lib) + LibSuffix));
+    }
+  };
+
+  if (!NoOffloadLib)
+    addLibraries(SYCLDeviceLibs);
+
+  // ITT annotation libraries are linked in separately whenever the device
+  // code instrumentation is enabled.
+  const SYCLDeviceLibsList SYCLDeviceAnnotationLibs = {
+      "libsycl-itt-user-wrappers", "libsycl-itt-compiler-wrappers",
+      "libsycl-itt-stubs"};
+  if (Args.hasFlag(options::OPT_fsycl_instrument_device_code,
+                   options::OPT_fno_sycl_instrument_device_code, true))
+    addLibraries(SYCLDeviceAnnotationLibs);
+
+  const SYCLDeviceLibsList SYCLDeviceBfloat16FallbackLib = {
+      "libsycl-fallback-bfloat16"};
+  const SYCLDeviceLibsList SYCLDeviceBfloat16NativeLib = {
+      "libsycl-native-bfloat16"};
+  bool NativeBfloatLibs;
+  bool NeedBfloatLibs = selectBfloatLibs(TargetTriple, C, NativeBfloatLibs);
+  if (NeedBfloatLibs && !NoOffloadLib) {
+    // Add native or fallback bfloat16 library.
+    if (NativeBfloatLibs)
+      addLibraries(SYCLDeviceBfloat16NativeLib);
+    else
+      addLibraries(SYCLDeviceBfloat16FallbackLib);
+  }
+
+  // Currently, device sanitizer support is required by some developers on
+  // Linux platform only, so compiler only provides device sanitizer libraries
+  // on Linux platform.
+#if !defined(_WIN32)
+  addSYCLDeviceSanitizerLibs(C, IsSpirvAOT, LibSuffix, LibraryList);
+#endif
+
+  return LibraryList;
+}
+
 /// Reads device config file to find information about the SYCL targets in
 /// `Targets`, and defines device traits macros accordingly.
 void SYCL::populateSYCLDeviceTraitsMacrosArgs(