[SYCL] Embed required fallback spv into final exeutable

clang/lib/Driver/ToolChains/Clang.cpp

@@ -10952,6 +10952,7 @@ static void getNonTripleBasedSYCLPostLinkOpts(const ToolChain &TC,
                                               const JobAction &JA,
                                               const llvm::opt::ArgList &TCArgs,
                                               ArgStringList &PostLinkArgs) {
+
   // See if device code splitting is requested
   if (Arg *A = TCArgs.getLastArg(options::OPT_fsycl_device_code_split_EQ)) {
     auto CodeSplitValue = StringRef(A->getValue());
@@ -10977,6 +10978,39 @@ static void getNonTripleBasedSYCLPostLinkOpts(const ToolChain &TC,
 
   if (allowDeviceImageDependencies(TCArgs))
     addArgs(PostLinkArgs, TCArgs, {"-allow-device-image-dependencies"});
+
+  bool DeviceLibDisable = false;
+  Arg *DeviceLibArg = TCArgs.getLastArg(options::OPT_fsycl_device_lib_EQ,
+                                        options::OPT_fno_sycl_device_lib_EQ);
+  if (DeviceLibArg &&
+      DeviceLibArg->getOption().matches(options::OPT_fno_sycl_device_lib_EQ)) {
+    for (StringRef Val : DeviceLibArg->getValues()) {
+      if (Val == "all") {
+        DeviceLibDisable = true;
+        break;
+      }
+    }
+  }
+
+  // Fallback spv is NOT involved in AOT compilation or
+  // '-fno-sycl-device-lib=all' is applied by user explicitly.
+  if (TC.getTriple().isSPIROrSPIRV() && !TC.getTriple().isSPIRAOT() &&
+      !DeviceLibDisable) {
+    SYCLInstallationDetector SYCLInstall(TC.getDriver());
+    SmallVector<SmallString<128>, 4> DeviceLibLocCandidates;
+    SmallString<128> FallbackAssertName("libsycl-fallback-cassert.bc");
+    SYCLInstall.getSYCLDeviceLibPath(DeviceLibLocCandidates);
+    for (const auto &DeviceLibLoc : DeviceLibLocCandidates) {
+      SmallString<128> FullLibName(DeviceLibLoc);
+      llvm::sys::path::append(FullLibName, FallbackAssertName);
+      if (llvm::sys::fs::exists(FullLibName)) {
+        SmallString<128> SYCLDeviceLibDir("--device-lib-dir=");
+        SYCLDeviceLibDir += DeviceLibLoc.str();
+        addArgs(PostLinkArgs, TCArgs, {SYCLDeviceLibDir.str()});
+        break;
+      }
+    }
+  }
 }
 
 // On Intel targets we don't need non-kernel functions as entry points,

clang/test/Driver/sycl-post-link-options-win.cpp

@@ -3,7 +3,7 @@
 // RUN: %clangxx -### --target=x86_64-pc-windows-msvc -fsycl \
 // RUN:          -Xdevice-post-link -O0 %s 2>&1 \
 // RUN:   | FileCheck -check-prefix OPTIONS_POSTLINK_JIT_OLD %s
-// OPTIONS_POSTLINK_JIT_OLD: sycl-post-link{{.*}} "-O2" "-device-globals" "-properties" "-spec-const=native" "-split=auto" "-emit-only-kernels-as-entry-points" "-emit-param-info" "-symbols" "-emit-exported-symbols" "-emit-imported-symbols" "-split-esimd" "-lower-esimd" "-O0"
+// OPTIONS_POSTLINK_JIT_OLD: sycl-post-link{{.*}} "-O2" "-device-globals" "--device-lib-dir={{.*}}" "-properties" "-spec-const=native" "-split=auto" "-emit-only-kernels-as-entry-points" "-emit-param-info" "-symbols" "-emit-exported-symbols" "-emit-imported-symbols" "-split-esimd" "-lower-esimd" "-O0"
 // -------
 // Generate .o file as linker wrapper input.
 //

clang/test/Driver/sycl-post-link-options.cpp

@@ -3,7 +3,7 @@
 // RUN: %clangxx --target=x86_64-unknown-linux-gnu -fsycl -### \
 // RUN:          --no-offload-new-driver -Xdevice-post-link -O0 %s 2>&1 \
 // RUN:   | FileCheck -check-prefix OPTIONS_POSTLINK_JIT_OLD %s
-// OPTIONS_POSTLINK_JIT_OLD: sycl-post-link{{.*}} "-O2" "-device-globals" "-properties" "-spec-const=native" "-split=auto" "-emit-only-kernels-as-entry-points" "-emit-param-info" "-symbols" "-emit-exported-symbols" "-emit-imported-symbols" "-split-esimd" "-lower-esimd" "-O0"
+// OPTIONS_POSTLINK_JIT_OLD: sycl-post-link{{.*}} "-O2" "-device-globals" "--device-lib-dir={{.*}}" "-properties" "-spec-const=native" "-split=auto" "-emit-only-kernels-as-entry-points" "-emit-param-info" "-symbols" "-emit-exported-symbols" "-emit-imported-symbols" "-split-esimd" "-lower-esimd" "-O0"
 //
 // Generate .o file as linker wrapper input.
 //

clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp

@@ -726,6 +726,16 @@ runSYCLPostLinkTool(ArrayRef<StringRef> InputFiles, const ArgList &Args) {
   SmallVector<StringRef, 8> CmdArgs;
   CmdArgs.push_back(*SYCLPostLinkPath);
   const llvm::Triple Triple(Args.getLastArgValue(OPT_triple_EQ));
+  Arg *SYCLDeviceLibLoc = Args.getLastArg(OPT_sycl_device_library_location_EQ);
+  if (SYCLDeviceLibLoc && !Triple.isSPIRAOT()) {
+    std::string SYCLDeviceLibLocParam = SYCLDeviceLibLoc->getValue();
+    std::string AssertDeviceLibLoc =
+        SYCLDeviceLibLocParam + "/libsycl-fallback-cassert.bc";
+    if (llvm::sys::fs::exists(AssertDeviceLibLoc)) {
+      SYCLDeviceLibLocParam = "--device-lib-dir=" + SYCLDeviceLibLocParam;
+      CmdArgs.push_back(Args.MakeArgString(StringRef(SYCLDeviceLibLocParam)));
+    }
+  }
   getTripleBasedSYCLPostLinkOpts(Args, CmdArgs, Triple);
   StringRef SYCLPostLinkOptions;
   if (Arg *A = Args.getLastArg(OPT_sycl_post_link_options_EQ))

llvm/include/llvm/SYCLLowerIR/ComputeModuleRuntimeInfo.h

@@ -12,6 +12,7 @@
 
 #include "llvm/ADT/SetVector.h"
 #include "llvm/SYCLLowerIR/ModuleSplitter.h"
+#include "llvm/SYCLLowerIR/SYCLDeviceLibReqMask.h"
 #include "llvm/Support/PropertySetIO.h"
 #include <string>
 namespace llvm {
@@ -36,6 +37,9 @@ PropSetRegTy computeModuleProperties(const Module &M,
                                      const EntryPointSet &EntryPoints,
                                      const GlobalBinImageProps &GlobProps);
 
+PropSetRegTy computeSYCLDeviceLibProperties(const Module &M,
+                                            std::string &SYCLDeviceLibName);
+
 std::string computeModuleSymbolTable(const Module &M,
                                      const EntryPointSet &EntryPoints);
 

llvm/include/llvm/SYCLLowerIR/SYCLDeviceLibReqMask.h

@@ -17,6 +17,8 @@
 #pragma once
 
 #include <cstdint>
+#include <string>
+#include <vector>
 
 namespace llvm {
 
@@ -39,5 +41,7 @@ enum class DeviceLibExt : std::uint32_t {
 };
 
 uint32_t getSYCLDeviceLibReqMask(const Module &M);
-
+void getSYCLDeviceLibReqNames(unsigned int ReqMask,
+                              std::vector<std::string> &ReqNames);
+unsigned int getSYCLDeviceLibMeta(std::string &DeviceLibFn);
 } // namespace llvm

llvm/include/llvm/Support/PropertySetIO.h

@@ -200,6 +200,7 @@ class PropertySetRegistry {
   static constexpr char SYCL_SPEC_CONSTANTS_DEFAULT_VALUES[] =
       "SYCL/specialization constants default values";
   static constexpr char SYCL_DEVICELIB_REQ_MASK[] = "SYCL/devicelib req mask";
+  static constexpr char SYCL_DEVICELIB_METADATA[] = "SYCL/devicelib metadata";
   static constexpr char SYCL_KERNEL_PARAM_OPT_INFO[] = "SYCL/kernel param opt";
   static constexpr char SYCL_PROGRAM_METADATA[] = "SYCL/program metadata";
   static constexpr char SYCL_MISC_PROP[] = "SYCL/misc properties";

llvm/lib/SYCLLowerIR/ComputeModuleRuntimeInfo.cpp

@@ -151,16 +151,37 @@ std::optional<T> getKernelSingleEltMetadata(const Function &Func,
   return std::nullopt;
 }
 
+PropSetRegTy computeSYCLDeviceLibProperties(const Module &M,
+                                            std::string &SYCLDeviceLibName) {
+  PropSetRegTy PropSet;
+
+  {
+    auto SYCLDeviceLibMeta = getSYCLDeviceLibMeta(SYCLDeviceLibName);
+    std::map<StringRef, unsigned int> RMEntry = {
+        {"DeviceLibMetaData", SYCLDeviceLibMeta}};
+    PropSet.add(PropSetRegTy::SYCL_DEVICELIB_METADATA, RMEntry);
+  }
+
+  {
+    for (const auto &F : M.functions()) {
+      if (!F.getName().starts_with("__devicelib_") || F.isDeclaration())
+        continue;
+      if (F.getCallingConv() == CallingConv::SPIR_FUNC) {
+        PropSet.add(PropSetRegTy::SYCL_EXPORTED_SYMBOLS, F.getName(),
+                    /*PropVal=*/true);
+      }
+    }
+  }
+
+  return PropSet;
+}
+
 PropSetRegTy computeModuleProperties(const Module &M,
                                      const EntryPointSet &EntryPoints,
                                      const GlobalBinImageProps &GlobProps) {
 
   PropSetRegTy PropSet;
-  {
-    uint32_t MRMask = getSYCLDeviceLibReqMask(M);
-    std::map<StringRef, uint32_t> RMEntry = {{"DeviceLibReqMask", MRMask}};
-    PropSet.add(PropSetRegTy::SYCL_DEVICELIB_REQ_MASK, RMEntry);
-  }
+
   {
     PropSet.add(PropSetRegTy::SYCL_DEVICE_REQUIREMENTS,
                 computeDeviceRequirements(M, EntryPoints).asMap());
@@ -461,7 +482,7 @@ PropSetRegTy computeModuleProperties(const Module &M,
       }
 
       PropSet.add(PropSetRegTy::SYCL_VIRTUAL_FUNCTIONS,
-                   "uses-virtual-functions-set", AllSets);
+                  "uses-virtual-functions-set", AllSets);
     }
   }
 

llvm/lib/SYCLLowerIR/ModuleSplitter.cpp

@@ -1402,6 +1402,9 @@ splitSYCLModule(std::unique_ptr<Module> M, ModuleSplitterSettings Settings) {
 }
 
 bool canBeImportedFunction(const Function &F) {
+
+  if (F.getName().starts_with("__devicelib_") && F.isDeclaration())
+    return true;
   // It may be theoretically possible to determine what is importable
   // based solely on function F, but the "SYCL/imported symbols"
   // property list MUST NOT have any imported symbols that are not supplied

llvm/lib/SYCLLowerIR/SYCLDeviceLibReqMask.cpp

@@ -757,6 +757,28 @@ uint32_t getDeviceLibBits(const std::string &FuncName) {
 
 } // namespace
 
+static std::unordered_map<DeviceLibExt, std::vector<const char *>>
+    SYCLDeviceLibFn = {
+        {DeviceLibExt::cl_intel_devicelib_assert,
+         {"libsycl-fallback-cassert.bc"}},
+        {DeviceLibExt::cl_intel_devicelib_math, {"libsycl-fallback-cmath.bc"}},
+        {DeviceLibExt::cl_intel_devicelib_math_fp64,
+         {"libsycl-fallback-cmath-fp64.bc"}},
+        {DeviceLibExt::cl_intel_devicelib_complex,
+         {"libsycl-fallback-complex.bc"}},
+        {DeviceLibExt::cl_intel_devicelib_complex_fp64,
+         {"libsycl-fallback-complex-fp64.bc"}},
+        {DeviceLibExt::cl_intel_devicelib_cstring,
+         {"libsycl-fallback-cstring.bc"}},
+        {DeviceLibExt::cl_intel_devicelib_imf, {"libsycl-fallback-imf.bc"}},
+        {DeviceLibExt::cl_intel_devicelib_imf_fp64,
+         {"libsycl-fallback-imf-fp64.bc"}},
+        {DeviceLibExt::cl_intel_devicelib_imf_bf16,
+         {"libsycl-fallback-imf-bf16.bc"}},
+        {DeviceLibExt::cl_intel_devicelib_bfloat16,
+         {"libsycl-fallback-bfloat16.bc", "libsycl-native-bfloat16.bc"}},
+};
+
 // For each device image module, we go through all functions which meets
 // 1. The function name has prefix "__devicelib_"
 // 2. The function is declaration which means it doesn't have function body
@@ -775,3 +797,55 @@ uint32_t llvm::getSYCLDeviceLibReqMask(const Module &M) {
   }
   return ReqMask;
 }
+
+void llvm::getSYCLDeviceLibReqNames(unsigned int ReqMask,
+                                    std::vector<std::string> &ReqNames) {
+  DeviceLibExt DeviceLibExts[] = {DeviceLibExt::cl_intel_devicelib_assert,
+                                  DeviceLibExt::cl_intel_devicelib_math,
+                                  DeviceLibExt::cl_intel_devicelib_math_fp64,
+                                  DeviceLibExt::cl_intel_devicelib_complex,
+                                  DeviceLibExt::cl_intel_devicelib_complex_fp64,
+                                  DeviceLibExt::cl_intel_devicelib_cstring,
+                                  DeviceLibExt::cl_intel_devicelib_imf,
+                                  DeviceLibExt::cl_intel_devicelib_imf_fp64,
+                                  DeviceLibExt::cl_intel_devicelib_imf_bf16,
+                                  DeviceLibExt::cl_intel_devicelib_bfloat16};
+
+  unsigned int Temp;
+  for (auto Ext : DeviceLibExts) {
+    Temp =
+        0x1 << (static_cast<size_t>(Ext) -
+                static_cast<size_t>(DeviceLibExt::cl_intel_devicelib_assert));
+    if (Temp & ReqMask) {
+      for (auto Fn : SYCLDeviceLibFn[Ext])
+        ReqNames.push_back(std::string(Fn));
+    }
+  }
+}
+
+unsigned int llvm::getSYCLDeviceLibMeta(std::string &DeviceLibFn) {
+  DeviceLibExt DeviceLibExts[] = {DeviceLibExt::cl_intel_devicelib_assert,
+                                  DeviceLibExt::cl_intel_devicelib_math,
+                                  DeviceLibExt::cl_intel_devicelib_math_fp64,
+                                  DeviceLibExt::cl_intel_devicelib_complex,
+                                  DeviceLibExt::cl_intel_devicelib_complex_fp64,
+                                  DeviceLibExt::cl_intel_devicelib_cstring,
+                                  DeviceLibExt::cl_intel_devicelib_imf,
+                                  DeviceLibExt::cl_intel_devicelib_imf_fp64,
+                                  DeviceLibExt::cl_intel_devicelib_imf_bf16,
+                                  DeviceLibExt::cl_intel_devicelib_bfloat16};
+
+  unsigned int DeviceLibMeta = 0;
+  for (auto Ext : DeviceLibExts) {
+    for (auto Fn : SYCLDeviceLibFn[Ext]) {
+      if (DeviceLibFn == Fn) {
+        DeviceLibMeta = static_cast<unsigned int>(Ext);
+        if (DeviceLibFn == "libsycl-native-bfloat16.bc")
+          DeviceLibMeta |= 0x80000000;
+        break;
+      }
+    }
+  }
+
+  return DeviceLibMeta;
+}

llvm/lib/Support/PropertySetIO.cpp

@@ -196,6 +196,7 @@ void PropertyValue::copy(const PropertyValue &P) {
 
 constexpr char PropertySetRegistry::SYCL_SPECIALIZATION_CONSTANTS[];
 constexpr char PropertySetRegistry::SYCL_DEVICELIB_REQ_MASK[];
+constexpr char PropertySetRegistry::SYCL_DEVICELIB_METADATA[];
 constexpr char PropertySetRegistry::SYCL_SPEC_CONSTANTS_DEFAULT_VALUES[];
 constexpr char PropertySetRegistry::SYCL_KERNEL_PARAM_OPT_INFO[];
 constexpr char PropertySetRegistry::SYCL_PROGRAM_METADATA[];