[mlir] Add support for basic location translation to LLVM.

[rriddle]

Summary

This revision adds basic support for emitting line table information when exporting to LLVMIR. We don't yet have a story for supporting all of the LLVM debug metadata, so this revision stubs some features(like subprograms) to enable emitting line tables.

Depends On D73932

[merge_guards_bot]

Unit tests: pass. 62434 tests passed, 0 failed and 845 were skipped.

clang-tidy: fail. clang-tidy found 1 errors and 0 warnings. 0 of them are added as review comments below (why?).

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[ftynse]

Thanks River, this is very useful!

I'm not an expert on LLVM debuginfo though.

mlir/lib/Target/LLVMIR/DebugTranslation.cpp

29

I'd explicitly initialize compileUnit to nullptr since it is later used as a signaling state for not doing anything.

31

Nit: I was confused by the name of the operation into believing that it would interrupt in _absence_ of location info, but it's the inverse. The code is correct though.

34

Nit: please specify what exactly isn't correct (e.g., using C as language)

39

Nit: could we have parameter names in comments for "" and 0 as well?

[rriddle]

Resolve comments

[rriddle]

Add comma.

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: fail. clang-tidy found 1 errors and 0 warnings. 0 of them are added as review comments below (why?).

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: fail. clang-tidy found 1 errors and 0 warnings. 0 of them are added as review comments below (why?).

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[antiagainst]

Cool stuff! :) This reminds me that we don't have proper debug information to and from SPIR-V binary format too. Need to add that some day too. ;-P

mlir/include/mlir/Target/LLVMIR/ModuleTranslation.h

 namespace mlir {
 class Attribute;
 class Location;
 class ModuleOp;
 class Operation;
 
 namespace LLVM {
 
+namespace detail {
+class DebugTranslation;
+} // end namespace detail
+
 class LLVMFuncOp;
 
-// Implementation class for module translation.  Holds a reference to the module
-// being translated, and the mappings between the original and the translated
-// functions, basic blocks and values.  It is practically easier to hold these
-// mappings in one class since the conversion of control flow operations
-// needs to look up block and function mappings.
+/// Implementation class for module translation. Holds a reference to the module
+/// being translated, and the mappings between the original and the translated
+/// functions, basic blocks and values. It is practically easier to hold these
+/// mappings in one class since the conversion of control flow operations
+/// needs to look up block and function mappings.
 class ModuleTranslation {
 public:
   template <typename T = ModuleTranslation>
   static std::unique_ptr<llvm::Module> translateModule(Operation *m) {
     if (!satisfiesLLVMModule(m))
       return nullptr;
     if (failed(checkSupportedModuleOps(m)))
       return nullptr;
     auto llvmModule = prepareLLVMModule(m);
     if (!llvmModule)
       return nullptr;
 
-    T translator(m);
-    translator.llvmModule = std::move(llvmModule);
+    T translator(m, std::move(llvmModule));
     translator.convertGlobals();
     if (failed(translator.convertFunctions()))
       return nullptr;
 
     return std::move(translator.llvmModule);
   }
 
   /// A helper method to get the single Block in an operation honoring LLVM's
   /// module requirements.
   static Block &getModuleBody(Operation *m) { return m->getRegion(0).front(); }
 
 protected:
-  // Translate the given MLIR module expressed in MLIR LLVM IR dialect into an
-  // LLVM IR module.  The MLIR LLVM IR dialect holds a pointer to an
-  // LLVMContext, the LLVM IR module will be created in that context.
-  explicit ModuleTranslation(Operation *module) : mlirModule(module) {
-    assert(satisfiesLLVMModule(mlirModule) &&
-           "mlirModule should honor LLVM's module semantics.");
-  }
-  virtual ~ModuleTranslation() {}
+  /// Translate the given MLIR module expressed in MLIR LLVM IR dialect into an
+  /// LLVM IR module. The MLIR LLVM IR dialect holds a pointer to an
+  /// LLVMContext, the LLVM IR module will be created in that context.
+  ModuleTranslation(Operation *module,
+                    std::unique_ptr<llvm::Module> llvmModule);
+  virtual ~ModuleTranslation();
 
   virtual LogicalResult convertOperation(Operation &op,
                                          llvm::IRBuilder<> &builder);
   static std::unique_ptr<llvm::Module> prepareLLVMModule(Operation *m);
 
   /// A helper to look up remapped operands in the value remapping table.
   SmallVector<llvm::Value *, 8> lookupValues(ValueRange values);
 
 private:
   /// Check whether the module contains only supported ops directly in its body.
   static LogicalResult checkSupportedModuleOps(Operation *m);
 
   LogicalResult convertFunctions();
   void convertGlobals();
   LogicalResult convertOneFunction(LLVMFuncOp func);
   void connectPHINodes(LLVMFuncOp func);
   LogicalResult convertBlock(Block &bb, bool ignoreArguments);
 
   llvm::Constant *getLLVMConstant(llvm::Type *llvmType, Attribute attr,
                                   Location loc);
 
-  // Original and translated module.
+  /// Original and translated module.
   Operation *mlirModule;
   std::unique_ptr<llvm::Module> llvmModule;
 
-  // Mappings between llvm.mlir.global definitions and corresponding globals.
+  /// A converter for translating debug information.
+  std::unique_ptr<detail::DebugTranslation> debugTranslation;
+
+  /// Mappings between llvm.mlir.global definitions and corresponding globals.
   DenseMap<Operation *, llvm::GlobalValue *> globalsMapping;
 
 protected:
-  // Mappings between original and translated values, used for lookups.
+  /// Mappings between original and translated values, used for lookups.
   llvm::StringMap<llvm::Function *> functionMapping;
   DenseMap<Value, llvm::Value *> valueMapping;
   DenseMap<Block *, llvm::BasicBlock *> blockMapping;
 };
 
 } // namespace LLVM
 } // namespace mlir
 
 #endif // MLIR_TARGET_LLVMIR_MODULETRANSLATION_H

mlir/include/mlir/Transforms/Passes.h

std::unique_ptr<OpPassBase<FuncOp>> createAffineDataCopyGenerationPass(
     unsigned tagMemorySpace = 0, int minDmaTransferSize = 1024,
     uint64_t fastMemCapacityBytes = std::numeric_limits<uint64_t>::max());
 
 /// Creates a pass to perform optimizations relying on memref dataflow such as
 /// store to load forwarding, elimination of dead stores, and dead allocs.
 std::unique_ptr<OpPassBase<FuncOp>> createMemRefDataFlowOptPass();
 
 /// Creates a pass to strip debug information from a function.
-std::unique_ptr<OpPassBase<FuncOp>> createStripDebugInfoPass();
+std::unique_ptr<Pass> createStripDebugInfoPass();
 
 /// Creates a pass which tests loop fusion utilities.
 std::unique_ptr<OpPassBase<FuncOp>> createTestLoopFusionPass();
 
 /// Creates a pass which inlines calls and callable operations as defined by the
 /// CallGraph.
 std::unique_ptr<Pass> createInlinerPass();
 
 /// Creates a pass which delete symbol operations that are unreachable. This
 /// pass may *only* be scheduled on an operation that defines a SymbolTable.
 std::unique_ptr<Pass> createSymbolDCEPass();
 } // end namespace mlir
 
 #endif // MLIR_TRANSFORMS_PASSES_H

mlir/lib/Target/CMakeLists.txt

 add_llvm_library(MLIRTargetLLVMIRModuleTranslation
+  LLVMIR/DebugTranslation.cpp
   LLVMIR/ModuleTranslation.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Target/LLVMIR
   DEPENDS
   intrinsics_gen
   )
 target_link_libraries(MLIRTargetLLVMIRModuleTranslation

mlir/lib/Target/LLVMIR/ConvertToNVVMIR.cpp

return resultType->isFloatTy() ? llvm::Intrinsic::nvvm_shfl_sync_bfly_f32p
                                    : llvm::Intrinsic::nvvm_shfl_sync_bfly_i32p;
   }
   return resultType->isFloatTy() ? llvm::Intrinsic::nvvm_shfl_sync_bfly_f32
                                  : llvm::Intrinsic::nvvm_shfl_sync_bfly_i32;
 }
 
 namespace {
 class ModuleTranslation : public LLVM::ModuleTranslation {
-
 public:
-  explicit ModuleTranslation(Operation *module)
-      : LLVM::ModuleTranslation(module) {}
-  ~ModuleTranslation() override {}
+  using LLVM::ModuleTranslation::ModuleTranslation;
 
 protected:
   LogicalResult convertOperation(Operation &opInst,
                                  llvm::IRBuilder<> &builder) override {
 
 #include "mlir/Dialect/LLVMIR/NVVMConversions.inc"
 
     return LLVM::ModuleTranslation::convertOperation(opInst, builder);
   }
 };
 } // namespace
 
 std::unique_ptr<llvm::Module> mlir::translateModuleToNVVMIR(Operation *m) {
-  ModuleTranslation translation(m);
   auto llvmModule =
       LLVM::ModuleTranslation::translateModule<ModuleTranslation>(m);
   if (!llvmModule)
     return llvmModule;
 
   // Insert the nvvm.annotations kernel so that the NVVM backend recognizes the
   // function as a kernel.
   for (auto func :

mlir/lib/Target/LLVMIR/ConvertToROCDLIR.cpp

llvm::Function *fn = dyn_cast<llvm::Function>(
       module->getOrInsertFunction(fn_name, function_type).getCallee());
   llvm::Value *fn_op0 = llvm::ConstantInt::get(
       llvm::Type::getInt32Ty(module->getContext()), parameter);
   return builder.CreateCall(fn, ArrayRef<llvm::Value *>(fn_op0));
 }
 
 namespace {
 class ModuleTranslation : public LLVM::ModuleTranslation {
-
 public:
-  explicit ModuleTranslation(Operation *module)
-      : LLVM::ModuleTranslation(module) {}
-  ~ModuleTranslation() override {}
+  using LLVM::ModuleTranslation::ModuleTranslation;
 
 protected:
   LogicalResult convertOperation(Operation &opInst,
                                  llvm::IRBuilder<> &builder) override {
 
 #include "mlir/Dialect/LLVMIR/ROCDLConversions.inc"
 
     return LLVM::ModuleTranslation::convertOperation(opInst, builder);
   }
 };
 } // namespace
 
 std::unique_ptr<llvm::Module> mlir::translateModuleToROCDLIR(Operation *m) {
-  ModuleTranslation translation(m);
-
   // lower MLIR (with RODL Dialect) to LLVM IR (with ROCDL intrinsics)
   auto llvmModule =
       LLVM::ModuleTranslation::translateModule<ModuleTranslation>(m);
 
   // foreach GPU kernel
   // 1. Insert AMDGPU_KERNEL calling convention.
   // 2. Insert amdgpu-flat-workgroup-size(1, 1024) attribute.
   for (auto func :

mlir/lib/Target/LLVMIR/DebugTranslation.h

+//===- DebugTranslation.h - MLIR to LLVM Debug conversion -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the translation between an MLIR debug information and
+// the corresponding LLVMIR representation.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_LIB_TARGET_LLVMIR_DEBUGTRANSLATION_H_
+#define MLIR_LIB_TARGET_LLVMIR_DEBUGTRANSLATION_H_
+
+#include "mlir/IR/Location.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/IR/DIBuilder.h"
+
+namespace mlir {
+class Operation;
+
+namespace LLVM {
+class LLVMFuncOp;
+
+namespace detail {
+class DebugTranslation {
+public:
+  DebugTranslation(Operation *module, llvm::Module &llvmModule);
+
+  /// Finalize the translation of debug information.
+  void finalize();
+
+  /// Translate the given location to an llvm debug location.
+  const llvm::DILocation *translateLoc(Location loc, llvm::DILocalScope *scope);
+
+  /// Translate the debug information for the given function.
+  void translate(LLVMFuncOp func, llvm::Function &llvmFunc);
+
+private:
+  /// Translate the given location to an llvm debug location with the given
+  /// scope and inlinedAt parameters.
+  const llvm::DILocation *translateLoc(Location loc, llvm::DILocalScope *scope,
+                                       const llvm::DILocation *inlinedAt);
+
+  /// Create an llvm debug file for the given file path.
+  llvm::DIFile *translateFile(StringRef fileName);
+
+  /// A mapping between mlir location+scope and the corresponding llvm debug
+  /// metadata.
+  DenseMap<std::pair<Location, llvm::DILocalScope *>, const llvm::DILocation *>
+      locationToLoc;
+
+  /// A mapping between filename and llvm debug file.
+  /// TODO(riverriddle) Change this to DenseMap<Identifier, ...> when we can
+  /// access the Identifier filename in FileLineColLoc.
+  llvm::StringMap<llvm::DIFile *> fileMap;
+
+  /// A string containing the current working directory of the compiler.
+  SmallString<256> currentWorkingDir;
+
+  /// Debug information fields.
+  llvm::DIBuilder builder;
+  llvm::LLVMContext &llvmCtx;
+  llvm::DICompileUnit *compileUnit;
+};
+
+} // end namespace detail
+} // end namespace LLVM
+} // end namespace mlir
+
+#endif // MLIR_LIB_TARGET_LLVMIR_DEBUGTRANSLATION_H_

mlir/lib/Target/LLVMIR/DebugTranslation.cpp

+//===- DebugTranslation.cpp - MLIR to LLVM Debug conversion ---------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "DebugTranslation.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "llvm/IR/Metadata.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+
+using namespace mlir;
+using namespace mlir::LLVM;
+using namespace mlir::LLVM::detail;
+
+/// A utility walker that interrupts if the operation has valid debug
+/// information.
+static WalkResult interruptIfValidLocation(Operation *op) {
+  return op->getLoc().isa<UnknownLoc>() ? WalkResult::advance()
+                                        : WalkResult::interrupt();
+}
+
+DebugTranslation::DebugTranslation(Operation *module, llvm::Module &llvmModule)
+    : builder(llvmModule), llvmCtx(llvmModule.getContext()),
+      compileUnit(nullptr) {
+
+  // If the module has no location information, there is nothing to do.
+  if (!module->walk(interruptIfValidLocation).wasInterrupted())
+    return;
+
+  // TODO(riverriddle) Several parts of this are incorrect. Different source
+  // languages may interpret different parts of the debug information
+  // differently. Frontends will also want to pipe in various information, like
+  // flags. This is fine for now as we only emit line-table information and not
+  // types or variables. This should disappear as the debug information story
+  // evolves; i.e. when we have proper attributes for LLVM debug metadata.
+  compileUnit = builder.createCompileUnit(
+      llvm::dwarf::DW_LANG_C,
+      builder.createFile(llvmModule.getModuleIdentifier(), "/"),
+      /*Producer=*/"mlir", /*isOptimized=*/true, /*Flags=*/"", /*RV=*/0);
+
+  // Mark this module as having debug information.
+  StringRef debugVersionKey = "Debug Info Version";
+  if (!llvmModule.getModuleFlag(debugVersionKey))
+    llvmModule.addModuleFlag(llvm::Module::Warning, debugVersionKey,
+                             llvm::DEBUG_METADATA_VERSION);
+}
+
+/// Finalize the translation of debug information.
+void DebugTranslation::finalize() { builder.finalize(); }
+
+/// Attempt to extract a filename for the given loc.
+static FileLineColLoc extractFileLoc(Location loc) {
+  if (auto fileLoc = loc.dyn_cast<FileLineColLoc>())
+    return fileLoc;
+  if (auto nameLoc = loc.dyn_cast<NameLoc>())
+    return extractFileLoc(nameLoc.getChildLoc());
+  if (auto opaqueLoc = loc.dyn_cast<OpaqueLoc>())
+    return extractFileLoc(opaqueLoc.getFallbackLocation());
+  return FileLineColLoc();
+}
+
+/// Translate the debug information for the given function.
+void DebugTranslation::translate(LLVMFuncOp func, llvm::Function &llvmFunc) {
+  // If the function doesn't have location information, there is nothing to
+  // translate.
+  if (!compileUnit || !func.walk(interruptIfValidLocation).wasInterrupted())
+    return;
+
+  FileLineColLoc fileLoc = extractFileLoc(func.getLoc());
+  auto *file = translateFile(fileLoc ? fileLoc.getFilename() : "<unknown>");
+  unsigned line = fileLoc ? fileLoc.getLine() : 0;
+
+  // TODO(riverriddle) This is the bare essentials for now. We will likely end
+  // up with wrapper metadata around LLVMs metadata in the future, so this
+  // doesn't need to be smart until then.
+  llvm::DISubroutineType *type =
+      builder.createSubroutineType(builder.getOrCreateTypeArray(llvm::None));
+  llvm::DISubprogram::DISPFlags spFlags = llvm::DISubprogram::SPFlagDefinition |
+                                          llvm::DISubprogram::SPFlagOptimized;
+  llvm::DISubprogram *program =
+      builder.createFunction(compileUnit, func.getName(), func.getName(), file,
+                             line, type, line, llvm::DINode::FlagZero, spFlags);
+  llvmFunc.setSubprogram(program);
+  builder.finalizeSubprogram(program);
+}
+
+//===----------------------------------------------------------------------===//
+// Locations
+//===----------------------------------------------------------------------===//
+
+/// Translate the given location to an llvm debug location.
+const llvm::DILocation *
+DebugTranslation::translateLoc(Location loc, llvm::DILocalScope *scope) {
+  if (!compileUnit)
+    return nullptr;
+  return translateLoc(loc, scope, /*inlinedAt=*/nullptr);
+}
+
+/// Translate the given location to an llvm DebugLoc.
+const llvm::DILocation *
+DebugTranslation::translateLoc(Location loc, llvm::DILocalScope *scope,
+                               const llvm::DILocation *inlinedAt) {
+  // LLVM doesn't have a representation for unknown.
+  if (!scope || loc.isa<UnknownLoc>())
+    return nullptr;
+
+  // Check for a cached instance.
+  const auto *&llvmLoc = locationToLoc[std::make_pair(loc, scope)];
+  if (llvmLoc)
+    return llvmLoc;
+
+  switch (loc->getKind()) {
+  case StandardAttributes::CallSiteLocation: {
+    auto callLoc = loc.dyn_cast<CallSiteLoc>();
+
+    // For callsites, the caller is fed as the inlinedAt for the callee.
+    const auto *callerLoc = translateLoc(callLoc.getCaller(), scope, inlinedAt);
+    llvmLoc = translateLoc(callLoc.getCallee(), scope, callerLoc);
+    break;
+  }
+  case StandardAttributes::FileLineColLocation: {
+    auto fileLoc = loc.dyn_cast<FileLineColLoc>();
+    auto *file = translateFile(fileLoc.getFilename());
+    auto *fileScope = builder.createLexicalBlockFile(scope, file);
+    llvmLoc = llvm::DILocation::get(llvmCtx, fileLoc.getLine(),
+                                    fileLoc.getColumn(), fileScope,
+                                    const_cast<llvm::DILocation *>(inlinedAt));
+    break;
+  }
+  case StandardAttributes::FusedLocation: {
+    auto fusedLoc = loc.dyn_cast<FusedLoc>();
+    ArrayRef<Location> locations = fusedLoc.getLocations();
+
+    // For fused locations, merge each of the nodes.
+    llvmLoc = translateLoc(locations.front(), scope, inlinedAt);
+    for (Location locIt : locations.drop_front()) {
+      llvmLoc = llvm::DILocation::getMergedLocation(
+          llvmLoc, translateLoc(locIt, scope, inlinedAt));
+    }
+    break;
+  }
+  case StandardAttributes::NameLocation:
+    llvmLoc = translateLoc(loc.cast<NameLoc>().getChildLoc(), scope, inlinedAt);
+    break;
+  case StandardAttributes::OpaqueLocation:
+    llvmLoc = translateLoc(loc.cast<OpaqueLoc>().getFallbackLocation(), scope,
+                           inlinedAt);
+    break;
+  default:
+    llvm_unreachable("unknown location kind");
+  }
+  return llvmLoc;
+}
+
+/// Create an llvm debug file for the given file path.
+llvm::DIFile *DebugTranslation::translateFile(StringRef fileName) {
+  auto *&file = fileMap[fileName];
+  if (file)
+    return file;
+
+  // Make sure the current working directory is up-to-date.
+  if (currentWorkingDir.empty())
+    llvm::sys::fs::current_path(currentWorkingDir);
+
+  StringRef directory = currentWorkingDir;
+  SmallString<128> dirBuf;
+  SmallString<128> fileBuf;
+  if (llvm::sys::path::is_absolute(fileName)) {
+    // Strip the common prefix (if it is more than just "/") from current
+    // directory and FileName for a more space-efficient encoding.
+    auto fileIt = llvm::sys::path::begin(fileName);
+    auto fileE = llvm::sys::path::end(fileName);
+    auto curDirIt = llvm::sys::path::begin(directory);
+    auto curDirE = llvm::sys::path::end(directory);
+    for (; curDirIt != curDirE && *curDirIt == *fileIt; ++curDirIt, ++fileIt)
+      llvm::sys::path::append(dirBuf, *curDirIt);
+    if (std::distance(llvm::sys::path::begin(directory), curDirIt) == 1) {
+      // Don't strip the common prefix if it is only the root "/"  since that
+      // would make LLVM diagnostic locations confusing.
+      directory = StringRef();
+    } else {
+      for (; fileIt != fileE; ++fileIt)
+        llvm::sys::path::append(fileBuf, *fileIt);
+      directory = dirBuf;
+      fileName = fileBuf;
+    }
+  }
+  return (file = builder.createFile(fileName, directory));
+}

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

 //===- ModuleTranslation.cpp - MLIR to LLVM conversion --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the translation between an MLIR LLVM dialect module and
 // the corresponding LLVMIR module. It only handles core LLVM IR operations.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Target/LLVMIR/ModuleTranslation.h"
 
+#include "DebugTranslation.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Support/LLVM.h"
 
 #include "llvm/ADT/SetVector.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 
 using namespace mlir;
 using namespace mlir::LLVM;
+using namespace mlir::LLVM::detail;
 
 #include "mlir/Dialect/LLVMIR/LLVMConversionEnumsToLLVM.inc"
 
 /// Builds a constant of a sequential LLVM type `type`, potentially containing
 /// other sequential types recursively, from the individual constant values
 /// provided in `constants`. `shape` contains the number of elements in nested
 /// sequential types. Reports errors at `loc` and returns nullptr on error.
 static llvm::Constant *
static llvm::AtomicOrdering getLLVMAtomicOrdering(AtomicOrdering ordering) {
   case LLVM::AtomicOrdering::acq_rel:
     return llvm::AtomicOrdering::AcquireRelease;
   case LLVM::AtomicOrdering::seq_cst:
     return llvm::AtomicOrdering::SequentiallyConsistent;
   }
   llvm_unreachable("incorrect atomic ordering");
 }
 
+ModuleTranslation::ModuleTranslation(Operation *module,
+                                     std::unique_ptr<llvm::Module> llvmModule)
+    : mlirModule(module), llvmModule(std::move(llvmModule)),
+      debugTranslation(
+          std::make_unique<DebugTranslation>(module, *this->llvmModule)) {
+  assert(satisfiesLLVMModule(mlirModule) &&
+         "mlirModule should honor LLVM's module semantics.");
+}
+ModuleTranslation::~ModuleTranslation() {}
+
 /// Given a single MLIR operation, create the corresponding LLVM IR operation
 /// using the `builder`.  LLVM IR Builder does not have a generic interface so
 /// this has to be a long chain of `if`s calling different functions with a
 /// different number of arguments.
 LogicalResult ModuleTranslation::convertOperation(Operation &opInst,
                                                   llvm::IRBuilder<> &builder) {
   auto extractPosition = [](ArrayAttr attr) {
     SmallVector<unsigned, 4> position;
return opInst.emitError("unsupported or non-LLVM operation: ")
          << opInst.getName();
 }
 
 /// Convert block to LLVM IR.  Unless `ignoreArguments` is set, emit PHI nodes
 /// to define values corresponding to the MLIR block arguments.  These nodes
 /// are not connected to the source basic blocks, which may not exist yet.
 LogicalResult ModuleTranslation::convertBlock(Block &bb, bool ignoreArguments) {
   llvm::IRBuilder<> builder(blockMapping[&bb]);
+  auto *subprogram = builder.GetInsertBlock()->getParent()->getSubprogram();
 
   // Before traversing operations, make block arguments available through
   // value remapping and PHI nodes, but do not add incoming edges for the PHI
   // nodes just yet: those values may be defined by this or following blocks.
   // This step is omitted if "ignoreArguments" is set.  The arguments of the
   // first block have been already made available through the remapping of
   // LLVM function arguments.
   if (!ignoreArguments) {
     auto predecessors = bb.getPredecessors();
     unsigned numPredecessors =
         std::distance(predecessors.begin(), predecessors.end());
     for (auto arg : bb.getArguments()) {
       auto wrappedType = arg.getType().dyn_cast<LLVM::LLVMType>();
       if (!wrappedType)
         return emitError(bb.front().getLoc(),
                          "block argument does not have an LLVM type");
       llvm::Type *type = wrappedType.getUnderlyingType();
       llvm::PHINode *phi = builder.CreatePHI(type, numPredecessors);
       valueMapping[arg] = phi;
     }
   }
 
   // Traverse operations.
   for (auto &op : bb) {
+    // Set the current debug location within the builder.
+    builder.SetCurrentDebugLocation(
+        debugTranslation->translateLoc(op.getLoc(), subprogram));
+
     if (failed(convertOperation(op, builder)))
       return failure();
   }
 
   return success();
 }
 
 /// Create named global variables that correspond to llvm.mlir.global

 }
 
 LogicalResult ModuleTranslation::convertOneFunction(LLVMFuncOp func) {
   // Clear the block and value mappings, they are only relevant within one
   // function.
   blockMapping.clear();
   valueMapping.clear();
   llvm::Function *llvmFunc = functionMapping.lookup(func.getName());
+
+  // Translate the debug information for this function.
+  debugTranslation->translate(func, *llvmFunc);
+
   // Add function arguments to the value remapping table.
   // If there was noalias info then we decorate each argument accordingly.
   unsigned int argIdx = 0;
   for (auto kvp : llvm::zip(func.getArguments(), llvmFunc->args())) {
     llvm::Argument &llvmArg = std::get<1>(kvp);
     BlockArgument mlirArg = std::get<0>(kvp);
 
     if (auto attr = func.getArgAttrOfType<BoolAttr>(argIdx, "llvm.noalias")) {

mlir/lib/Transforms/StripDebugInfo.cpp

 //===- StripDebugInfo.cpp - Pass to strip debug information ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/Passes.h"
 
 using namespace mlir;
 
 namespace {
-struct StripDebugInfo : public FunctionPass<StripDebugInfo> {
-  void runOnFunction() override;
+struct StripDebugInfo : public OperationPass<StripDebugInfo> {
+  void runOnOperation() override;
 };
 } // end anonymous namespace
 
-void StripDebugInfo::runOnFunction() {
-  FuncOp func = getFunction();
+void StripDebugInfo::runOnOperation() {
+  // Strip the debug info from all operations.
   auto unknownLoc = UnknownLoc::get(&getContext());
-
-  // Strip the debug info from the function and its operations.
-  func.setLoc(unknownLoc);
-  func.walk([&](Operation *op) { op->setLoc(unknownLoc); });
+  getOperation()->walk([&](Operation *op) { op->setLoc(unknownLoc); });
 }
 
 /// Creates a pass to strip debug information from a function.
-std::unique_ptr<OpPassBase<FuncOp>> mlir::createStripDebugInfoPass() {
+std::unique_ptr<Pass> mlir::createStripDebugInfoPass() {
   return std::make_unique<StripDebugInfo>();
 }
 
 static PassRegistration<StripDebugInfo>
-    pass("strip-debuginfo", "Strip debug info from functions and operations");
+    pass("strip-debuginfo", "Strip debug info from all operations");

mlir/test/Target/llvmir-debug.mlir

+// RUN: mlir-translate -mlir-to-llvmir %s | FileCheck %s
+
+// CHECK-LABEL: define void @func_no_debug()
+// CHECK-NOT: !dbg
+llvm.func @func_no_debug() {
+  llvm.return loc(unknown)
+} loc(unknown)
+
+// CHECK-LABEL: define void @func_with_debug()
+// CHECK-SAME: !dbg ![[FUNC_LOC:[0-9]+]]
+llvm.func @func_with_debug() {
+  // CHECK: call void @func_no_debug()
+  // CHECK-NOT: !dbg
+  llvm.call @func_no_debug() : () -> () loc(unknown)
+
+  // CHECK: call void @func_no_debug(), !dbg ![[CALLSITE_LOC:[0-9]+]]
+  llvm.call @func_no_debug() : () -> () loc(callsite("mysource.cc":3:4 at "mysource.cc":5:6))
+
+  // CHECK: call void @func_no_debug(), !dbg ![[FILE_LOC:[0-9]+]]
+  llvm.call @func_no_debug() : () -> () loc("foo.mlir":1:2)
+
+  // CHECK: call void @func_no_debug(), !dbg ![[NAMED_LOC:[0-9]+]]
+  llvm.call @func_no_debug() : () -> () loc("named"("foo.mlir":10:10))
+
+  // CHECK: call void @func_no_debug(), !dbg ![[FUSED_LOC:[0-9]+]]
+  llvm.call @func_no_debug() : () -> () loc(fused[callsite("mysource.cc":1:1 at "mysource.cc":5:6), "mysource.cc":1:1])
+
+  llvm.return
+} loc("foo.mlir":1:1)
+
+// CHECK-DAG: ![[FUNC_LOC]] = distinct !DISubprogram{{.*}}, line: 1
+// CHECK-DAG: ![[CALLSITE_LOC]] = !DILocation(line: 3, column: 4,
+// CHECK-DAG: ![[FILE_LOC]] = !DILocation(line: 1, column: 2,
+// CHECK-DAG: ![[NAMED_LOC]] = !DILocation(line: 10, column: 10
+// CHECK-DAG: ![[FUSED_LOC]] = !DILocation(line: 1, column: 1

mlir/test/Target/llvmir.mlir

 // CHECK: declare void @free(i8*)
 
 
 //
 // Basic functionality: function and block conversion, function calls,
 // phi nodes, scalar type conversion, arithmetic operations.
 //
 
-// CHECK-LABEL: define void @empty() {
+// CHECK-LABEL: define void @empty()
 // CHECK-NEXT:    ret void
 // CHECK-NEXT:  }
 llvm.func @empty() {
   llvm.return
 }
 
 // CHECK-LABEL: @global_refs
 llvm.func @global_refs() {
llvm.func @global_refs() {
 
   llvm.return
 }
 
 // CHECK-LABEL: declare void @body(i64)
 llvm.func @body(!llvm.i64)
 
 
-// CHECK-LABEL: define void @simple_loop() {
+// CHECK-LABEL: define void @simple_loop()
 llvm.func @simple_loop() {
 // CHECK: br label %[[SIMPLE_bb1:[0-9]+]]
   llvm.br ^bb1
 
 // Constants are inlined in LLVM rather than a separate instruction.
 // CHECK: [[SIMPLE_bb1]]:
 // CHECK-NEXT: br label %[[SIMPLE_bb2:[0-9]+]]
 ^bb1:   // pred: ^bb0
^bb3:   // pred: ^bb2
   llvm.br ^bb2(%5 : !llvm.i64)
 
 // CHECK: [[SIMPLE_bb4]]:
 // CHECK-NEXT:    ret void
 ^bb4:   // pred: ^bb2
   llvm.return
 }
 
-// CHECK-LABEL: define void @simple_caller() {
+// CHECK-LABEL: define void @simple_caller()
 // CHECK-NEXT:   call void @simple_loop()
 // CHECK-NEXT:   ret void
 // CHECK-NEXT: }
 llvm.func @simple_caller() {
   llvm.call @simple_loop() : () -> ()
   llvm.return
 }
 
 //func @simple_indirect_caller() {
 //^bb0:
 //  %f = constant @simple_loop : () -> ()
 //  call_indirect %f() : () -> ()
 //  return
 //}
 
-// CHECK-LABEL: define void @ml_caller() {
+// CHECK-LABEL: define void @ml_caller()
 // CHECK-NEXT:   call void @simple_loop()
 // CHECK-NEXT:   call void @more_imperfectly_nested_loops()
 // CHECK-NEXT:   ret void
 // CHECK-NEXT: }
 llvm.func @ml_caller() {
   llvm.call @simple_loop() : () -> ()
   llvm.call @more_imperfectly_nested_loops() : () -> ()
   llvm.return
 }
 
 // CHECK-LABEL: declare i64 @body_args(i64)
 llvm.func @body_args(!llvm.i64) -> !llvm.i64
 // CHECK-LABEL: declare i32 @other(i64, i32)
 llvm.func @other(!llvm.i64, !llvm.i32) -> !llvm.i32
 
-// CHECK-LABEL: define i32 @func_args(i32 {{%.*}}, i32 {{%.*}}) {
+// CHECK-LABEL: define i32 @func_args(i32 {{%.*}}, i32 {{%.*}})
 // CHECK-NEXT: br label %[[ARGS_bb1:[0-9]+]]
 llvm.func @func_args(%arg0: !llvm.i32, %arg1: !llvm.i32) -> !llvm.i32 {
   %0 = llvm.mlir.constant(0 : i32) : !llvm.i32
   llvm.br ^bb1
 
 // CHECK: [[ARGS_bb1]]:
 // CHECK-NEXT: br label %[[ARGS_bb2:[0-9]+]]
 ^bb1:   // pred: ^bb0

 llvm.func @pre(!llvm.i64)
 
 // CHECK: declare void @body2(i64, i64)
 llvm.func @body2(!llvm.i64, !llvm.i64)
 
 // CHECK: declare void @post(i64)
 llvm.func @post(!llvm.i64)
 
-// CHECK-LABEL: define void @imperfectly_nested_loops() {
+// CHECK-LABEL: define void @imperfectly_nested_loops()
 // CHECK-NEXT:   br label %[[IMPER_bb1:[0-9]+]]
 llvm.func @imperfectly_nested_loops() {
   llvm.br ^bb1
 
 // CHECK: [[IMPER_bb1]]:
 // CHECK-NEXT:   br label %[[IMPER_bb2:[0-9]+]]
 ^bb1:   // pred: ^bb0
   %0 = llvm.mlir.constant(0 : index) : !llvm.i64

 
 // CHECK: declare void @mid(i64)
 llvm.func @mid(!llvm.i64)
 
 // CHECK: declare void @body3(i64, i64)
 llvm.func @body3(!llvm.i64, !llvm.i64)
 
 // A complete function transformation check.
-// CHECK-LABEL: define void @more_imperfectly_nested_loops() {
+// CHECK-LABEL: define void @more_imperfectly_nested_loops()
 // CHECK-NEXT:   br label %1
 // CHECK: 1:                                      ; preds = %0
 // CHECK-NEXT:   br label %2
 // CHECK: 2:                                      ; preds = %19, %1
 // CHECK-NEXT:   %3 = phi i64 [ %20, %19 ], [ 0, %1 ]
 // CHECK-NEXT:   %4 = icmp slt i64 %3, 42
 // CHECK-NEXT:   br i1 %4, label %5, label %21
 // CHECK: 5:                                      ; preds = %2
// CHECK-NEXT: %{{[0-9]+}} = load float, float* %{{[0-9]+}}
   %40 = llvm.add %39, %14 : !llvm.i64
   %41 = llvm.extractvalue %13[0] : !llvm<"{ float*, i64, i64 }">
   %42 = llvm.getelementptr %41[%40] : (!llvm<"float*">, !llvm.i64) -> !llvm<"float*">
   %43 = llvm.load %42 : !llvm<"float*">
 // CHECK-NEXT: ret void
   llvm.return
 }
 
-// CHECK-LABEL: define { float*, i64 } @memref_args_rets({ float* } {{%.*}}, { float*, i64 } {{%.*}}, { float*, i64 } {{%.*}}) {
+// CHECK-LABEL: define { float*, i64 } @memref_args_rets({ float* } {{%.*}}, { float*, i64 } {{%.*}}, { float*, i64 } {{%.*}})
 llvm.func @memref_args_rets(%arg0: !llvm<"{ float* }">, %arg1: !llvm<"{ float*, i64 }">, %arg2: !llvm<"{ float*, i64 }">) -> !llvm<"{ float*, i64 }"> {
   %0 = llvm.mlir.constant(7 : index) : !llvm.i64
 // CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index()
   %1 = llvm.call @get_index() : () -> !llvm.i64
   %2 = llvm.mlir.constant(4.200000e+01 : f32) : !llvm.float
 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float* } %{{[0-9]+}}, 0
 // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 7
 // CHECK-NEXT: store float 4.200000e+01, float* %{{[0-9]+}}

 // CHECK-NEXT: ret i64 %6
   llvm.return %6 : !llvm.i64
 }
 
 llvm.func @get_i64() -> !llvm.i64
 llvm.func @get_f32() -> !llvm.float
 llvm.func @get_memref() -> !llvm<"{ float*, i64, i64 }">
 
-// CHECK-LABEL: define { i64, float, { float*, i64, i64 } } @multireturn() {
+// CHECK-LABEL: define { i64, float, { float*, i64, i64 } } @multireturn()
 llvm.func @multireturn() -> !llvm<"{ i64, float, { float*, i64, i64 } }"> {
   %0 = llvm.call @get_i64() : () -> !llvm.i64
   %1 = llvm.call @get_f32() : () -> !llvm.float
   %2 = llvm.call @get_memref() : () -> !llvm<"{ float*, i64, i64 }">
 // CHECK:        %{{[0-9]+}} = insertvalue { i64, float, { float*, i64, i64 } } undef, i64 %{{[0-9]+}}, 0
 // CHECK-NEXT:   %{{[0-9]+}} = insertvalue { i64, float, { float*, i64, i64 } } %{{[0-9]+}}, float %{{[0-9]+}}, 1
 // CHECK-NEXT:   %{{[0-9]+}} = insertvalue { i64, float, { float*, i64, i64 } } %{{[0-9]+}}, { float*, i64, i64 } %{{[0-9]+}}, 2
 // CHECK-NEXT:   ret { i64, float, { float*, i64, i64 } } %{{[0-9]+}}
   %3 = llvm.mlir.undef : !llvm<"{ i64, float, { float*, i64, i64 } }">
   %4 = llvm.insertvalue %0, %3[0] : !llvm<"{ i64, float, { float*, i64, i64 } }">
   %5 = llvm.insertvalue %1, %4[1] : !llvm<"{ i64, float, { float*, i64, i64 } }">
   %6 = llvm.insertvalue %2, %5[2] : !llvm<"{ i64, float, { float*, i64, i64 } }">
   llvm.return %6 : !llvm<"{ i64, float, { float*, i64, i64 } }">
 }
 
 
-// CHECK-LABEL: define void @multireturn_caller() {
+// CHECK-LABEL: define void @multireturn_caller()
 llvm.func @multireturn_caller() {
 // CHECK-NEXT:   %1 = call { i64, float, { float*, i64, i64 } } @multireturn()
 // CHECK-NEXT:   [[ret0:%[0-9]+]] = extractvalue { i64, float, { float*, i64, i64 } } %1, 0
 // CHECK-NEXT:   [[ret1:%[0-9]+]] = extractvalue { i64, float, { float*, i64, i64 } } %1, 1
 // CHECK-NEXT:   [[ret2:%[0-9]+]] = extractvalue { i64, float, { float*, i64, i64 } } %1, 2
   %0 = llvm.call @multireturn() : () -> !llvm<"{ i64, float, { float*, i64, i64 } }">
   %1 = llvm.extractvalue %0[0] : !llvm<"{ i64, float, { float*, i64, i64 } }">
   %2 = llvm.extractvalue %0[1] : !llvm<"{ i64, float, { float*, i64, i64 } }">
// CHECK:   extractvalue { float*, i64, i64 } [[ret2]], 0
   %17 = llvm.mul %16, %12 : !llvm.i64
   %18 = llvm.add %17, %8 : !llvm.i64
   %19 = llvm.extractvalue %3[0] : !llvm<"{ float*, i64, i64 }">
   %20 = llvm.getelementptr %19[%18] : (!llvm<"float*">, !llvm.i64) -> !llvm<"float*">
   %21 = llvm.load %20 : !llvm<"float*">
   llvm.return
 }
 
-// CHECK-LABEL: define <4 x float> @vector_ops(<4 x float> {{%.*}}, <4 x i1> {{%.*}}, <4 x i64> {{%.*}}) {
+// CHECK-LABEL: define <4 x float> @vector_ops(<4 x float> {{%.*}}, <4 x i1> {{%.*}}, <4 x i64> {{%.*}})
 llvm.func @vector_ops(%arg0: !llvm<"<4 x float>">, %arg1: !llvm<"<4 x i1>">, %arg2: !llvm<"<4 x i64>">) -> !llvm<"<4 x float>"> {
   %0 = llvm.mlir.constant(dense<4.200000e+01> : vector<4xf32>) : !llvm<"<4 x float>">
 // CHECK-NEXT: %4 = fadd <4 x float> %0, <float 4.200000e+01, float 4.200000e+01, float 4.200000e+01, float 4.200000e+01>
   %1 = llvm.fadd %arg0, %0 : !llvm<"<4 x float>">
 // CHECK-NEXT: %5 = select <4 x i1> %1, <4 x float> %4, <4 x float> %0
   %2 = llvm.select %arg1, %1, %arg0 : !llvm<"<4 x i1>">, !llvm<"<4 x float>">
 // CHECK-NEXT: %6 = sdiv <4 x i64> %2, %2
   %3 = llvm.sdiv %arg2, %arg2 : !llvm<"<4 x i64>">
// CHECK-NEXT: fneg float %0
 
   llvm.return %10 : !llvm<"{ float, i32 }">
 }
 
 //
 // Indirect function calls
 //
 
-// CHECK-LABEL: define void @indirect_const_call(i64 {{%.*}}) {
+// CHECK-LABEL: define void @indirect_const_call(i64 {{%.*}})
 llvm.func @indirect_const_call(%arg0: !llvm.i64) {
 // CHECK-NEXT:  call void @body(i64 %0)
   %0 = llvm.mlir.constant(@body) : !llvm<"void (i64)*">
   llvm.call %0(%arg0) : (!llvm.i64) -> ()
 // CHECK-NEXT:  ret void
   llvm.return
 }
 
-// CHECK-LABEL: define i32 @indirect_call(i32 (float)* {{%.*}}, float {{%.*}}) {
+// CHECK-LABEL: define i32 @indirect_call(i32 (float)* {{%.*}}, float {{%.*}})
 llvm.func @indirect_call(%arg0: !llvm<"i32 (float)*">, %arg1: !llvm.float) -> !llvm.i32 {
 // CHECK-NEXT:  %3 = call i32 %0(float %1)
   %0 = llvm.call %arg0(%arg1) : (!llvm.float) -> !llvm.i32
 // CHECK-NEXT:  ret i32 %3
   llvm.return %0 : !llvm.i32
 }
 
 //
 // Check that we properly construct phi nodes in the blocks that have the same
 // predecessor more than once.
 //
 
-// CHECK-LABEL: define void @cond_br_arguments(i1 {{%.*}}, i1 {{%.*}}) {
+// CHECK-LABEL: define void @cond_br_arguments(i1 {{%.*}}, i1 {{%.*}})
 llvm.func @cond_br_arguments(%arg0: !llvm.i1, %arg1: !llvm.i1) {
 // CHECK-NEXT:   br i1 %0, label %3, label %5
   llvm.cond_br %arg0, ^bb1(%arg0 : !llvm.i1), ^bb2
 
 // CHECK:      3:
 // CHECK-NEXT:   %4 = phi i1 [ %1, %5 ], [ %0, %2 ]
 ^bb1(%0 : !llvm.i1):
 // CHECK-NEXT:   ret void
   llvm.return
 
 // CHECK:      5:
 ^bb2:
 // CHECK-NEXT:   br label %3
   llvm.br ^bb1(%arg1 : !llvm.i1)
 }
 
-// CHECK-LABEL: define void @llvm_noalias(float* noalias {{%*.}}) {
+// CHECK-LABEL: define void @llvm_noalias(float* noalias {{%*.}})
 llvm.func @llvm_noalias(%arg0: !llvm<"float*"> {llvm.noalias = true}) {
   llvm.return
 }
 
 // CHECK-LABEL: @llvm_varargs(...)
 llvm.func @llvm_varargs(...)
 
 llvm.func @intpointerconversion(%arg0 : !llvm.i32) -> !llvm.i32 {

mlir/tools/mlir-cuda-runner/mlir-cuda-runner.cpp

 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/LLVMIR/NVVMDialect.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Module.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Support/JitRunner.h"
 #include "mlir/Transforms/DialectConversion.h"
+#include "mlir/Transforms/Passes.h"
 
 #include "cuda.h"
 
 using namespace mlir;
 
 inline void emit_cuda_error(const llvm::Twine &message, const char *buffer,
                             CUresult error, Location loc) {
   emitError(loc, message.concat(" failed with error code ")

 }
 
 static LogicalResult runMLIRPasses(ModuleOp m) {
   PassManager pm(m.getContext());
   applyPassManagerCLOptions(pm);
 
   pm.addPass(createGpuKernelOutliningPass());
   auto &kernelPm = pm.nest<gpu::GPUModuleOp>();
+  kernelPm.addPass(createStripDebugInfoPass());
   kernelPm.addPass(createLowerGpuOpsToNVVMOpsPass());
   kernelPm.addPass(createConvertGPUKernelToCubinPass(&compilePtxToCubin));
   pm.addPass(createLowerToLLVMPass());
   pm.addPass(createConvertGpuLaunchFuncToCudaCallsPass());
 
   return pm.run(m);
 }
 
 int main(int argc, char **argv) {
   registerPassManagerCLOptions();
   return mlir::JitRunnerMain(argc, argv, &runMLIRPasses);
 }