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

[gysit]

Summary

This revision extends the LLVMImportDialectInterface to make the import
of LLVM IR instruction-level metadata extensible. It extends the
signature of the existing dialect interface to provide a method to
import specific metadata kinds and attach them to the imported
operation. The conversion function can rely on the ModuleImport class
to perform support tasks.

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

The interface method names changed a bit compared to the suggested
design. The hook to set the instruction level metadata is now called
setMetadataAttrs and takes the metadata kind as an additional parameter.
We do not hand in the original LLVM IR instruction since it is not used
at this point. Importing named module-level meta data can be added in a
later stage after gaining some experience with this extension mechanism.

Depends on D140374

[Dinistro]

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

84 ↗

(On Diff #484839)

I'm not too familiar with the details of the metadata nodes. Is it guaranteed that each node has at least 1 operand? If so, I would probably still add an assertion.

135 ↗

(On Diff #484839)

This code can be reached by a user passing in an invalid kind. I would suggest to return failure() instead.

[gysit]

Address review comments.

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

135 ↗

(On Diff #484839)

This point is only reachable if the dialect interface does not implement a handler for a metadata kind that it is supposed to support (i.e., a metadata kind returned by getSupportedMetadata. If we reach this point we thus face an implementation error and not an input program dependent error.

I added a comment to clarify this.

[ftynse]

mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td

183–184

This feels repetitive. Can't we automate this a bit? Not sure if we need this for all ops or a subset... In the latter case, may be have an extra tablegen field bit builderSetsDebugMetadata defaulted to false.

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

71

Please document what the returned list of integers contains.

135–137

Nit: explain what happens if only a subset of conversions succeed.

142

Nit: I'd use an find and iterators to avoid copying the vector (one can get a reference to the stored value from the iterator, but not from lookup AFAIR).

169

This is a legitimate use case for something like SmallVector<Dialect *, 1>.

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

102 ↗

(On Diff #485068)

IMO, it's fine without an interface here. LLVM IR is a closed set of operations and there aren't that many that support branch weights to justify the complexity of an extra interface.

[gysit]

Address first batch of review comments.

[gysit]

Fix merging mishap and rename metadata.ll to profiling-metadata.ll

[gysit]

Address automation review comment (avoid repetitive setNonDebugMetadataAttrs calls).

[gysit]

mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td

183–184

I tried to automate it by maintaining an additional noResultOpMapping in the ModuleImport. It maps LLVM IR instructions that have no result to the corresponding MLIR operation. The setNonDebugMetadataAttrs method can then be called from within the ModuleImport and the tablegen files only need minor changes to store the newly created operations that return no result.

An alternative could be to call setNonDebugMetadataAttrs only on a per need basis (so initially only on controlflow operations). However, I think the set of operations that require a metadata import will grow quickly and certain metadata may live on all operations (e.g., !annotation). I thus prefer a solution that supports all operations from the beginning.

[gysit]

Emit a warning if an operation is dropped during the import instead of asserting and add a test case.

[Dinistro]

LGTM!

mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td

class LLVM_LifetimeBaseOp<string opName> : LLVM_ZeroResultIntrOp<opName> {
   }];
 
   let assemblyFormat = "$size `,` $ptr attr-dict `:` qualified(type($ptr))";
 }
 
 def LLVM_LifetimeStartOp : LLVM_LifetimeBaseOp<"lifetime.start"> {
   // Custom builder to convert the size argument to an attribute.
   string mlirBuilder = [{
-    $_builder.create<LLVM::LifetimeStartOp>(
+    $_op = $_builder.create<LLVM::LifetimeStartOp>(
       $_location, $_int_attr($size), $ptr);
   }];
 }
 def LLVM_LifetimeEndOp : LLVM_LifetimeBaseOp<"lifetime.end"> {
   // Custom builder to convert the size argument to an attribute.
   string mlirBuilder = [{
-    $_builder.create<LLVM::LifetimeEndOp>(
+    $_op = $_builder.create<LLVM::LifetimeEndOp>(
       $_location, $_int_attr($size), $ptr);
   }];
 }
 
 // Intrinsics with multiple returns.
 
 class LLVM_ArithWithOverflowOp<string mnem>
     : LLVM_IntrOp<mnem, [0], [], [SameOperandsElementType], 2>,
builder.CreateCall(fn, {
       });
   }];
   let mlirBuilder = [{
     // Drop all debug intrinsics with a non-empty debug expression.
     // TODO: Stop dropping debug intrinsics once debug expressions are
     // convertible to MLIR.
     auto *dbgIntr = cast<llvm::DbgVariableIntrinsic>(inst);
     if (dbgIntr->getExpression()->getNumElements() == 0)
-      $_builder.create<$_qualCppClassName>($_location,
+      $_op = $_builder.create<$_qualCppClassName>($_location,
         $}] # argName # [{, $_var_attr($varInfo));
   }];
   let assemblyFormat = [{
     qualified($varInfo) `=` $}] # argName #
       [{ `:` qualified(type($}] # argName # [{)) attr-dict
   }];
 }
 
string llvmBuilder = [{
     Type elementType = getVectorElementType(op.getMatrix().getType());
     llvm::Align align = dl.getABITypeAlign(
       moduleTranslation.convertType(elementType));
     mb.CreateColumnMajorStore(
       $matrix, $data, align, $stride, $isVolatile,
       $rows, $columns);
   }];
   string mlirBuilder = [{
-    $_builder.create<LLVM::MatrixColumnMajorStoreOp>(
+    $_op = $_builder.create<LLVM::MatrixColumnMajorStoreOp>(
       $_location, $matrix, $data, $stride,
       $_int_attr($isVolatile), $_int_attr($rows), $_int_attr($columns));
   }];
 }
 
 /// Create a llvm.matrix.multiply call, multiplying 2-D matrices LHS and RHS, as
 /// specified in the LLVM MatrixBuilder.
 def LLVM_MatrixMultiplyOp : LLVM_OneResultIntrOp<"matrix.multiply"> {
def LLVM_MaskedStoreOp : LLVM_ZeroResultIntrOp<"masked.store"> {
   let assemblyFormat = "$value `,` $data `,` $mask attr-dict `:` "
     "type($value) `,` type($mask) `into` qualified(type($data))";
 
   string llvmBuilder = [{
     builder.CreateMaskedStore(
       $value, $data, llvm::Align($alignment), $mask);
   }];
   string mlirBuilder = [{
-    $_builder.create<LLVM::MaskedStoreOp>($_location,
+    $_op = $_builder.create<LLVM::MaskedStoreOp>($_location,
       $value, $data, $mask, $_int_attr($alignment));
   }];
   list<int> llvmArgIndices = [0, 1, 3, 2];
 }
 
 /// Create a call to Masked Gather intrinsic.
 def LLVM_masked_gather : LLVM_OneResultIntrOp<"masked.gather"> {
   let arguments = (ins LLVM_VectorOf<LLVM_AnyPointer>:$ptrs,
def LLVM_masked_scatter : LLVM_ZeroResultIntrOp<"masked.scatter"> {
   let assemblyFormat = "$value `,` $ptrs `,` $mask attr-dict `:` "
     "type($value) `,` type($mask) `into` type($ptrs)";
 
   string llvmBuilder = [{
     builder.CreateMaskedScatter(
       $value, $ptrs, llvm::Align($alignment), $mask);
   }];
   string mlirBuilder = [{
-    $_builder.create<LLVM::masked_scatter>($_location,
+    $_op = $_builder.create<LLVM::masked_scatter>($_location,
       $value, $ptrs, $mask, $_int_attr($alignment));
   }];
   list<int> llvmArgIndices = [0, 1, 3, 2];
 }
 
 /// Create a call to Masked Expand Load intrinsic.
 def LLVM_masked_expandload : LLVM_IntrOp<"masked.expandload", [0], [], [], 1> {
   let arguments = (ins LLVM_AnyPointer, LLVM_VectorOf<I1>, LLVM_AnyVector);

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

class LLVM_OpBase<Dialect dialect, string mnemonic, list<Trait> traits = []> :
 
   // A builder to construct the MLIR LLVM dialect operation given the matching
   // LLVM IR instruction `inst` and its operands `llvmOperands`. The
   // following $-variables exist:
   //   - $name - substituted by the remapped `inst` operand value at the index
   //             of the MLIR operation argument with the given name, or if the
   //             name matches the result name, by a reference to store the
   //             result of the newly created MLIR operation to;
+  //   - $_op - substituted by a reference to store the newly created MLIR
+  //            operation (only for MLIR operations that return no result);
   //   - $_int_attr - substituted by a call to an integer attribute matcher;
   //   - $_var_attr - substituted by a call to a variable attribute matcher;
   //   - $_resultType - substituted with the MLIR result type;
   //   - $_location - substituted with the MLIR location;
   //   - $_builder - substituted with the MLIR builder;
   //   - $_qualCppClassName - substitiuted with the MLIR operation class name.
+  // Always either store a reference to the result of the newly created
+  // operation, or to the operation itself if it does not return a result.
   // Additionally, `$$` can be used to produce the dollar character.
   string mlirBuilder = "";
 
   // An array that specifies a mapping from MLIR argument indices to LLVM IR
   // operand indices. The mapping is necessary since argument and operand
   // indices do not always match. If not defined, the array is set to the
   // identity permutation. An operation may define any custom index permutation
   // and set a specific argument index to -1 if it does not map to an LLVM IR
string mlirBuilder = [{
     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),
       "moduleImport.setFastmathFlagsAttr(inst, op);", "")
-    # !if(!gt(numResults, 0), "$res = op;", "(void)op;");
+    # !if(!gt(numResults, 0), "$res = op;", "$_op = 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,
                   bit requiresAliasScope = 0, bit requiresFastmath = 0>

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

def LLVM_StoreOp : LLVM_Op<"store">, MemoryOpWithAlignmentAndAttributes {
   string llvmBuilder = [{
     auto *inst = builder.CreateStore($value, $addr, $volatile_);
   }] # setAlignmentCode
      # setNonTemporalMetadataCode
      # setAccessGroupsMetadataCode
      # setAliasScopeMetadataCode;
   // FIXME: Import attributes.
   string mlirBuilder = [{
-    $_builder.create<LLVM::StoreOp>($_location, $value, $addr);
+    $_op = $_builder.create<LLVM::StoreOp>($_location, $value, $addr);
   }];
   let builders = [
     OpBuilder<(ins "Value":$value, "Value":$addr,
       CArg<"unsigned", "0">:$alignment, CArg<"bool", "false">:$isVolatile,
       CArg<"bool", "false">:$isNonTemporal)>
     ];
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
string llvmBuilder = [{
     else
       builder.CreateRetVoid();
   }];
   string mlirBuilder = [{
     FailureOr<SmallVector<Value>> mlirOperands =
       moduleImport.convertValues(llvmOperands);
     if (failed(mlirOperands))
       return failure();
-    $_builder.create<LLVM::ReturnOp>($_location, *mlirOperands);
+    $_op = $_builder.create<LLVM::ReturnOp>($_location, *mlirOperands);
   }];
 }
 
 def LLVM_ResumeOp : LLVM_TerminatorOp<"resume"> {
   let arguments = (ins LLVM_Type:$value);
   let assemblyFormat = "$value attr-dict `:` type($value)";
   let hasVerifier = 1;
   string llvmInstName = "Resume";
   string llvmBuilder = [{ builder.CreateResume($value); }];
   string mlirBuilder = [{
-    $_builder.create<LLVM::ResumeOp>($_location, $value);
+    $_op = $_builder.create<LLVM::ResumeOp>($_location, $value);
   }];
 }
 def LLVM_UnreachableOp : LLVM_TerminatorOp<"unreachable"> {
   let assemblyFormat = "attr-dict";
   string llvmInstName = "Unreachable";
   string llvmBuilder = [{ builder.CreateUnreachable(); }];
   string mlirBuilder = [{
-    $_builder.create<LLVM::UnreachableOp>($_location);
+    $_op = $_builder.create<LLVM::UnreachableOp>($_location);
   }];
 }
 
 def LLVM_SwitchOp : LLVM_TerminatorOp<"switch",
     [AttrSizedOperandSegments, DeclareOpInterfaceMethods<BranchOpInterface>,
      Pure]> {
   let arguments = (ins
     AnyInteger:$value,
def LLVM_FenceOp : LLVM_Op<"fence"> {
   string llvmInstName = "Fence";
   let llvmBuilder = [{
     llvm::LLVMContext &llvmContext = builder.getContext();
     builder.CreateFence(getLLVMAtomicOrdering($ordering),
       llvmContext.getOrInsertSyncScopeID($syncscope));
   }];
   string mlirBuilder = [{
     llvm::FenceInst *fenceInst = cast<llvm::FenceInst>(inst);
-    $_builder.create<LLVM::FenceOp>(
+    $_op = $_builder.create<LLVM::FenceOp>(
       $_location,
       getLLVMAtomicOrdering(fenceInst->getOrdering()),
       getLLVMSyncScope(fenceInst));
   }];
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 

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

public:
   /// 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 implement the import of metadata
+  /// into MLIR. Attaches the converted metadata kind and node to the provided
+  /// operation.
+  virtual LogicalResult
+  setMetadataAttrs(OpBuilder &builder, unsigned kind, llvm::MDNode *node,
+                   Operation *op, LLVM::ModuleImport &moduleImport) const {
+    return failure();
+  }
+
   /// Hook for derived dialect interfaces to publish the supported intrinsics.
   /// As every LLVM IR intrinsic has a unique integer identifier, the function
   /// returns the list of supported intrinsic identifiers.
   virtual ArrayRef<unsigned> getSupportedIntrinsics() const { return {}; }
+
+  /// Hook for derived dialect interfaces to publish the supported metadata
+  /// kinds. As every metadata kind has a unique integer identifier, the
+  /// function returns the list of supported metadata identifiers.
+  virtual ArrayRef<unsigned> getSupportedMetadata() 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 multiple dialect interfaces translate the same LLVM IR
-  /// intrinsic.
+  /// Queries all registered dialect interfaces for the supported LLVM IR
+  /// intrinsic and metadata kinds and builds the dispatch tables for the
+  /// conversion. Returns failure if multiple dialect interfaces translate the
+  /// same LLVM IR intrinsic.
   LogicalResult initializeImport() {
     for (const LLVMImportDialectInterface &iface : *this) {
       // Verify the supported intrinsics have not been mapped before.
       const auto *it =
           llvm::find_if(iface.getSupportedIntrinsics(), [&](unsigned id) {
             return intrinsicToDialect.count(id);
           });
       if (it != iface.getSupportedIntrinsics().end()) {
         return emitError(
             UnknownLoc::get(iface.getContext()),
             llvm::formatv("expected unique conversion for intrinsic ({0}), but "
                           "got conflicting {1} and {2} conversions",
                           *it, iface.getDialect()->getNamespace(),
                           intrinsicToDialect.lookup(*it)->getNamespace()));
       }
       // Add a mapping for all supported intrinsic identifiers.
       for (unsigned id : iface.getSupportedIntrinsics())
         intrinsicToDialect[id] = iface.getDialect();
+      // Add a mapping for all supported metadata kinds.
+      for (unsigned kind : iface.getSupportedMetadata())
+        metadataToDialect[kind].push_back(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,
public:
   }
 
   /// Returns true if the given LLVM IR intrinsic is convertible to an MLIR
   /// operation.
   bool isConvertibleIntrinsic(llvm::Intrinsic::ID id) {
     return intrinsicToDialect.count(id);
   }
 
+  /// Attaches the given LLVM metadata to the imported operation if a conversion
+  /// to one or more MLIR dialect attributes exists and succeeds. Returns
+  /// success if at least one of the conversions is successful and failure if
+  /// all of them fail.
+  LogicalResult setMetadataAttrs(OpBuilder &builder, unsigned kind,
+                                 llvm::MDNode *node, Operation *op,
+                                 LLVM::ModuleImport &moduleImport) const {
+    // Lookup the dialect interfaces for the given metadata.
+    auto it = metadataToDialect.find(kind);
+    if (it == metadataToDialect.end())
+      return failure();
+
+    // Dispatch the conversion to the dialect interfaces.
+    bool isSuccess = false;
+    for (Dialect *dialect : it->getSecond()) {
+      const LLVMImportDialectInterface *iface = getInterfaceFor(dialect);
+      assert(iface && "expected to find a dialect interface");
+      if (succeeded(
+              iface->setMetadataAttrs(builder, kind, node, op, moduleImport)))
+        isSuccess = true;
+    }
+
+    // Returns failure if all conversions fail.
+    return success(isSuccess);
+  }
+
+  /// Returns true if the given LLVM IR metadata is convertible to an MLIR
+  /// attribute.
+  bool isConvertibleMetadata(unsigned kind) {
+    return metadataToDialect.count(kind);
+  }
+
 private:
   DenseMap<unsigned, Dialect *> intrinsicToDialect;
+  DenseMap<unsigned, SmallVector<Dialect *, 1>> metadataToDialect;
 };
 
 } // namespace mlir
 
 #endif // MLIR_TARGET_LLVMIR_LLVMIMPORTINTERFACE_H

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

 /// 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);
 
   /// Calls the LLVMImportInterface initialization that queries the registered
-  /// dialect interfaces for the supported LLVM IR intrinsics and builds the
-  /// dispatch table. Returns failure if multiple dialect interfaces translate
-  /// the same LLVM IR intrinsic.
+  /// dialect interfaces for the supported LLVM IR intrinsics and metadata kinds
+  /// and builds the dispatch tables. Returns failure if multiple dialect
+  /// interfaces translate the same LLVM IR intrinsic.
   LogicalResult initializeImportInterface() { return iface.initializeImport(); }
 
   /// 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 &&
            "attempting to map a value that is already mapped");
     return mlir;
   }
 
   /// Returns the MLIR value mapped to the given LLVM value.
   Value lookupValue(llvm::Value *value) { return valueMapping.lookup(value); }
 
+  /// Stores a mapping between an LLVM instruction and the imported MLIR
+  /// operation if the operation returns no result. Asserts if the operation
+  /// returns a result and should be added to valueMapping instead.
+  void mapNoResultOp(llvm::Instruction *inst, Operation *mlir) {
+    mapNoResultOp(inst) = mlir;
+  }
+
+  /// Provides write-once access to store the MLIR operation corresponding to
+  /// the given LLVM instruction if the operation returns no result. Asserts if
+  /// the operation returns a result and should be added to valueMapping
+  /// instead.
+  Operation *&mapNoResultOp(llvm::Instruction *inst) {
+    Operation *&mlir = noResultOpMapping[inst];
+    assert(inst->getType()->isVoidTy() &&
+           "attempting to map an operation that returns a result");
+    assert(mlir == nullptr &&
+           "attempting to map an operation that is already mapped");
+    return mlir;
+  }
+
+  /// Returns the MLIR operation mapped to the given LLVM instruction. Queries
+  /// valueMapping and noResultOpMapping to support operations with and without
+  /// result.
+  Operation *lookupOperation(llvm::Instruction *inst) {
+    if (Value value = lookupValue(inst))
+      return value.getDefiningOp();
+    return noResultOpMapping.lookup(inst);
+  }
+
   /// Stores the mapping between an LLVM block and its MLIR counterpart.
   void mapBlock(llvm::BasicBlock *llvm, Block *mlir) {
     auto result = blockMapping.try_emplace(llvm, mlir);
     (void)result;
     assert(result.second && "attempting to map a block that is already mapped");
   }
 
   /// Returns the MLIR block mapped to the given LLVM block.
public:
   /// 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();
+    noResultOpMapping.clear();
     blockMapping.clear();
   }
   /// Sets the constant insertion point to the start of the given block.
   void setConstantInsertionPointToStart(Block *block) {
     constantInsertionBlock = block;
     constantInsertionOp = nullptr;
   }
 
   /// 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);
+  /// Converts the metadata attached to the original instruction `inst` if
+  /// a dialect interfaces supports the specific kind of metadata and attaches
+  /// the resulting dialect attributes to the converted operation `op`. Emits a
+  /// warning if the conversion of a supported metadata kind fails.
+  void setNonDebugMetadataAttrs(llvm::Instruction *inst, Operation *op);
   /// Imports `inst` and populates valueMapping[inst] with the result of the
-  /// imported operation.
+  /// imported operation or noResultOpMapping[inst] with the imported operation
+  /// if it has no result.
   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,
                                   llvm::BasicBlock *target,
                                   SmallVectorImpl<Value> &blockArguments);
private:
   /// 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;
+  /// Function-local mapping between original instructions and imported
+  /// operations for all operations that return no result. All operations that
+  /// return a result have a valueMapping entry instead.
+  DenseMap<llvm::Instruction *, Operation *> noResultOpMapping;
   /// 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/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMIRToLLVMTranslation.cpp

if (isConvertibleIntrinsic(intrinsicID)) {
     SmallVector<llvm::Value *> args(inst->args());
     ArrayRef<llvm::Value *> llvmOperands(args);
 #include "mlir/Dialect/LLVMIR/LLVMIntrinsicFromLLVMIRConversions.inc"
   }
 
   return failure();
 }
 
+/// Returns the list of LLVM IR metadata kinds that are convertible to MLIR LLVM
+/// dialect attributes.
+static ArrayRef<unsigned> getSupportedMetadataImpl() {
+  static const SmallVector<unsigned> convertibleMetadata = {
+      llvm::LLVMContext::MD_prof // profiling metadata
+  };
+  return convertibleMetadata;
+}
+
+/// Attaches the given profiling metadata to the imported operation if a
+/// conversion to an MLIR profiling attribute exists and succeeds. Returns
+/// failure otherwise.
+static LogicalResult setProfilingAttrs(OpBuilder &builder, llvm::MDNode *node,
+                                       Operation *op,
+                                       LLVM::ModuleImport &moduleImport) {
+  // Return success for empty metadata nodes since there is nothing to import.
+  if (!node->getNumOperands())
+    return success();
+
+  // Return failure for non-"branch_weights" metadata.
+  auto *name = dyn_cast<llvm::MDString>(node->getOperand(0));
+  if (!name || !name->getString().equals("branch_weights"))
+    return failure();
+
+  // Copy the branch weights to an array.
+  SmallVector<int32_t> branchWeights;
+  branchWeights.reserve(node->getNumOperands() - 1);
+  for (unsigned i = 1, e = node->getNumOperands(); i != e; ++i) {
+    llvm::ConstantInt *branchWeight =
+        llvm::mdconst::extract<llvm::ConstantInt>(node->getOperand(i));
+    branchWeights.push_back(branchWeight->getZExtValue());
+  }
+
+  // Attach the branch weights to the operations that support it.
+  if (auto condBrOp = dyn_cast<CondBrOp>(op)) {
+    condBrOp.setBranchWeightsAttr(builder.getI32VectorAttr(branchWeights));
+    return success();
+  }
+  if (auto switchOp = dyn_cast<SwitchOp>(op)) {
+    switchOp.setBranchWeightsAttr(builder.getI32VectorAttr(branchWeights));
+    return success();
+  }
+  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);
   }
 
+  /// Attaches the given LLVM metadata to the imported operation if a conversion
+  /// to an LLVM dialect attribute exists and succeeds. Returns failure
+  /// otherwise.
+  LogicalResult setMetadataAttrs(OpBuilder &builder, unsigned kind,
+                                 llvm::MDNode *node, Operation *op,
+                                 LLVM::ModuleImport &moduleImport) const final {
+    // Call metadata specific handlers.
+    if (kind == llvm::LLVMContext::MD_prof)
+      return setProfilingAttrs(builder, node, op, moduleImport);
+
+    // A handler for a supported metadata kind is missing.
+    llvm_unreachable("unknown metadata type");
+  }
+
   /// Returns the list of LLVM IR intrinsic identifiers that are convertible to
   /// MLIR LLVM dialect intrinsics.
   ArrayRef<unsigned> getSupportedIntrinsics() const final {
     return getSupportedIntrinsicsImpl();
   }
+
+  /// Returns the list of LLVM IR metadata kinds that are convertible to MLIR
+  /// LLVM dialect attributes.
+  ArrayRef<unsigned> getSupportedMetadata() const final {
+    return getSupportedMetadataImpl();
+  }
 };
 } // 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/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"
+#include "llvm/IR/Metadata.h"
 #include "llvm/IR/Operator.h"
 
 using namespace mlir;
 using namespace mlir::LLVM;
 using namespace mlir::LLVM::detail;
 
 #include "mlir/Dialect/LLVMIR/LLVMConversionEnumsFromLLVM.inc"
 

 
 LogicalResult ModuleImport::convertFunctions() {
   for (llvm::Function &func : llvmModule->functions())
     if (failed(processFunction(&func)))
       return failure();
   return success();
 }
 
+void ModuleImport::setNonDebugMetadataAttrs(llvm::Instruction *inst,
+                                            Operation *op) {
+  SmallVector<std::pair<unsigned, llvm::MDNode *>> allMetadata;
+  inst->getAllMetadataOtherThanDebugLoc(allMetadata);
+  for (auto &[kind, node] : allMetadata) {
+    if (!iface.isConvertibleMetadata(kind))
+      continue;
+    if (failed(iface.setMetadataAttrs(builder, kind, node, op, *this))) {
+      Location loc = debugImporter->translateLoc(inst->getDebugLoc());
+      emitWarning(loc) << "unhandled metadata (" << kind << ") " << diag(*inst);
+    }
+  }
+}
+
 void ModuleImport::setFastmathFlagsAttr(llvm::Instruction *inst,
                                         Operation *op) const {
   auto iface = cast<FastmathFlagsInterface>(op);
 
   // Even if the imported operation implements the fastmath interface, the
   // original instruction may not have fastmath flags set. Exit if an
   // instruction, such as a non floating-point function call, does not have
   // fastmath flags.
FailureOr<Value> ModuleImport::convertConstant(llvm::Constant *constant) {
   if (auto *constExpr = dyn_cast<llvm::ConstantExpr>(constant)) {
     // Convert the constant expression to a temporary LLVM instruction and
     // translate it using the `processInstruction` method. Delete the
     // instruction after the translation and remove it from `valueMapping`,
     // since later calls to `getAsInstruction` may return the same address
     // resulting in a conflicting `valueMapping` entry.
     llvm::Instruction *inst = constExpr->getAsInstruction();
     auto guard = llvm::make_scope_exit([&]() {
+      assert(noResultOpMapping.find(inst) == noResultOpMapping.end() &&
+             "expected constant expression to return a result");
       valueMapping.erase(inst);
       inst->deleteValue();
     });
     // Note: `processInstruction` does not call `convertConstant` recursively
     // since all constant dependencies have been converted before.
     assert(llvm::all_of(inst->operands(), [&](llvm::Value *value) {
       return valueMapping.count(value);
     }));
for (auto i : llvm::seq<unsigned>(0, brInst->getNumSuccessors())) {
       llvm::BasicBlock *succ = brInst->getSuccessor(i);
       SmallVector<Value> blockArgs;
       if (failed(convertBranchArgs(brInst, succ, blockArgs)))
         return failure();
       succBlocks.push_back(lookupBlock(succ));
       succBlockArgs.push_back(blockArgs);
     }
 
-    if (brInst->isConditional()) {
-      FailureOr<Value> condition = convertValue(brInst->getCondition());
-      if (failed(condition))
-        return failure();
-      builder.create<LLVM::CondBrOp>(loc, *condition, succBlocks.front(),
-                                     succBlockArgs.front(), succBlocks.back(),
-                                     succBlockArgs.back());
-    } else {
-      builder.create<LLVM::BrOp>(loc, succBlockArgs.front(),
-                                 succBlocks.front());
-    }
+    if (!brInst->isConditional()) {
+      auto brOp = builder.create<LLVM::BrOp>(loc, succBlockArgs.front(),
+                                             succBlocks.front());
+      mapNoResultOp(inst, brOp);
+      return success();
+    }
+    auto condBrOp = builder.create<LLVM::CondBrOp>(
+        loc, *condition, succBlocks.front(), succBlockArgs.front(),
+        succBlocks.back(), succBlockArgs.back());
+    mapNoResultOp(inst, condBrOp);
     return success();
   }
   if (inst->getOpcode() == llvm::Instruction::Switch) {
     auto *swInst = cast<llvm::SwitchInst>(inst);
     // Process the condition value.
     FailureOr<Value> condition = convertValue(swInst->getCondition());
     if (failed(condition))
       return failure();
for (const auto &it : llvm::enumerate(swInst->cases())) {
       llvm::BasicBlock *succBB = caseHandle.getCaseSuccessor();
       if (failed(convertBranchArgs(swInst, succBB, caseOperands[it.index()])))
         return failure();
       caseOperandRefs[it.index()] = caseOperands[it.index()];
       caseValues[it.index()] = caseHandle.getCaseValue()->getSExtValue();
       caseBlocks[it.index()] = lookupBlock(succBB);
     }
 
-    builder.create<SwitchOp>(loc, *condition, lookupBlock(defaultBB),
-                             defaultBlockArgs, caseValues, caseBlocks,
-                             caseOperandRefs);
+    auto switchOp = builder.create<SwitchOp>(
+        loc, *condition, lookupBlock(defaultBB), defaultBlockArgs, caseValues,
+        caseBlocks, caseOperandRefs);
+    mapNoResultOp(inst, switchOp);
     return success();
   }
   if (inst->getOpcode() == llvm::Instruction::PHI) {
     Type type = convertType(inst->getType());
     mapValue(inst, builder.getInsertionBlock()->addArgument(
                        type, translateLoc(inst->getDebugLoc())));
     return success();
   }
if (llvm::Function *callee = callInst->getCalledFunction()) {
       callOp = builder.create<CallOp>(
           loc, types, SymbolRefAttr::get(context, callee->getName()), operands);
     } else {
       callOp = builder.create<CallOp>(loc, types, operands);
     }
     setFastmathFlagsAttr(inst, callOp);
     if (!callInst->getType()->isVoidTy())
       mapValue(inst, callOp.getResult());
+    else
+      mapNoResultOp(inst, callOp);
     return success();
   }
   if (inst->getOpcode() == llvm::Instruction::LandingPad) {
     auto *lpInst = cast<llvm::LandingPadInst>(inst);
 
     SmallVector<Value> operands;
     operands.reserve(lpInst->getNumClauses());
     for (auto i : llvm::seq<unsigned>(0, lpInst->getNumClauses())) {
       FailureOr<Value> operand = convertConstantExpr(lpInst->getClause(i));
       if (failed(operand))
         return failure();
       operands.push_back(*operand);
     }
 
     Type type = convertType(lpInst->getType());
-    Value res =
+    auto lpOp =
         builder.create<LandingpadOp>(loc, type, lpInst->isCleanup(), operands);
-    mapValue(inst, res);
+    mapValue(inst, lpOp);
     return success();
   }
   if (inst->getOpcode() == llvm::Instruction::Invoke) {
     auto *invokeInst = cast<llvm::InvokeInst>(inst);
 
     SmallVector<Type> types;
     SmallVector<Value> operands;
     if (failed(convertCallTypeAndOperands(invokeInst, types, operands)))
if (llvm::Function *callee = invokeInst->getCalledFunction()) {
           lookupBlock(invokeInst->getUnwindDest()), unwindArgs);
     } else {
       invokeOp = builder.create<InvokeOp>(
           loc, types, operands, lookupBlock(invokeInst->getNormalDest()),
           normalArgs, lookupBlock(invokeInst->getUnwindDest()), unwindArgs);
     }
     if (!invokeInst->getType()->isVoidTy())
       mapValue(inst, invokeOp.getResults().front());
+    else
+      mapNoResultOp(inst, invokeOp);
     return success();
   }
   if (inst->getOpcode() == llvm::Instruction::GetElementPtr) {
     auto *gepInst = cast<llvm::GetElementPtrInst>(inst);
     Type sourceElementType = convertType(gepInst->getSourceElementType());
     FailureOr<Value> basePtr = convertValue(gepInst->getOperand(0));
     if (failed(basePtr))
       return failure();
 
     // Treat every indices as dynamic since GEPOp::build will refine those
     // indices into static attributes later. One small downside of this
     // approach is that many unused `llvm.mlir.constant` would be emitted
     // at first place.
     SmallVector<GEPArg> indices;
     for (llvm::Value *operand : llvm::drop_begin(gepInst->operand_values())) {
       FailureOr<Value> index = convertValue(operand);
       if (failed(index))
         return failure();
       indices.push_back(*index);
     }
 
     Type type = convertType(inst->getType());
-    Value res = builder.create<GEPOp>(loc, type, sourceElementType, *basePtr,
+    auto gepOp = builder.create<GEPOp>(loc, type, sourceElementType, *basePtr,
                                        indices, gepInst->isInBounds());
-    mapValue(inst, res);
+    mapValue(inst, gepOp);
     return success();
   }
 
   return emitError(loc) << "unhandled instruction " << diag(*inst);
 }
 
 LogicalResult ModuleImport::processInstruction(llvm::Instruction *inst) {
   // FIXME: Support uses of SubtargetData.

 }
 
 LogicalResult ModuleImport::processBasicBlock(llvm::BasicBlock *bb,
                                               Block *block) {
   builder.setInsertionPointToStart(block);
   for (llvm::Instruction &inst : *bb) {
     if (failed(processInstruction(&inst)))
       return failure();
+
+    // Set the non-debug metadata attributes on the imported operation and emit
+    // a warning if an instruction other than a phi instruction is dropped
+    // during the import.
+    if (Operation *op = lookupOperation(&inst)) {
+      setNonDebugMetadataAttrs(&inst, op);
+    } else if (inst.getOpcode() != llvm::Instruction::PHI) {
+      Location loc = debugImporter->translateLoc(inst.getDebugLoc());
+      emitWarning(loc) << "dropped instruction " << diag(inst);
+    }
   }
   return success();
 }
 
 OwningOpRef<ModuleOp>
 mlir::translateLLVMIRToModule(std::unique_ptr<llvm::Module> llvmModule,
                               MLIRContext *context) {
   // Preload all registered dialects to allow the import to iterate the

mlir/test/Target/LLVMIR/Import/import-failure.ll

 ; RUN: not mlir-translate -import-llvm -split-input-file %s 2>&1 | FileCheck %s
 
-; CHECK: unhandled instruction indirectbr i8* %dst, [label %bb1, label %bb2]
+; CHECK: error: unhandled instruction indirectbr i8* %dst, [label %bb1, label %bb2]
 define i32 @unhandled_instruction(i8* %dst) {
   indirectbr i8* %dst, [label %bb1, label %bb2]
 bb1:
   ret i32 0
 bb2:
   ret i32 1
 }
 
 ; // -----
 
 ; CHECK: unhandled value ptr asm "bswap $0", "=r,r"
 define i32 @unhandled_value(i32 %arg0) {
   %1 = call i32 asm "bswap $0", "=r,r"(i32 %arg0)
   ret i32 %1
 }
 
 ; // -----
 
-; CHECK: unhandled constant i8* blockaddress(@unhandled_constant, %bb1)
+; CHECK: error: unhandled constant i8* blockaddress(@unhandled_constant, %bb1)
 define i8* @unhandled_constant() {
 bb1:
   ret i8* blockaddress(@unhandled_constant, %bb1)
 }
 
 ; // -----
 
 declare void @llvm.gcroot(ptr %arg0, ptr %arg1)
 
-; CHECK: unhandled intrinsic call void @llvm.gcroot(ptr %arg0, ptr %arg1)
+; CHECK: error: unhandled intrinsic call void @llvm.gcroot(ptr %arg0, ptr %arg1)
 define void @unhandled_intrinsic(ptr %arg0, ptr %arg1) {
   call void @llvm.gcroot(ptr %arg0, ptr %arg1)
   ret void
 }
+
+; // -----
+
+; CHECK: warning: unhandled metadata (2)   br i1 %arg1, label %bb1, label %bb2, !prof !0
+define i64 @cond_br(i1 %arg1, i64 %arg2) {
+entry:
+  br i1 %arg1, label %bb1, label %bb2, !prof !0
+bb1:
+  ret i64 %arg2
+bb2:
+  ret i64 %arg2
+}
+
+!0 = !{!"unknown metadata"}
+
+; // -----
+
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+; CHECK: warning: dropped instruction   call void @llvm.dbg.value(metadata i64 %arg1, metadata !3, metadata !DIExpression(DW_OP_plus_uconst, 42, DW_OP_stack_value)), !dbg !5
+define void @dropped_instruction(i64 %arg1) {
+  call void @llvm.dbg.value(metadata i64 %arg1, metadata !3, metadata !DIExpression(DW_OP_plus_uconst, 42, DW_OP_stack_value)), !dbg !5
+  ret void
+}
+
+!llvm.dbg.cu = !{!1}
+!llvm.module.flags = !{!0}
+!0 = !{i32 2, !"Debug Info Version", i32 3}
+!1 = distinct !DICompileUnit(language: DW_LANG_C, file: !2)
+!2 = !DIFile(filename: "debug-info.ll", directory: "/")
+!3 = !DILocalVariable(scope: !4, name: "arg", file: !2, line: 1, arg: 1, align: 32);
+!4 = distinct !DISubprogram(name: "intrinsic", scope: !2, file: !2, spFlags: DISPFlagDefinition, unit: !1)
+!5 = !DILocation(line: 1, column: 2, scope: !4)

mlir/test/Target/LLVMIR/Import/profiling-metadata.ll

+; RUN: mlir-translate -import-llvm -split-input-file %s | FileCheck %s
+
+; CHECK-LABEL: @cond_br
+define i64 @cond_br(i1 %arg1, i64 %arg2) {
+entry:
+  ; CHECK: llvm.cond_br
+  ; CHECK-SAME: weights(dense<[0, 3]> : vector<2xi32>)
+  br i1 %arg1, label %bb1, label %bb2, !prof !0
+bb1:
+  ret i64 %arg2
+bb2:
+  ret i64 %arg2
+}
+
+!0 = !{!"branch_weights", i32 0, i32 3}
+
+; // -----
+
+; CHECK-LABEL: @simple_switch(
+define i32 @simple_switch(i32 %arg1) {
+  ; CHECK: llvm.switch
+  ; CHECK: {branch_weights = dense<[42, 3, 5]> : vector<3xi32>}
+  switch i32 %arg1, label %bbd [
+    i32 0, label %bb1
+    i32 9, label %bb2
+  ], !prof !0
+bb1:
+  ret i32 %arg1
+bb2:
+  ret i32 %arg1
+bbd:
+  ret i32 %arg1
+}
+
+!0 = !{!"branch_weights", i32 42, i32 3, i32 5}

mlir/tools/mlir-tblgen/LLVMIRConversionGen.cpp

if (succeeded(argIndex)) {
                       "  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 << "moduleImport.mapValue(inst)";
+    } else if (name == "_op") {
+      bs << "moduleImport.mapNoResultOp(inst)";
     } else if (name == "_int_attr") {
       bs << "moduleImport.matchIntegerAttr";
     } else if (name == "_var_attr") {
       bs << "moduleImport.matchLocalVariableAttr";
     } else if (name == "_resultType") {
       bs << "moduleImport.convertType(inst->getType())";
     } else if (name == "_location") {
       bs << "moduleImport.translateLoc(inst->getDebugLoc())";