[mlir][llvm] Make the import of LLVM IR intrinsics extensible.

[gysit]

Summary

The revision introduces the LLVMImportDialectInterface to make the
import of LLVM IR intrinsics extensible. It uses a dialect interface
that enables external projects to provide their own conversion functions
for custom intrinsics. These conversion functions can rely on the
ModuleImport class to perform support tasks such as mapping LLVM
values to MLIR values or for converting types between the two worlds.

The implementation largely mirrors the export implementation. One major
difference is the dispatch to the appropriate dialect interface, since
LLVM IR intrinsics have no direct association to an MLIR dialect. The
dialect interfaces thus have to publish the supported intrinsics to
ensure incoming conversion calls are dispatched to the right dialect
interface.

The revision implements the extensible intrinsic import discussed as
part of the "extensible llvm ir import" rfc:
https://discourse.llvm.org/t/rfc-extensible-llvm-ir-import/67256/6

[Dinistro]

I skimmed over the changes and added a small NIT comment. I'm not an expert on the LLVM import, so other reviews will be required.

mlir/include/mlir/Target/LLVMIR/LLVMImportInterface.h

57

Returning an ArrayRef<unsigned> might be a good idea. Explicitly creating a new SmallVector if one only reads from it (as is done further down) seems a waste.

[gysit]

Address review comment.

[gysit]

Better error message and translation naming.

[Dinistro]

mlir/include/mlir/Target/LLVMIR/LLVMImportInterface.h

71

NIT: I find this name a bit misleading as the main purpose of this function seems to be the initialization to the supported intrinsics. Consider renaming the function into something like initializeSupportedIntrinsics.

mlir/include/mlir/Target/LLVMIR/ModuleImport.h

49

NIT: As above, I would expect a query function to return said list but this function initializes it.

[gysit]

Address review comments.

[ftynse]

I think we need a bit of testing here, like checking that tblgen'ed code is what we expect it to be.

mlir/include/mlir/Target/LLVMIR/Dialect/LLVMIR/LLVMIRToLLVMImport.h

2

Nit: could we call this LLVMIRToLLVMTranslation for symmetry with the adjacent file?

mlir/include/mlir/Target/LLVMIR/Import.h

33–37

Typo: the the

mlir/include/mlir/Target/LLVMIR/LLVMImportInterface.h

57

Please document what the result refers to here. It's unclear how an arrayref of integers maps to intrinsics.

76–85

Nit: consider swapping the condition + using continue to decrease the number of highly-indented code.

mlir/include/mlir/Tools/mlir-translate/Translation.h

107

Nit: consider a typedef instead of spelling out the function object type every time, similarly yo TranslateSourceMgrToMLIRFunction above.

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

46

Please comment why you need to register DLTI here.

[gysit]

Address review comments and ensure all dialects and extensions are loaded.

Thanks for the review!

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

auto operands = moduleTranslation.lookupValues(opInst.getOperands());
       "moduleTranslation.setAccessGroupsMetadata(op, inst);",
       "(void) inst;")
     # !if(!gt(requiresAliasScope, 0),
       "moduleTranslation.setAliasScopeMetadata(op, inst);",
       "(void) inst;")
     # !if(!gt(numResults, 0), "$res = inst;", "");
 
   string mlirBuilder = [{
-    FailureOr<SmallVector<Value>> mlirOperands = convertValues(llvmOperands);
+    FailureOr<SmallVector<Value>> mlirOperands =
+      moduleImport.convertValues(llvmOperands);
     if (failed(mlirOperands))
       return failure();
     SmallVector<Type> resultTypes =
     }] # !if(!gt(numResults, 0), "{$_resultType};", "{};") # [{
     auto op = $_builder.create<$_qualCppClassName>(
       $_location, resultTypes, *mlirOperands);
     }] # !if(!gt(requiresFastmath, 0),
-      "setFastmathFlagsAttr(inst, op);", "")
+      "moduleImport.setFastmathFlagsAttr(inst, op);", "")
     # !if(!gt(numResults, 0), "$res = op;", "(void)op;");
 }
 
 // Base class for LLVM intrinsic operations, should not be used directly. Places
 // the intrinsic into the LLVM dialect and prefixes its name with "intr.".
 class LLVM_IntrOp<string mnem, list<int> overloadedResults,
                   list<int> overloadedOperands, list<Trait> traits,
                   int numResults, bit requiresAccessGroup = 0,

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

class LLVM_FloatArithmeticOp<string mnemonic, string instName,
                              list<Trait> traits = []> :
     LLVM_ArithmeticOpBase<LLVM_AnyFloat, mnemonic, instName,
     !listconcat([DeclareOpInterfaceMethods<FastmathFlagsInterface>], traits)> {
   dag fmfArg = (
     ins DefaultValuedAttr<LLVM_FastmathFlagsAttr, "{}">:$fastmathFlags);
   let arguments = !con(commonArgs, fmfArg);
   string mlirBuilder = [{
     auto op = $_builder.create<$_qualCppClassName>($_location, $lhs, $rhs);
-    setFastmathFlagsAttr(inst, op);
+    moduleImport.setFastmathFlagsAttr(inst, op);
     $res = op;
   }];
 }
 
 // Class for arithmetic unary operations.
 class LLVM_UnaryFloatArithmeticOp<Type type, string mnemonic,
                                   string instName, list<Trait> traits = []> :
     LLVM_Op<mnemonic,
            !listconcat([Pure, SameOperandsAndResultType, DeclareOpInterfaceMethods<FastmathFlagsInterface>], traits)>,
     LLVM_Builder<"$res = builder.Create" # instName # "($operand);"> {
   let arguments = (
     ins type:$operand,
     DefaultValuedAttr<LLVM_FastmathFlagsAttr, "{}">:$fastmathFlags);
   let results = (outs type:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "$operand custom<LLVMOpAttrs>(attr-dict) `:` type($res)";
   string llvmInstName = instName;
   string mlirBuilder = [{
     auto op = $_builder.create<$_qualCppClassName>($_location, $operand);
-    setFastmathFlagsAttr(inst, op);
+    moduleImport.setFastmathFlagsAttr(inst, op);
     $res = op;
    }];
 }
 
 // Integer binary operations.
 def LLVM_AddOp : LLVM_IntArithmeticOp<"add", "Add", [Commutative]>;
 def LLVM_SubOp : LLVM_IntArithmeticOp<"sub", "Sub">;
 def LLVM_MulOp : LLVM_IntArithmeticOp<"mul", "Mul", [Commutative]>;
def LLVM_FCmpOp : LLVM_ArithmeticCmpOp<"fcmp", [
   string llvmInstName = "FCmp";
   string llvmBuilder = [{
     $res = builder.CreateFCmp(getLLVMCmpPredicate($predicate), $lhs, $rhs);
   }];
   string mlirBuilder = [{
     auto *fCmpInst = cast<llvm::FCmpInst>(inst);
     auto op = $_builder.create<$_qualCppClassName>(
       $_location, getFCmpPredicate(fCmpInst->getPredicate()), $lhs, $rhs);
-    setFastmathFlagsAttr(inst, op);
+    moduleImport.setFastmathFlagsAttr(inst, op);
     $res = op;
   }];
   // Set the $predicate index to -1 to indicate there is no matching operand
   // and decrement the following indices.
   list<int> llvmArgIndices = [-1, 0, 1, 2];
 }
 
 // Floating point binary operations.
llvm::Type *elementType = moduleTranslation.convertType(
                    : op.getType().cast<LLVMPointerType>().getElementType());
     auto *inst = builder.CreateAlloca(elementType, addrSpace, $arraySize);
     }] # setAlignmentCode # [{
     $res = inst;
   }];
   // FIXME: Import attributes.
   string mlirBuilder = [{
     auto *allocaInst = cast<llvm::AllocaInst>(inst);
-    Type allocatedType = convertType(allocaInst->getAllocatedType());
+    Type allocatedType =
+      moduleImport.convertType(allocaInst->getAllocatedType());
     unsigned alignment = allocaInst->getAlign().value();
     $res = $_builder.create<LLVM::AllocaOp>(
       $_location, $_resultType, allocatedType, $arraySize, alignment);
   }];
   let builders = [
     OpBuilder<(ins "Type":$resultType, "Value":$arraySize,
                "unsigned":$alignment),
     [{
def LLVM_ReturnOp : LLVM_TerminatorOp<"return", [Pure, ReturnLike]> {
   string llvmInstName = "Ret";
   string llvmBuilder = [{
     if ($_numOperands != 0)
       builder.CreateRet($arg);
     else
       builder.CreateRetVoid();
   }];
   string mlirBuilder = [{
-    FailureOr<SmallVector<Value>> mlirOperands = convertValues(llvmOperands);
+    FailureOr<SmallVector<Value>> mlirOperands =
+      moduleImport.convertValues(llvmOperands);
     if (failed(mlirOperands))
       return failure();
     $_builder.create<LLVM::ReturnOp>($_location, *mlirOperands);
   }];
 }
 
 def LLVM_ResumeOp : LLVM_TerminatorOp<"resume"> {
   let arguments = (ins LLVM_Type:$value);

mlir/include/mlir/Target/LLVMIR/Dialect/All.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TARGET_LLVMIR_DIALECT_ALL_H
 #define MLIR_TARGET_LLVMIR_DIALECT_ALL_H
 
 #include "mlir/Target/LLVMIR/Dialect/AMX/AMXToLLVMIRTranslation.h"
 #include "mlir/Target/LLVMIR/Dialect/ArmNeon/ArmNeonToLLVMIRTranslation.h"
 #include "mlir/Target/LLVMIR/Dialect/ArmSVE/ArmSVEToLLVMIRTranslation.h"
+#include "mlir/Target/LLVMIR/Dialect/LLVMIR/LLVMIRToLLVMImport.h"
 #include "mlir/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.h"
 #include "mlir/Target/LLVMIR/Dialect/NVVM/NVVMToLLVMIRTranslation.h"
 #include "mlir/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.h"
 #include "mlir/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.h"
 #include "mlir/Target/LLVMIR/Dialect/ROCDL/ROCDLToLLVMIRTranslation.h"
 #include "mlir/Target/LLVMIR/Dialect/X86Vector/X86VectorToLLVMIRTranslation.h"
 
 namespace mlir {
 class DialectRegistry;
 
 /// Registers all dialects that can be translated to LLVM IR and the
 /// corresponding translation interfaces.
 static inline void registerAllToLLVMIRTranslations(DialectRegistry &registry) {
   registerArmNeonDialectTranslation(registry);
   registerAMXDialectTranslation(registry);
   registerArmSVEDialectTranslation(registry);
   registerLLVMDialectTranslation(registry);
   registerNVVMDialectTranslation(registry);
   registerOpenACCDialectTranslation(registry);
   registerOpenMPDialectTranslation(registry);
   registerROCDLDialectTranslation(registry);
   registerX86VectorDialectTranslation(registry);
 }
+
+/// Registers all dialects that can be translated from LLVM IR and the
+/// corresponding translation interfaces.
+static inline void
+registerAllFromLLVMIRTranslations(DialectRegistry &registry) {
+  registerLLVMDialectImport(registry);
+}
 } // namespace mlir
 
 #endif // MLIR_TARGET_LLVMIR_DIALECT_ALL_H

mlir/include/mlir/Target/LLVMIR/Dialect/LLVMIR/LLVMIRToLLVMImport.h

+//===- LLVMIRToLLVMImport.h - LLVM Dialect to LLVM IR------------*- 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 provides registration calls for the LLVM IR to LLVM dialect import.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TARGET_LLVMIR_DIALECT_LLVMIR_LLVMIRTOLLVMIMPORT_H
+#define MLIR_TARGET_LLVMIR_DIALECT_LLVMIR_LLVMIRTOLLVMIMPORT_H
+
+namespace mlir {
+
+class DialectRegistry;
+class MLIRContext;
+
+/// Registers the LLVM dialect and its import from LLVM IR in the given
+/// registry.
+void registerLLVMDialectImport(DialectRegistry &registry);
+
+/// Registers the LLVM dialect and its import from LLVM IR with the given
+/// context.
+void registerLLVMDialectImport(MLIRContext &context);
+
+} // namespace mlir
+
+#endif // MLIR_TARGET_LLVMIR_DIALECT_LLVMIR_LLVMIRTOLLVMIMPORT_H

mlir/include/mlir/Target/LLVMIR/Import.h

 } // namespace llvm
 
 namespace mlir {
 
 class DataLayoutSpecInterface;
 class MLIRContext;
 class ModuleOp;
 
-/// Convert the given LLVM module into MLIR's LLVM dialect.  The LLVM context is
-/// extracted from the registered LLVM IR dialect. In case of error, report it
-/// to the error handler registered with the MLIR context, if any (obtained from
-/// the MLIR module), and return `{}`.
+/// Translates the LLVM module into an MLIR module living in the the given
+/// context. The translation supports operations from any dialect that has a
+/// registered implementation of the LLVMImportDialectInterface. It returns
+/// nullptr if the translation fails and reports errors using the error handler
+/// registered with the MLIR context.
 OwningOpRef<ModuleOp>
 translateLLVMIRToModule(std::unique_ptr<llvm::Module> llvmModule,
                         MLIRContext *context);
 
 /// Translate the given LLVM data layout into an MLIR equivalent using the DLTI
 /// dialect.
 DataLayoutSpecInterface translateDataLayout(const llvm::DataLayout &dataLayout,
                                             MLIRContext *context);
 
 } // namespace mlir
 
 #endif // MLIR_TARGET_LLVMIR_IMPORT_H

mlir/include/mlir/Target/LLVMIR/LLVMImportInterface.h

+//===- LLVMImportInterface.h - Import from LLVM interface -------*- 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 header file defines dialect interfaces for the LLVM IR import.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TARGET_LLVMIR_LLVMIMPORTINTERFACE_H
+#define MLIR_TARGET_LLVMIR_LLVMIMPORTINTERFACE_H
+
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/BuiltinAttributes.h"
+#include "mlir/IR/Diagnostics.h"
+#include "mlir/IR/DialectInterface.h"
+#include "mlir/IR/Location.h"
+#include "mlir/Support/LogicalResult.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/Support/FormatVariadic.h"
+
+namespace llvm {
+class IRBuilderBase;
+} // namespace llvm
+
+namespace mlir {
+namespace LLVM {
+class ModuleImport;
+} // namespace LLVM
+
+/// Base class for dialect interfaces used to import LLVM IR. Dialects that can
+/// be imported should provide an implementation of this interface for the
+/// supported intrinsics. The interface may be implemented in a separate library
+/// to avoid the "main" dialect library depending on LLVM IR. The interface can
+/// be attached using the delayed registration mechanism available in
+/// DialectRegistry.
+class LLVMImportDialectInterface
+    : public DialectInterface::Base<LLVMImportDialectInterface> {
+public:
+  LLVMImportDialectInterface(Dialect *dialect) : Base(dialect) {}
+
+  /// Hook for derived dialect interfaces to implement the import of
+  /// intrinsics into MLIR.
+  virtual LogicalResult
+  convertIntrinsic(OpBuilder &builder, llvm::CallInst *inst,
+                   LLVM::ModuleImport &moduleImport) const {
+    return failure();
+  }
+
+  /// Hook for derived dialect interfaces to publish the supported intrinsics.
+  virtual ArrayRef<unsigned> getSupportedIntrinsics() const { return {}; }
+};
+
+/// Interface collection for the import of LLVM IR that dispatches to a concrete
+/// dialect interface implementation. Queries the dialect interfaces to obtain a
+/// list of the supported LLVM IR constructs and then builds a mapping for the
+/// efficient dispatch.
+class LLVMImportInterface
+    : public DialectInterfaceCollection<LLVMImportDialectInterface> {
+public:
+  using Base::Base;
+
+  /// Queries all dialect interfaces to build a map from intrinsic identifiers
+  /// to the dialect interface that supports importing the intrinsic. Returns
+  /// failure if the mapping is not unique.
+  LogicalResult querySupportedIntrinsics() {
+    for (const LLVMImportDialectInterface &iface : *this) {
+      for (unsigned id : iface.getSupportedIntrinsics()) {
+        if (intrinsicToDialect.count(id)) {
+          Location loc = UnknownLoc::get(iface.getContext());
+          return emitError(
+              loc, llvm::formatv(
+                       "expected unique conversion for intrinsic ({0}), but "
+                       "got conflicting {1} and {2} conversions",
+                       id, iface.getDialect()->getNamespace(),
+                       intrinsicToDialect.lookup(id)->getNamespace()));
+        }
+        intrinsicToDialect[id] = iface.getDialect();
+      }
+    }
+
+    return success();
+  }
+
+  /// Converts the LLVM intrinsic to an MLIR operation if a conversion exists.
+  /// Returns failure otherwise.
+  LogicalResult convertIntrinsic(OpBuilder &builder, llvm::CallInst *inst,
+                                 LLVM::ModuleImport &moduleImport) const {
+    // Lookup the dialect interface for the given intrinsic.
+    Dialect *dialect = intrinsicToDialect.lookup(inst->getIntrinsicID());
+    if (!dialect)
+      return failure();
+
+    // Dispatch the conversion to the dialect interface.
+    const LLVMImportDialectInterface *iface = getInterfaceFor(dialect);
+    assert(iface && "expected to find a dialect interface");
+    return iface->convertIntrinsic(builder, inst, moduleImport);
+  }
+
+  /// Returns true if the given LLVM IR intrinsic is convertible to an MLIR
+  /// operation.
+  bool isConvertibleIntrinsic(llvm::Intrinsic::ID id) {
+    return intrinsicToDialect.count(id);
+  }
+
+private:
+  DenseMap<unsigned, Dialect *> intrinsicToDialect;
+};
+
+} // namespace mlir
+
+#endif // MLIR_TARGET_LLVMIR_LLVMIMPORTINTERFACE_H

mlir/include/mlir/Target/LLVMIR/ModuleImport.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TARGET_LLVMIR_MODULEIMPORT_H
 #define MLIR_TARGET_LLVMIR_MODULEIMPORT_H
 
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/Target/LLVMIR/Import.h"
+#include "mlir/Target/LLVMIR/LLVMImportInterface.h"
 #include "mlir/Target/LLVMIR/TypeFromLLVM.h"
 
 namespace llvm {
 class BasicBlock;
 class CallBase;
 class Function;
 class Instruction;
 class Value;

 /// between the original and translated globals, basic blocks, and values used
 /// during the translation. Additionally, it keeps track of the current constant
 /// insertion point since LLVM immediate values translate to MLIR operations
 /// that are introduced at the beginning of the region.
 class ModuleImport {
 public:
   ModuleImport(ModuleOp mlirModule, std::unique_ptr<llvm::Module> llvmModule);
 
+  /// Queries the dialect interfaces for the supported LLVM IR intrinsics.
+  LogicalResult querySupportedIntrinsics() {
+    return iface.querySupportedIntrinsics();
+  }
+
+  /// Converts all functions of the LLVM module to MLIR functions.
+  LogicalResult convertFunctions();
+
+  /// Converts all global variables of the LLVM module to MLIR global variables.
+  LogicalResult convertGlobals();
+
   /// Stores the mapping between an LLVM value and its MLIR counterpart.
   void mapValue(llvm::Value *llvm, Value mlir) { mapValue(llvm) = mlir; }
 
   /// Provides write-once access to store the MLIR value corresponding to the
   /// given LLVM value.
   Value &mapValue(llvm::Value *value) {
     Value &mlir = valueMapping[value];
     assert(mlir == nullptr &&
public:
   /// Translates the debug location.
   Location translateLoc(llvm::DILocation *loc);
 
   /// Converts the type from LLVM to MLIR LLVM dialect.
   Type convertType(llvm::Type *type) {
     return typeTranslator.translateType(type);
   }
 
-  /// Converts an LLVM intrinsic to an MLIR LLVM dialect operation if an MLIR
-  /// counterpart exists. Otherwise, returns failure.
-  LogicalResult convertIntrinsic(OpBuilder &odsBuilder, llvm::CallInst *inst,
-                                 llvm::Intrinsic::ID intrinsicID);
-
-  /// Converts an LLVM instruction to an MLIR LLVM dialect operation if an MLIR
-  /// counterpart exists. Otherwise, returns failure.
-  LogicalResult convertOperation(OpBuilder &odsBuilder,
-                                 llvm::Instruction *inst);
-
   /// Imports `func` into the current module.
   LogicalResult processFunction(llvm::Function *func);
 
   /// Converts function attributes of LLVM Function \p func
   /// into LLVM dialect attributes of LLVMFuncOp \p funcOp.
   void processFunctionAttributes(llvm::Function *func, LLVMFuncOp funcOp);
 
   /// Imports `globalVar` as a GlobalOp, creating it if it doesn't exist.
   GlobalOp processGlobal(llvm::GlobalVariable *globalVar);
 
-  /// Converts all functions of the LLVM module to MLIR functions.
-  LogicalResult convertFunctions();
-
-  /// Converts all global variables of the LLVM module to MLIR global variables.
-  LogicalResult convertGlobals();
+  /// Sets the fastmath flags attribute for the imported operation `op` given
+  /// the original instruction `inst`. Asserts if the operation does not
+  /// implement the fastmath interface.
+  void setFastmathFlagsAttr(llvm::Instruction *inst, Operation *op) const;
 
 private:
   /// Clears the block and value mapping before processing a new region.
   void clearBlockAndValueMapping() {
     valueMapping.clear();
     blockMapping.clear();
   }
   /// Sets the constant insertion point to the start of the given block.
   void setConstantInsertionPointToStart(Block *block) {
     constantInsertionBlock = block;
     constantInsertionOp = nullptr;
   }
 
-  /// Sets the fastmath flags attribute for the imported operation `op` given
-  /// the original instruction `inst`. Asserts if the operation does not
-  /// implement the fastmath interface.
-  void setFastmathFlagsAttr(llvm::Instruction *inst, Operation *op) const;
   /// Returns personality of `func` as a FlatSymbolRefAttr.
   FlatSymbolRefAttr getPersonalityAsAttr(llvm::Function *func);
   /// Imports `bb` into `block`, which must be initially empty.
   LogicalResult processBasicBlock(llvm::BasicBlock *bb, Block *block);
+  /// Converts an LLVM intrinsic to an MLIR LLVM dialect operation if an MLIR
+  /// counterpart exists. Otherwise, returns failure.
+  LogicalResult convertIntrinsic(OpBuilder &odsBuilder, llvm::CallInst *inst);
+  /// Converts an LLVM instruction to an MLIR LLVM dialect operation if an MLIR
+  /// counterpart exists. Otherwise, returns failure.
+  LogicalResult convertInstruction(OpBuilder &odsBuilder,
+                                   llvm::Instruction *inst);
   /// Imports `inst` and populates valueMapping[inst] with the result of the
   /// imported operation.
   LogicalResult processInstruction(llvm::Instruction *inst);
   /// Converts the `branch` arguments in the order of the phi's found in
   /// `target` and appends them to the `blockArguments` to attach to the
   /// generated branch operation. The `blockArguments` thus have the same order
   /// as the phi's in `target`.
   LogicalResult convertBranchArgs(llvm::Instruction *branch,
private:
   Operation *globalInsertionOp = nullptr;
   /// The current context.
   MLIRContext *context;
   /// The MLIR module being created.
   ModuleOp mlirModule;
   /// The LLVM module being imported.
   std::unique_ptr<llvm::Module> llvmModule;
 
+  /// A dialect interface collection used for dispatching the import to specific
+  /// dialects.
+  LLVMImportInterface iface;
+
   /// Function-local mapping between original and imported block.
   DenseMap<llvm::BasicBlock *, Block *> blockMapping;
   /// Function-local mapping between original and imported values.
   DenseMap<llvm::Value *, Value> valueMapping;
   /// Uniquing map of GlobalVariables.
   DenseMap<llvm::GlobalVariable *, GlobalOp> globals;
   /// The stateful type translator (contains named structs).
   LLVM::TypeFromLLVMIRTranslator typeTranslator;
   /// Stateful debug information importer.
   std::unique_ptr<detail::DebugImporter> debugImporter;
 };
 
 } // namespace LLVM
 } // namespace mlir
 
 #endif // MLIR_TARGET_LLVMIR_MODULEIMPORT_H

mlir/include/mlir/Tools/mlir-translate/Translation.h

 ///   }
 ///   } // namespace mlir
 ///
 /// \{
 struct TranslateToMLIRRegistration {
   TranslateToMLIRRegistration(
       llvm::StringRef name, llvm::StringRef description,
       const TranslateSourceMgrToMLIRFunction &function,
+      const std::function<void(DialectRegistry &)> &dialectRegistration =
+          [](DialectRegistry &) {},
       Optional<llvm::Align> inputAlignment = std::nullopt);
   TranslateToMLIRRegistration(
       llvm::StringRef name, llvm::StringRef description,
       const TranslateRawSourceMgrToMLIRFunction &function,
+      const std::function<void(DialectRegistry &)> &dialectRegistration =
+          [](DialectRegistry &) {},
       Optional<llvm::Align> inputAlignment = std::nullopt);
   TranslateToMLIRRegistration(
       llvm::StringRef name, llvm::StringRef description,
       const TranslateStringRefToMLIRFunction &function,
+      const std::function<void(DialectRegistry &)> &dialectRegistration =
+          [](DialectRegistry &) {},
       Optional<llvm::Align> inputAlignment = std::nullopt);
 };
 
 struct TranslateFromMLIRRegistration {
   TranslateFromMLIRRegistration(
       llvm::StringRef name, llvm::StringRef description,
       const TranslateFromMLIRFunction &function,
       const std::function<void(DialectRegistry &)> &dialectRegistration =

mlir/lib/Target/LLVMIR/CMakeLists.txt

add_mlir_translation_library(MLIRToLLVMIRTranslationRegistration
   MLIRLLVMToLLVMIRTranslation
   MLIRNVVMToLLVMIRTranslation
   MLIROpenACCToLLVMIRTranslation
   MLIROpenMPToLLVMIRTranslation
   MLIRROCDLToLLVMIRTranslation
   )
 
 add_mlir_translation_library(MLIRTargetLLVMIRImport
-  ConvertFromLLVMIR.cpp
   DebugImporter.cpp
   ModuleImport.cpp
   TypeFromLLVM.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Target/LLVMIR
 
   LINK_COMPONENTS
   Core
   IRReader
 
   LINK_LIBS PUBLIC
   MLIRDLTIDialect
   MLIRLLVMDialect
   MLIRTranslateLib
   )
+
+add_mlir_translation_library(MLIRFromLLVMIRTranslationRegistration
+  ConvertFromLLVMIR.cpp
+
+  LINK_LIBS PUBLIC
+  MLIRLLVMIRToLLVMImport
+  )

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

 //===- ConvertFromLLVMIR.cpp - MLIR to LLVM IR 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 function that registers the translation between
 // LLVM IR and the MLIR LLVM dialect.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/Dialect/DLTI/DLTI.h"
 #include "mlir/IR/BuiltinOps.h"
+#include "mlir/Target/LLVMIR/Dialect/All.h"
 #include "mlir/Target/LLVMIR/Import.h"
 #include "mlir/Tools/mlir-translate/Translation.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Support/SourceMgr.h"
 
 using namespace mlir;
 
 namespace mlir {
 void registerFromLLVMIRTranslation() {
   TranslateToMLIRRegistration registration(
-      "import-llvm", "translate mlir to llvmir",
+      "import-llvm", "translate llvmir to mlir",
       [](llvm::SourceMgr &sourceMgr,
          MLIRContext *context) -> OwningOpRef<Operation *> {
         llvm::SMDiagnostic err;
         llvm::LLVMContext llvmContext;
         std::unique_ptr<llvm::Module> llvmModule =
             llvm::parseIR(*sourceMgr.getMemoryBuffer(sourceMgr.getMainFileID()),
                           err, llvmContext);
         if (!llvmModule) {
           std::string errStr;
           llvm::raw_string_ostream errStream(errStr);
           err.print(/*ProgName=*/"", errStream);
           emitError(UnknownLoc::get(context)) << errStream.str();
           return {};
         }
         return translateLLVMIRToModule(std::move(llvmModule), context);
+      },
+      [](DialectRegistry &registry) {
+        registry.insert<DLTIDialect>();
+        registerAllFromLLVMIRTranslations(registry);
       });
 }
 } // namespace mlir

mlir/lib/Target/LLVMIR/Dialect/LLVMIR/CMakeLists.txt

+set(LLVM_OPTIONAL_SOURCES
+  LLVMIRToLLVMImport.cpp
+  LLVMToLLVMIRTranslation.cpp
+  )
+
+add_mlir_translation_library(MLIRLLVMIRToLLVMImport
+  LLVMIRToLLVMImport.cpp
+
+  LINK_COMPONENTS
+  Core
+
+  LINK_LIBS PUBLIC
+  MLIRIR
+  MLIRLLVMDialect
+  MLIRSupport
+  MLIRTargetLLVMIRImport
+  )
+
 add_mlir_translation_library(MLIRLLVMToLLVMIRTranslation
   LLVMToLLVMIRTranslation.cpp
 
   LINK_COMPONENTS
   Core
 
   LINK_LIBS PUBLIC
   MLIRIR
   MLIRLLVMDialect
   MLIRSupport
   MLIRTargetLLVMIRExport
   )

mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMIRToLLVMImport.cpp

+//===- LLVMIRToLLVMImport.cpp - Translate LLVM IR to LLVM dialect ---------===//
+//
+// 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 import of LLVM IR into the MLIR LLVM dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Target/LLVMIR/Dialect/LLVMIR/LLVMIRToLLVMImport.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Support/LLVM.h"
+#include "mlir/Target/LLVMIR/ModuleImport.h"
+
+#include "llvm/ADT/PostOrderIterator.h"
+#include "llvm/ADT/ScopeExit.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/InlineAsm.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
+
+using namespace mlir;
+using namespace mlir::LLVM;
+using namespace mlir::LLVM::detail;
+
+#include "mlir/Dialect/LLVMIR/LLVMConversionEnumsFromLLVM.inc"
+
+/// Returns true if the LLVM IR intrinsic is convertible to an MLIR LLVM dialect
+/// intrinsic. Returns false otherwise.
+static bool isConvertibleIntrinsic(llvm::Intrinsic::ID id) {
+  static const DenseSet<unsigned> convertibleIntrinsics = {
+#include "mlir/Dialect/LLVMIR/LLVMConvertibleLLVMIRIntrinsics.inc"
+  };
+  return convertibleIntrinsics.contains(id);
+}
+
+/// Returns the list of LLVM IR intrinsic identifiers that are convertible to
+/// MLIR LLVM dialect intrinsics.
+static ArrayRef<unsigned> getSupportedIntrinsicsImpl() {
+  static const SmallVector<unsigned> convertibleIntrinsics = {
+#include "mlir/Dialect/LLVMIR/LLVMConvertibleLLVMIRIntrinsics.inc"
+  };
+  return convertibleIntrinsics;
+}
+
+/// Converts the LLVM intrinsic to an MLIR LLVM dialect operation if a
+/// conversion exits. Returns failure otherwise.
+static LogicalResult convertIntrinsicImpl(OpBuilder &odsBuilder,
+                                          llvm::CallInst *inst,
+                                          LLVM::ModuleImport &moduleImport) {
+  llvm::Intrinsic::ID intrinsicID = inst->getIntrinsicID();
+
+  // Check if the intrinsic is convertible to an MLIR dialect counterpart and
+  // copy the arguments to an an LLVM operands array reference for conversion.
+  if (isConvertibleIntrinsic(intrinsicID)) {
+    SmallVector<llvm::Value *> args(inst->args());
+    ArrayRef<llvm::Value *> llvmOperands(args);
+#include "mlir/Dialect/LLVMIR/LLVMIntrinsicFromLLVMIRConversions.inc"
+  }
+
+  return failure();
+}
+
+namespace {
+
+/// Implementation of the dialect interface that converts operations belonging
+/// to the LLVM dialect to LLVM IR.
+class LLVMDialectLLVMIRImportInterface : public LLVMImportDialectInterface {
+public:
+  using LLVMImportDialectInterface::LLVMImportDialectInterface;
+
+  /// Converts the LLVM intrinsic to an MLIR LLVM dialect operation if a
+  /// conversion exits. Returns failure otherwise.
+  LogicalResult convertIntrinsic(OpBuilder &builder, llvm::CallInst *inst,
+                                 LLVM::ModuleImport &moduleImport) const final {
+    return convertIntrinsicImpl(builder, inst, moduleImport);
+  }
+
+  /// Returns the list of LLVM IR intrinsic identifiers that are convertible to
+  /// MLIR LLVM dialect intrinsics.
+  ArrayRef<unsigned> getSupportedIntrinsics() const final {
+    return getSupportedIntrinsicsImpl();
+  }
+};
+} // namespace
+
+void mlir::registerLLVMDialectImport(DialectRegistry &registry) {
+  registry.insert<LLVM::LLVMDialect>();
+  registry.addExtension(+[](MLIRContext *ctx, LLVM::LLVMDialect *dialect) {
+    dialect->addInterfaces<LLVMDialectLLVMIRImportInterface>();
+  });
+}
+
+void mlir::registerLLVMDialectImport(MLIRContext &context) {
+  DialectRegistry registry;
+  registerLLVMDialectImport(registry);
+  context.appendDialectRegistry(registry);
+}

mlir/lib/Target/LLVMIR/ModuleImport.cpp

 #include "llvm/IR/Operator.h"
 
 using namespace mlir;
 using namespace mlir::LLVM;
 using namespace mlir::LLVM::detail;
 
 #include "mlir/Dialect/LLVMIR/LLVMConversionEnumsFromLLVM.inc"
 
-/// Returns true if the LLVM IR intrinsic is convertible to an MLIR LLVM dialect
-/// intrinsic, or false if no counterpart exists.
-static bool isConvertibleIntrinsic(llvm::Intrinsic::ID id) {
-  static const DenseSet<unsigned> convertibleIntrinsics = {
-#include "mlir/Dialect/LLVMIR/LLVMConvertibleLLVMIRIntrinsics.inc"
-  };
-  return convertibleIntrinsics.contains(id);
-}
-
 // Utility to print an LLVM value as a string for passing to emitError().
 // FIXME: Diagnostic should be able to natively handle types that have
 // operator << (raw_ostream&) defined.
 static std::string diag(llvm::Value &value) {
   std::string str;
   llvm::raw_string_ostream os(str);
   os << value;
   return os.str();
 }
 
 /// Creates an attribute containing ABI and preferred alignment numbers parsed
 /// a string. The string may be either "abi:preferred" or just "abi". In the
-/// latter case, the prefrred alignment is considered equal to ABI alignment.
+/// latter case, the preferred alignment is considered equal to ABI alignment.
 static DenseIntElementsAttr parseDataLayoutAlignment(MLIRContext &ctx,
                                                      StringRef spec) {
   auto i32 = IntegerType::get(&ctx, 32);
 
   StringRef abiString, preferredString;
   std::tie(abiString, preferredString) = spec.split(':');
   int abi, preferred;
   if (abiString.getAsInteger(/*Radix=*/10, abi))
getTopologicallySortedBlocks(llvm::Function *func) {
 
   return blocks;
 }
 
 ModuleImport::ModuleImport(ModuleOp mlirModule,
                            std::unique_ptr<llvm::Module> llvmModule)
     : builder(mlirModule->getContext()), context(mlirModule->getContext()),
       mlirModule(mlirModule), llvmModule(std::move(llvmModule)),
+      iface(mlirModule->getContext()),
       typeTranslator(*mlirModule->getContext()),
       debugImporter(std::make_unique<DebugImporter>(mlirModule->getContext())) {
   builder.setInsertionPointToStart(mlirModule.getBody());
 }
 
 LogicalResult ModuleImport::convertGlobals() {
   for (llvm::GlobalVariable &globalVar : llvmModule->globals())
     if (!processGlobal(&globalVar))
ModuleImport::convertCallTypeAndOperands(llvm::CallBase *callInst,
   FailureOr<SmallVector<Value>> arguments = convertValues(args);
   if (failed(arguments))
     return failure();
   llvm::append_range(operands, *arguments);
   return success();
 }
 
 LogicalResult ModuleImport::convertIntrinsic(OpBuilder &odsBuilder,
-                                             llvm::CallInst *inst,
-                                             llvm::Intrinsic::ID intrinsicID) {
-  Location loc = translateLoc(inst->getDebugLoc());
-
-  // Check if the intrinsic is convertible to an MLIR dialect counterpart and
-  // copy the arguments to an an LLVM operands array reference for conversion.
-  if (isConvertibleIntrinsic(intrinsicID)) {
-    SmallVector<llvm::Value *> args(inst->args());
-    ArrayRef<llvm::Value *> llvmOperands(args);
-#include "mlir/Dialect/LLVMIR/LLVMIntrinsicFromLLVMIRConversions.inc"
-  }
+                                             llvm::CallInst *inst) {
+  if (succeeded(iface.convertIntrinsic(builder, inst, *this)))
+    return success();
 
+  Location loc = translateLoc(inst->getDebugLoc());
   return emitError(loc) << "unhandled intrinsic " << diag(*inst);
 }
 
-LogicalResult ModuleImport::convertOperation(OpBuilder &odsBuilder,
+LogicalResult ModuleImport::convertInstruction(OpBuilder &odsBuilder,
                                                llvm::Instruction *inst) {
   // Copy the operands to an LLVM operands array reference for conversion.
   SmallVector<llvm::Value *> operands(inst->operands());
   ArrayRef<llvm::Value *> llvmOperands(operands);
+  ModuleImport &moduleImport = *this;
 
   // Convert all instructions that provide an MLIR builder.
 #include "mlir/Dialect/LLVMIR/LLVMOpFromLLVMIRConversions.inc"
 
   // Convert all remaining instructions that do not provide an MLIR builder.
   Location loc = translateLoc(inst->getDebugLoc());
   if (inst->getOpcode() == llvm::Instruction::Br) {
     auto *brInst = cast<llvm::BranchInst>(inst);
LogicalResult ModuleImport::processInstruction(llvm::Instruction *inst) {
   // FIXME: Add support for call / operand attributes.
   // FIXME: Add support for the indirectbr, cleanupret, catchret, catchswitch,
   // callbr, vaarg, landingpad, catchpad, cleanuppad instructions.
 
   // Convert LLVM intrinsics calls to MLIR intrinsics.
   if (auto *callInst = dyn_cast<llvm::CallInst>(inst)) {
     llvm::Function *callee = callInst->getCalledFunction();
     if (callee && callee->isIntrinsic())
-      return convertIntrinsic(builder, callInst, callInst->getIntrinsicID());
+      return convertIntrinsic(builder, callInst);
   }
 
   // Convert all remaining LLVM instructions to MLIR operations.
-  return convertOperation(builder, inst);
+  return convertInstruction(builder, inst);
 }
 
 FlatSymbolRefAttr ModuleImport::getPersonalityAsAttr(llvm::Function *f) {
   if (!f->hasPersonalityFn())
     return nullptr;
 
   llvm::Constant *pf = f->getPersonalityFn();
 
if (func->doesNotAccessMemory())
     addNamedUnitAttr(LLVMDialect::getReadnoneAttrName());
 }
 
 LogicalResult ModuleImport::processFunction(llvm::Function *func) {
   clearBlockAndValueMapping();
 
   auto functionType =
       convertType(func->getFunctionType()).dyn_cast<LLVMFunctionType>();
-  if (func->isIntrinsic() && isConvertibleIntrinsic(func->getIntrinsicID()))
+  if (func->isIntrinsic() &&
+      iface.isConvertibleIntrinsic(func->getIntrinsicID()))
     return success();
 
   bool dsoLocal = func->hasLocalLinkage();
   CConv cconv = convertCConvFromLLVM(func->getCallingConv());
 
   // Insert the function at the end of the module.
   OpBuilder::InsertionGuard guard(builder);
   builder.setInsertionPoint(mlirModule.getBody(), mlirModule.getBody()->end());
DataLayoutSpecInterface dlSpec =
       translateDataLayout(llvmModule->getDataLayout(), context);
   if (!dlSpec) {
     emitError(UnknownLoc::get(context), "can't translate data layout");
     return {};
   }
   module.get()->setAttr(DLTIDialect::kDataLayoutAttrName, dlSpec);
 
   ModuleImport moduleImport(module.get(), std::move(llvmModule));
+  if (failed(moduleImport.querySupportedIntrinsics()))
+    return {};
   if (failed(moduleImport.convertGlobals()))
     return {};
   if (failed(moduleImport.convertFunctions()))
     return {};
 
   return module;
 }

mlir/lib/Tools/mlir-translate/Translation.cpp

 
 //===----------------------------------------------------------------------===//
 // Translation to MLIR
 //===----------------------------------------------------------------------===//
 
 // Puts `function` into the to-MLIR translation registry unless there is already
 // a function registered for the same name.
 static void registerTranslateToMLIRFunction(
-    StringRef name, StringRef description, Optional<llvm::Align> inputAlignment,
+    StringRef name, StringRef description,
+    const std::function<void(DialectRegistry &)> &dialectRegistration,
+    Optional<llvm::Align> inputAlignment,
     const TranslateSourceMgrToMLIRFunction &function) {
-  auto wrappedFn = [function](const std::shared_ptr<llvm::SourceMgr> &sourceMgr,
-                              raw_ostream &output, MLIRContext *context) {
+  auto wrappedFn = [function, dialectRegistration](
+                       const std::shared_ptr<llvm::SourceMgr> &sourceMgr,
+    DialectRegistry registry;
+    dialectRegistration(registry);
+    context->appendDialectRegistry(registry);
     OwningOpRef<Operation *> op = function(sourceMgr, context);
     if (!op || failed(verify(*op)))
       return failure();
     op.get()->print(output);
     return success();
   };
   registerTranslation(name, description, inputAlignment, wrappedFn);
 }
 
 TranslateToMLIRRegistration::TranslateToMLIRRegistration(
     StringRef name, StringRef description,
     const TranslateSourceMgrToMLIRFunction &function,
+    const std::function<void(DialectRegistry &)> &dialectRegistration,
     Optional<llvm::Align> inputAlignment) {
-  registerTranslateToMLIRFunction(name, description, inputAlignment, function);
+  registerTranslateToMLIRFunction(name, description, dialectRegistration,
+                                  inputAlignment, function);
 }
 TranslateToMLIRRegistration::TranslateToMLIRRegistration(
     StringRef name, StringRef description,
     const TranslateRawSourceMgrToMLIRFunction &function,
+    const std::function<void(DialectRegistry &)> &dialectRegistration,
     Optional<llvm::Align> inputAlignment) {
   registerTranslateToMLIRFunction(
-      name, description, inputAlignment,
+      name, description, dialectRegistration, inputAlignment,
       [function](const std::shared_ptr<llvm::SourceMgr> &sourceMgr,
                  MLIRContext *ctx) { return function(*sourceMgr, ctx); });
 }
 /// Wraps `function` with a lambda that extracts a StringRef from a source
 /// manager and registers the wrapper lambda as a to-MLIR conversion.
 TranslateToMLIRRegistration::TranslateToMLIRRegistration(
     StringRef name, StringRef description,
     const TranslateStringRefToMLIRFunction &function,
+    const std::function<void(DialectRegistry &)> &dialectRegistration,
     Optional<llvm::Align> inputAlignment) {
   registerTranslateToMLIRFunction(
-      name, description, inputAlignment,
+      name, description, dialectRegistration, inputAlignment,
       [function](const std::shared_ptr<llvm::SourceMgr> &sourceMgr,
                  MLIRContext *ctx) {
         const llvm::MemoryBuffer *buffer =
             sourceMgr->getMemoryBuffer(sourceMgr->getMainFileID());
         return function(buffer->getBuffer(), ctx);
       });
 }
 

mlir/tools/mlir-tblgen/LLVMIRConversionGen.cpp

if (succeeded(argIndex)) {
             record, "expected non-negative operand index for argument " + name);
       }
       if (isAttributeName(op, name)) {
         bs << formatv("llvmOperands[{0}]", idx);
       } else {
         if (isVariadicOperandName(op, name)) {
           as << formatv(
               "FailureOr<SmallVector<Value>> _llvmir_gen_operand_{0} = "
-              "convertValues(llvmOperands.drop_front({1}));\n",
+              "moduleImport.convertValues(llvmOperands.drop_front({1}));\n",
               name, idx);
         } else {
           as << formatv("FailureOr<Value> _llvmir_gen_operand_{0} = "
-                        "convertValue(llvmOperands[{1}]);\n",
+                        "moduleImport.convertValue(llvmOperands[{1}]);\n",
                         name, idx);
         }
         as << formatv("if (failed(_llvmir_gen_operand_{0}))\n"
                       "  return failure();\n",
                       name);
         bs << formatv("*_llvmir_gen_operand_{0}", name);
       }
     } else if (isResultName(op, name)) {
       if (op.getNumResults() != 1)
         return emitError(record, "expected op to have one result");
-      bs << "mapValue(inst)";
+      bs << "moduleImport.mapValue(inst)";
     } else if (name == "_int_attr") {
-      bs << "matchIntegerAttr";
+      bs << "moduleImport.matchIntegerAttr";
     } else if (name == "_var_attr") {
-      bs << "matchLocalVariableAttr";
+      bs << "moduleImport.matchLocalVariableAttr";
     } else if (name == "_resultType") {
-      bs << "convertType(inst->getType())";
+      bs << "moduleImport.convertType(inst->getType())";
     } else if (name == "_location") {
-      bs << "translateLoc(inst->getDebugLoc())";
+      bs << "moduleImport.translateLoc(inst->getDebugLoc())";
     } else if (name == "_builder") {
       bs << "odsBuilder";
     } else if (name == "_qualCppClassName") {
       bs << op.getQualCppClassName();
     } else if (name == "$") {
       bs << '$';
     } else {
       return emitError(