[Mlir-commits] [mlir] [MLIR][XeVM] Update XeVM target (PR #179557)

[llvmlistbot at llvm.org]

llvmbot wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-mlir-llvm

Author: Sang Ik Lee (silee2)

<details>
<summary>Changes</summary>

XeVM target needs to enable several SPV_INTEL extensions.
Override `run()` method to customize target machine with extensions.

---
Full diff: https://github.com/llvm/llvm-project/pull/179557.diff


2 Files Affected:

- (modified) mlir/lib/Target/LLVM/CMakeLists.txt (+7) 
- (modified) mlir/lib/Target/LLVM/XeVM/Target.cpp (+90-8) 


``````````diff
diff --git a/mlir/lib/Target/LLVM/CMakeLists.txt b/mlir/lib/Target/LLVM/CMakeLists.txt
index 9a0e4d45693b8..2a16160267174 100644
--- a/mlir/lib/Target/LLVM/CMakeLists.txt
+++ b/mlir/lib/Target/LLVM/CMakeLists.txt
@@ -234,3 +234,10 @@ add_mlir_dialect_library(MLIRXeVMTarget
   MLIRTargetLLVM
   MLIRXeVMToLLVMIRTranslation
 )
+
+target_include_directories(MLIRXeVMTarget
+  PRIVATE
+    ${PROJECT_SOURCE_DIR}/lib/Target/SPIRV
+    ${PROJECT_BINARY_DIR}/lib/Target/SPIRV
+)
+
diff --git a/mlir/lib/Target/LLVM/XeVM/Target.cpp b/mlir/lib/Target/LLVM/XeVM/Target.cpp
index 4285a4e37becf..00a90ab6bd0c1 100644
--- a/mlir/lib/Target/LLVM/XeVM/Target.cpp
+++ b/mlir/lib/Target/LLVM/XeVM/Target.cpp
@@ -13,6 +13,7 @@
 
 #include "mlir/Target/LLVM/XeVM/Target.h"
 
+#include "MCTargetDesc/SPIRVBaseInfo.h"
 #include "mlir/Dialect/GPU/IR/CompilationInterfaces.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Dialect/LLVMIR/XeVMDialect.h"
@@ -39,6 +40,12 @@
 #include "llvm/Support/Program.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
+// From llvm/lib/Target/SPIRV
+#if LLVM_HAS_SPIRV_TARGET
+#include "SPIRVCommandLine.h"
+#include "SPIRVSubtarget.h"
+#include "SPIRVTargetMachine.h"
+#endif
 
 #include <cstdint>
 #include <cstdlib>
@@ -239,6 +246,10 @@ class SPIRVSerializer : public SerializeGPUModuleBase {
 
   static void init();
 
+  /// Runs the serialization pipeline, returning `std::nullopt` on error.
+  std::optional<SmallVector<char, 0>> run() override;
+
+protected:
   /// Serializes the LLVM module to an object format, depending on the
   /// compilation target selected in target options.
   FailureOr<SmallVector<char, 0>>
@@ -265,27 +276,98 @@ void SPIRVSerializer::init() {
   });
 }
 
-FailureOr<SmallVector<char, 0>>
-SPIRVSerializer::moduleToObject(llvm::Module &llvmModule) {
+static const std::vector<std::string> getDefaultSPIRVExtensions() {
+  return {
+      "SPV_INTEL_cache_controls",
+      "SPV_INTEL_variable_length_array",
+  };
+}
+
+std::optional<SmallVector<char, 0>> SPIRVSerializer::run() {
+  // Translate the module to LLVM IR.
+  llvm::LLVMContext llvmContext;
+  std::unique_ptr<llvm::Module> llvmModule = translateToLLVMIR(llvmContext);
+  if (!llvmModule) {
+    getOperation().emitError() << "Failed creating the llvm::Module.";
+    return std::nullopt;
+  }
+
 #define DEBUG_TYPE "serialize-to-llvm"
   LLVM_DEBUG({
     llvm::dbgs() << "LLVM IR for module: " << getGPUModuleOp().getNameAttr()
                  << "\n";
-    llvm::dbgs() << llvmModule << "\n";
+    llvm::dbgs() << *llvmModule << "\n";
     llvm::dbgs().flush();
   });
 #undef DEBUG_TYPE
 
   // Return LLVM IR if the compilation target is `offload`.
   if (targetOptions.getCompilationTarget() == gpu::CompilationTarget::Offload)
-    return SerializeGPUModuleBase::moduleToObject(llvmModule);
+    return SerializeGPUModuleBase::moduleToObject(*llvmModule);
 
-#if !LLVM_HAS_SPIRV_TARGET
-  return getGPUModuleOp()->emitError(
-      "The `SPIRV` target was not built. Please enable "
-      "it when building LLVM.");
+#if LLVM_HAS_SPIRV_TARGET
+  setDataLayoutAndTriple(*llvmModule);
+
+  // Create the target machine.
+  FailureOr<llvm::TargetMachine *> targetMachine = getOrCreateTargetMachine();
+  if (failed(targetMachine)) {
+    getOperation().emitError()
+        << "Target Machine unavailable for triple " << triple
+        << ", can't output compilation target.\n";
+    return std::nullopt;
+  }
+  // Setup allowed SPIR-V extensions.
+  std::set<llvm::SPIRV::Extension::Extension> AllowedExtIds;
+  llvm::StringRef UnknownExt = llvm::SPIRVExtensionsParser::checkExtensions(
+      getDefaultSPIRVExtensions(), AllowedExtIds);
+  if (!UnknownExt.empty()) {
+    std::string ErrMsg{"Unknown SPIR-V extension: "};
+    ErrMsg.append(UnknownExt.str());
+    getOperation().emitError() << ErrMsg;
+    return std::nullopt;
+  }
+
+  llvm::SPIRVTargetMachine *STM =
+      static_cast<llvm::SPIRVTargetMachine *>(*targetMachine);
+  const_cast<llvm::SPIRVSubtarget *>(STM->getSubtargetImpl())
+      ->initAvailableExtensions(AllowedExtIds);
+
+  if (initialLlvmIRCallback)
+    initialLlvmIRCallback(*llvmModule);
+
+  // Link bitcode files.
+  handleModulePreLink(*llvmModule);
+  {
+    auto libs = loadBitcodeFiles(*llvmModule);
+    if (!libs)
+      return std::nullopt;
+    if (!libs->empty())
+      if (failed(linkFiles(*llvmModule, std::move(*libs))))
+        return std::nullopt;
+    handleModulePostLink(*llvmModule);
+  }
+
+  if (linkedLlvmIRCallback)
+    linkedLlvmIRCallback(*llvmModule);
+
+  // Optimize the module.
+  if (failed(optimizeModule(*llvmModule, optLevel)))
+    return std::nullopt;
+
+  if (optimizedLlvmIRCallback)
+    optimizedLlvmIRCallback(*llvmModule);
+
+  // Return the serialized object.
+  return moduleToObject(*llvmModule);
+#else
+  getOperation().emitError("The `SPIRV` target was not built. Please enable "
+                           "it when building LLVM.");
+  return std::nullopt;
 #endif // LLVM_HAS_SPIRV_TARGET
+}
 
+FailureOr<SmallVector<char, 0>>
+SPIRVSerializer::moduleToObject(llvm::Module &llvmModule) {
   FailureOr<llvm::TargetMachine *> targetMachine = getOrCreateTargetMachine();
   if (failed(targetMachine))
     return getGPUModuleOp().emitError()

``````````

</details>


https://github.com/llvm/llvm-project/pull/179557