[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

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

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

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

69

Please document what the returned list of integers contains.

128–130

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

135

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).

161

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

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

102

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>(
+    auto op = $_builder.create<LLVM::LifetimeStartOp>(
       $_location, $_int_attr($size), $ptr);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
   }];
 }
 def LLVM_LifetimeEndOp : LLVM_LifetimeBaseOp<"lifetime.end"> {
   // Custom builder to convert the size argument to an attribute.
   string mlirBuilder = [{
-    $_builder.create<LLVM::LifetimeEndOp>(
+    auto op = $_builder.create<LLVM::LifetimeEndOp>(
       $_location, $_int_attr($size), $ptr);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
   }];
 }
 
 // Intrinsics with multiple returns.
 
 class LLVM_ArithWithOverflowOp<string mnem>
     : LLVM_IntrOp<mnem, [0], [], [SameOperandsElementType], 2>,
       Arguments<(ins LLVM_ScalarOrVectorOf<AnySignlessInteger>,
builder.CreateCall(fn, {
         llvm::MetadataAsValue::get(ctx, llvm::DIExpression::get(ctx, std::nullopt)),
       });
   }];
   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,
+    if (dbgIntr->getExpression()->getNumElements() == 0) {
+      auto op = $_builder.create<$_qualCppClassName>($_location,
         $}] # argName # [{, $_var_attr($varInfo));
+      // Set non-debug metadata attributes.
+      moduleImport.setNonDebugMetadataAttrs(inst, op);
+    }
   }];
   let assemblyFormat = [{
     qualified($varInfo) `=` $}] # argName #
       [{ `:` qualified(type($}] # argName # [{)) attr-dict
   }];
 }
 
 def LLVM_DbgAddrOp : LLVM_DbgIntrOp<"dbg.addr", "addr"> {
let llvmBuilder = [{
     llvm::FastMathFlags tempFM = origFM;
     tempFM.setAllowReassoc($reassoc);
     builder.setFastMathFlags(tempFM);  // set fastmath flag
     $res = builder.CreateCall(fn, operands);
     builder.setFastMathFlags(origFM);  // restore fastmath flag
   }];
   let mlirBuilder = [{
     bool allowReassoc = inst->getFastMathFlags().allowReassoc();
-    $res = $_builder.create<$_qualCppClassName>($_location,
+    auto op = $_builder.create<$_qualCppClassName>($_location,
       $_resultType, $start_value, $input, allowReassoc);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
 }
 
 class LLVM_VecReductionAccF<string mnem>
     : LLVM_VecReductionAccBase<mnem, AnyFloat>;
 
 def LLVM_vector_reduce_add : LLVM_VecReductionI<"add">;
 def LLVM_vector_reduce_and : LLVM_VecReductionI<"and">;
string llvmBuilder = [{
     llvm::Type *ElemTy = moduleTranslation.convertType(
         getVectorElementType(op.getType()));
     llvm::Align align = dl.getABITypeAlign(ElemTy);
     $res = mb.CreateColumnMajorLoad(
       ElemTy, $data, align, $stride, $isVolatile, $rows,
       $columns);
   }];
   string mlirBuilder = [{
-    $res = $_builder.create<LLVM::MatrixColumnMajorLoadOp>(
+    auto op = $_builder.create<LLVM::MatrixColumnMajorLoadOp>(
       $_location, $_resultType, $data, $stride,
       $_int_attr($isVolatile), $_int_attr($rows), $_int_attr($columns));
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
 }
 
 /// Create a column major, strided 2-D matrix store, as specified in the LLVM
 /// MatrixBuilder.
 /// matrix     - Matrix to store
 /// ptr        - Pointer to write back to
 /// isVolatile - True if the load operation is marked as volatile.
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>(
+    auto op = $_builder.create<LLVM::MatrixColumnMajorStoreOp>(
       $_location, $matrix, $data, $stride,
       $_int_attr($isVolatile), $_int_attr($rows), $_int_attr($columns));
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
   }];
 }
 
 /// 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"> {
   let arguments = (ins LLVM_AnyVector:$lhs, LLVM_AnyVector:$rhs, I32Attr:$lhs_rows,
                    I32Attr:$lhs_columns, I32Attr:$rhs_columns);
   let results = (outs LLVM_AnyVector:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "$lhs `,` $rhs attr-dict "
     "`:` `(` type($lhs) `,` type($rhs) `)` `->` type($res)";
 
   string llvmBuilder = [{
     llvm::MatrixBuilder mb(builder);
     $res = mb.CreateMatrixMultiply(
       $lhs, $rhs, $lhs_rows, $lhs_columns,
       $rhs_columns);
   }];
   string mlirBuilder = [{
-    $res = $_builder.create<LLVM::MatrixMultiplyOp>(
+    auto op = $_builder.create<LLVM::MatrixMultiplyOp>(
       $_location, $_resultType, $lhs, $rhs,
       $_int_attr($lhs_rows), $_int_attr($lhs_columns), $_int_attr($rhs_columns));
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
 }
 
 /// Create a llvm.matrix.transpose call, transposing a `rows` x `columns` 2-D
 /// `matrix`, as specified in the LLVM MatrixBuilder.
 def LLVM_MatrixTransposeOp : LLVM_OneResultIntrOp<"matrix.transpose"> {
   let arguments = (ins LLVM_AnyVector:$matrix, I32Attr:$rows, I32Attr:$columns);
   let results = (outs LLVM_AnyVector:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "$matrix attr-dict `:` type($matrix) `into` type($res)";
 
   string llvmBuilder = [{
     llvm::MatrixBuilder mb(builder);
     $res = mb.CreateMatrixTranspose(
       $matrix, $rows, $columns);
   }];
   string mlirBuilder = [{
-    $res = $_builder.create<LLVM::MatrixTransposeOp>(
+    auto op = $_builder.create<LLVM::MatrixTransposeOp>(
       $_location, $_resultType, $matrix,
       $_int_attr($rows), $_int_attr($columns));
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
 }
 
 //
 // LLVM masked operations.
 //
 
 /// Create a llvm.get.active.lane.mask to set a mask up to a given position.
def LLVM_MaskedLoadOp : LLVM_OneResultIntrOp<"masked.load"> {
 
   string llvmBuilder = [{
     $res = $pass_thru.empty() ? builder.CreateMaskedLoad(
         $_resultType, $data, llvm::Align($alignment), $mask) :
       builder.CreateMaskedLoad(
         $_resultType, $data, llvm::Align($alignment), $mask, $pass_thru[0]);
   }];
   string mlirBuilder = [{
-    $res = $_builder.create<LLVM::MaskedLoadOp>($_location,
+    auto op = $_builder.create<LLVM::MaskedLoadOp>($_location,
       $_resultType, $data, $mask, $pass_thru, $_int_attr($alignment));
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
   list<int> llvmArgIndices = [0, 2, 3, 1];
 }
 
 /// Create a call to Masked Store intrinsic.
 def LLVM_MaskedStoreOp : LLVM_ZeroResultIntrOp<"masked.store"> {
   let arguments = (ins LLVM_AnyVector:$value, LLVM_AnyPointer:$data,
                    LLVM_VectorOf<I1>:$mask, I32Attr:$alignment);
   let builders = [LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder];
   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,
+    auto op = $_builder.create<LLVM::MaskedStoreOp>($_location,
       $value, $data, $mask, $_int_attr($alignment));
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
   }];
   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,
                    LLVM_VectorOf<I1>:$mask, Variadic<LLVM_AnyVector>:$pass_thru,
                    I32Attr:$alignment);
   let results = (outs LLVM_AnyVector:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat =
     "operands attr-dict `:` functional-type(operands, results)";
 
   string llvmBuilder = [{
     $res = $pass_thru.empty() ? builder.CreateMaskedGather(
         $_resultType, $ptrs, llvm::Align($alignment), $mask) :
       builder.CreateMaskedGather(
         $_resultType, $ptrs, llvm::Align($alignment), $mask, $pass_thru[0]);
   }];
   string mlirBuilder = [{
-    $res = $_builder.create<LLVM::masked_gather>($_location,
+    auto op = $_builder.create<LLVM::masked_gather>($_location,
       $_resultType, $ptrs, $mask, $pass_thru, $_int_attr($alignment));
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
   list<int> llvmArgIndices = [0, 2, 3, 1];
 }
 
 /// Create a call to Masked Scatter intrinsic.
 def LLVM_masked_scatter : LLVM_ZeroResultIntrOp<"masked.scatter"> {
   let arguments = (ins LLVM_AnyVector:$value, LLVM_VectorOf<LLVM_AnyPointer>:$ptrs,
                    LLVM_VectorOf<I1>:$mask, I32Attr:$alignment);
   let builders = [LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder];
   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,
+    auto op = $_builder.create<LLVM::masked_scatter>($_location,
       $value, $ptrs, $mask, $_int_attr($alignment));
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
   }];
   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

string mlirBuilder = [{
     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);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
     }] # !if(!gt(requiresFastmath, 0),
       "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,

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

class LLVM_ArithmeticOpBase<Type type, string mnemonic,
   let assemblyFormat = "$lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)";
   string llvmInstName = instName;
 }
 class LLVM_IntArithmeticOp<string mnemonic, string instName,
                            list<Trait> traits = []> :
     LLVM_ArithmeticOpBase<AnyInteger, mnemonic, instName, traits> {
   let arguments = commonArgs;
   string mlirBuilder = [{
-    $res = $_builder.create<$_qualCppClassName>($_location, $lhs, $rhs);
+    auto op = $_builder.create<$_qualCppClassName>($_location, $lhs, $rhs);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
 }
 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);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(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);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(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_ICmpOp : LLVM_ArithmeticCmpOp<"icmp", [Pure]> {
   ];
   let hasCustomAssemblyFormat = 1;
   string llvmInstName = "ICmp";
   string llvmBuilder = [{
     $res = builder.CreateICmp(getLLVMCmpPredicate($predicate), $lhs, $rhs);
   }];
   string mlirBuilder = [{
     auto *iCmpInst = cast<llvm::ICmpInst>(inst);
-    $res = $_builder.create<$_qualCppClassName>(
+    auto op = $_builder.create<$_qualCppClassName>(
       $_location, getICmpPredicate(iCmpInst->getPredicate()), $lhs, $rhs);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(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];
 }
 
 // Other floating-point operations.
 def LLVM_FCmpOp : LLVM_ArithmeticCmpOp<"fcmp", [
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);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(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];
 }
 
string llvmBuilder = [{
     $res = inst;
   }];
   // FIXME: Import attributes.
   string mlirBuilder = [{
     auto *allocaInst = cast<llvm::AllocaInst>(inst);
     Type allocatedType =
       moduleImport.convertType(allocaInst->getAllocatedType());
     unsigned alignment = allocaInst->getAlign().value();
-    $res = $_builder.create<LLVM::AllocaOp>(
+    auto op = $_builder.create<LLVM::AllocaOp>(
       $_location, $_resultType, allocatedType, $arraySize, alignment);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
   let builders = [
     OpBuilder<(ins "Type":$resultType, "Value":$arraySize,
                "unsigned":$alignment),
     [{
       assert(!resultType.cast<LLVMPointerType>().isOpaque() &&
              "pass the allocated type explicitly if opaque pointers are used");
       if (alignment == 0)
string llvmBuilder = [{
      # setNonTemporalMetadataCode
      # setAccessGroupsMetadataCode
      # setAliasScopeMetadataCode
      # [{
     $res = inst;
   }];
   // FIXME: Import attributes.
   string mlirBuilder = [{
-    $res = $_builder.create<LLVM::LoadOp>($_location, $_resultType, $addr);
+    auto op = $_builder.create<LLVM::LoadOp>($_location, $_resultType, $addr);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
   let builders = [
     OpBuilder<(ins "Value":$addr, CArg<"unsigned", "0">:$alignment,
       CArg<"bool", "false">:$isVolatile, CArg<"bool", "false">:$isNonTemporal),
     [{
       auto type = addr.getType().cast<LLVMPointerType>().getElementType();
       assert(type && "must provide explicit element type to the constructor "
                      "when the pointer type is opaque");
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);
+    auto op = $_builder.create<LLVM::StoreOp>($_location, $value, $addr);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
   }];
   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;
 }
 
 // Casts.
 class LLVM_CastOp<string mnemonic, string instName, Type type,
                   Type resultType, list<Trait> traits = []> :
     LLVM_Op<mnemonic, !listconcat([Pure], traits)>,
     LLVM_Builder<"$res = builder.Create" # instName # "($arg, $_resultType);"> {
   let arguments = (ins type:$arg);
   let results = (outs resultType:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "$arg attr-dict `:` type($arg) `to` type($res)";
   string llvmInstName = instName;
   string mlirBuilder = [{
-    $res = $_builder.create<$_qualCppClassName>(
+    auto op = $_builder.create<$_qualCppClassName>(
       $_location, $_resultType, $arg);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
 }
 def LLVM_BitcastOp : LLVM_CastOp<"bitcast", "BitCast",
                                  LLVM_AnyNonAggregate, LLVM_AnyNonAggregate> {
   let hasFolder = 1;
 }
 def LLVM_AddrSpaceCastOp : LLVM_CastOp<"addrspacecast", "AddrSpaceCast",
                                        LLVM_ScalarOrVectorOf<LLVM_AnyPointer>,
let assemblyFormat = [{
     $vector `[` $position `:` type($position) `]` attr-dict `:` type($vector)
   }];
 
   string llvmInstName = "ExtractElement";
   string llvmBuilder = [{
     $res = builder.CreateExtractElement($vector, $position);
   }];
   string mlirBuilder = [{
-    $res = $_builder.create<LLVM::ExtractElementOp>(
+    auto op = $_builder.create<LLVM::ExtractElementOp>(
       $_location, $vector, $position);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // ExtractValueOp
 //===----------------------------------------------------------------------===//
 
 def LLVM_ExtractValueOp : LLVM_Op<"extractvalue", [Pure]> {
def LLVM_ExtractValueOp : LLVM_Op<"extractvalue", [Pure]> {
   let hasVerifier = 1;
 
   string llvmInstName = "ExtractValue";
   string llvmBuilder = [{
     $res = builder.CreateExtractValue($container, extractPosition($position));
   }];
   string mlirBuilder = [{
     auto *evInst = cast<llvm::ExtractValueInst>(inst);
-    $res = $_builder.create<LLVM::ExtractValueOp>($_location,
+    auto op = $_builder.create<LLVM::ExtractValueOp>($_location,
       $container, getPositionFromIndices(evInst->getIndices()));
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // InsertElementOp
 //===----------------------------------------------------------------------===//
 
 def LLVM_InsertElementOp : LLVM_Op<"insertelement", [Pure,
let assemblyFormat = [{
     type($vector)
   }];
 
   string llvmInstName = "InsertElement";
   string llvmBuilder = [{
     $res = builder.CreateInsertElement($vector, $value, $position);
   }];
   string mlirBuilder = [{
-    $res = $_builder.create<LLVM::InsertElementOp>(
+    auto op = $_builder.create<LLVM::InsertElementOp>(
       $_location, $vector, $value, $position);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // InsertValueOp
 //===----------------------------------------------------------------------===//
 
 def LLVM_InsertValueOp : LLVM_Op<
def LLVM_InsertValueOp : LLVM_Op<
 
   string llvmInstName = "InsertValue";
   string llvmBuilder = [{
     $res = builder.CreateInsertValue($container, $value,
                                      extractPosition($position));
   }];
   string mlirBuilder = [{
     auto *ivInst = cast<llvm::InsertValueInst>(inst);
-    $res = $_builder.create<LLVM::InsertValueOp>($_location,
+    auto op = $_builder.create<LLVM::InsertValueOp>($_location,
       $container, $value, getPositionFromIndices(ivInst->getIndices()));
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // ShuffleVectorOp
 //===----------------------------------------------------------------------===//
 
 def LLVM_ShuffleVectorOp : LLVM_Op<"shufflevector",
def LLVM_ShuffleVectorOp : LLVM_Op<"shufflevector",
 
   string llvmInstName = "ShuffleVector";
   string llvmBuilder = [{
     $res = builder.CreateShuffleVector($v1, $v2, $mask);
   }];
   string mlirBuilder = [{
     auto *svInst = cast<llvm::ShuffleVectorInst>(inst);
     SmallVector<int32_t> mask(svInst->getShuffleMask());
-    $res = $_builder.create<LLVM::ShuffleVectorOp>(
+    auto op = $_builder.create<LLVM::ShuffleVectorOp>(
       $_location, $v1, $v2, mask);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
 }
 
 // Misc operations.
 def LLVM_SelectOp
     : LLVM_Op<"select",
           [Pure, AllTypesMatch<["trueValue", "falseValue", "res"]>]>,
       LLVM_Builder<
           "$res = builder.CreateSelect($condition, $trueValue, $falseValue);"> {
   let arguments = (ins LLVM_ScalarOrVectorOf<I1>:$condition,
                    LLVM_Type:$trueValue, LLVM_Type:$falseValue);
   let results = (outs LLVM_Type:$res);
   let assemblyFormat = "operands attr-dict `:` type($condition) `,` type($res)";
   string llvmInstName = "Select";
   string mlirBuilder = [{
-    $res = $_builder.create<LLVM::SelectOp>(
+    auto op = $_builder.create<LLVM::SelectOp>(
       $_location, $_resultType, $condition, $trueValue, $falseValue);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
 }
 def LLVM_FreezeOp : LLVM_Op<"freeze", [SameOperandsAndResultType]> {
   let arguments = (ins LLVM_Type:$val);
   let results = (outs LLVM_Type:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "$val attr-dict `:` type($val)";
   string llvmInstName = "Freeze";
   string llvmBuilder = "$res = builder.CreateFreeze($val);";
   string mlirBuilder = [{
-    $res = $_builder.create<LLVM::FreezeOp>($_location, $val);
+    auto op = $_builder.create<LLVM::FreezeOp>($_location, $val);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
 }
 
 // Terminators.
 def LLVM_BrOp : LLVM_TerminatorOp<"br",
     [DeclareOpInterfaceMethods<BranchOpInterface>, Pure]> {
   let arguments = (ins Variadic<LLVM_Type>:$destOperands);
   let successors = (successor AnySuccessor:$dest);
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);
+    auto op = $_builder.create<LLVM::ReturnOp>($_location, *mlirOperands);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
   }];
 }
 
 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);
+    auto op = $_builder.create<LLVM::ResumeOp>($_location, $value);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
   }];
 }
 def LLVM_UnreachableOp : LLVM_TerminatorOp<"unreachable"> {
   let assemblyFormat = "attr-dict";
   string llvmInstName = "Unreachable";
   string llvmBuilder = [{ builder.CreateUnreachable(); }];
   string mlirBuilder = [{
-    $_builder.create<LLVM::UnreachableOp>($_location);
+    auto op = $_builder.create<LLVM::UnreachableOp>($_location);
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
   }];
 }
 
 def LLVM_SwitchOp : LLVM_TerminatorOp<"switch",
     [AttrSizedOperandSegments, DeclareOpInterfaceMethods<BranchOpInterface>,
      Pure]> {
   let arguments = (ins
     AnyInteger:$value,
def LLVM_AtomicRMWOp : LLVM_Op<"atomicrmw"> {
   string llvmInstName = "AtomicRMW";
   string llvmBuilder = [{
     $res = builder.CreateAtomicRMW(getLLVMAtomicBinOp($bin_op), $ptr, $val,
                                    llvm::MaybeAlign(),
                                    getLLVMAtomicOrdering($ordering));
   }];
   string mlirBuilder = [{
     auto *atomicInst = cast<llvm::AtomicRMWInst>(inst);
-    $res = $_builder.create<LLVM::AtomicRMWOp>($_location, $_resultType,
+    auto op = $_builder.create<LLVM::AtomicRMWOp>($_location, $_resultType,
         getLLVMAtomicBinOp(atomicInst->getOperation()), $ptr, $val,
         getLLVMAtomicOrdering(atomicInst->getOrdering()));
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
   // Only $ptr and $val are llvm instruction operands.
   list<int> llvmArgIndices = [-1, 0, 1, -1];
 }
 
 def LLVM_AtomicCmpXchgType : AnyTypeOf<[AnyInteger, LLVM_AnyPointer]>;
 def LLVM_AtomicCmpXchgResultType : Type<And<[
   LLVM_AnyStruct.predicate,
def LLVM_AtomicCmpXchgOp : LLVM_Op<"cmpxchg"> {
   string llvmInstName = "AtomicCmpXchg";
   string llvmBuilder = [{
     $res = builder.CreateAtomicCmpXchg($ptr, $cmp, $val, llvm::MaybeAlign(),
                    getLLVMAtomicOrdering($success_ordering),
                    getLLVMAtomicOrdering($failure_ordering));
   }];
   string mlirBuilder = [{
     auto *cmpXchgInst = cast<llvm::AtomicCmpXchgInst>(inst);
-    $res = $_builder.create<LLVM::AtomicCmpXchgOp>(
+    auto op = $_builder.create<LLVM::AtomicCmpXchgOp>(
       $_location, $_resultType, $ptr, $cmp, $val,
       getLLVMAtomicOrdering(cmpXchgInst->getSuccessOrdering()),
       getLLVMAtomicOrdering(cmpXchgInst->getFailureOrdering()));
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
+    $res = op;
   }];
 }
 
 def LLVM_FenceOp : LLVM_Op<"fence"> {
   let arguments = (ins AtomicOrdering:$ordering, StrAttr:$syncscope);
   let builders = [LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder];
   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>(
+    auto op = $_builder.create<LLVM::FenceOp>(
       $_location,
       getLLVMAtomicOrdering(fenceInst->getOrdering()),
       getLLVMSyncScope(fenceInst));
+    // Set non-debug metadata attributes.
+    moduleImport.setNonDebugMetadataAttrs(inst, op);
   }];
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
 def LLVM_InlineAsmOp : LLVM_Op<"inline_asm", []> {
   let description = [{
     The InlineAsmOp mirrors the underlying LLVM semantics with a notable

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.
   virtual ArrayRef<unsigned> getSupportedIntrinsics() const { return {}; }
+
+  /// Hook for derived dialect interfaces to publish the supported metadata
+  /// kinds.
+  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 the mapping is not unique.
-  LogicalResult querySupportedIntrinsics() {
+  /// and metadata kinds to the dialect interface that supports importing them.
+  /// Returns failure if there is no unique mapping for the intrinsics.
+  LogicalResult querySupportedIntrinsicsAndMetadata() {
     for (const LLVMImportDialectInterface &iface : *this) {
+      // Query all supported intrinsics and enforce a unique mapping.
       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();
       }
+      // Query 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
+  /// failure otherwise.
+  LogicalResult setMetadataAttrs(OpBuilder &builder, unsigned kind,
+                                 llvm::MDNode *node, Operation *op,
+                                 LLVM::ModuleImport &moduleImport) const {
+    // Lookup the dialect interfaces for the given metadata.
+    SmallVector<Dialect *> dialects = metadataToDialect.lookup(kind);
+    if (dialects.empty())
+      return failure();
+
+    // Dispatch the conversion to the dialect interfaces.
+    bool isSuccess = false;
+    for (Dialect *dialect : dialects) {
+      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 *>> metadataToDialect;
 };
 
 } // namespace mlir
 
 #endif // MLIR_TARGET_LLVMIR_LLVMIMPORTINTERFACE_H

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

 /// 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();
+  /// Queries the dialect interfaces for the supported LLVM IR intrinsics and
+  /// metadata kinds.
+  LogicalResult querySupportedIntrinsicsAndMetadata() {
+    return iface.querySupportedIntrinsicsAndMetadata();
   }
 
   /// 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();
 
public:
 
   /// 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 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);
+
   /// 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() {

mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMIRToLLVMImport.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 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.
+  // TODO: Avoid instruction specific code using a branch weight interface.
+  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);
+
+    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.
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());
+      // Set non-debug metadata attributes.
+      setNonDebugMetadataAttrs(inst, brOp);
+      return success();
+    }
+    auto condBrOp = builder.create<LLVM::CondBrOp>(
+        loc, *condition, succBlocks.front(), succBlockArgs.front(),
+        succBlocks.back(), succBlockArgs.back());
+    // Set non-debug metadata attributes.
+    setNonDebugMetadataAttrs(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);
+    // Set non-debug metadata attributes.
+    setNonDebugMetadataAttrs(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 (inst->getOpcode() == llvm::Instruction::Call) {
     auto *callInst = cast<llvm::CallInst>(inst);
 
     SmallVector<Type> types;
     SmallVector<Value> operands;
     if (failed(convertCallTypeAndOperands(callInst, types, operands)))
       return failure();
 
     CallOp callOp;
     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);
     }
+    // Set non-debug metadata attributes.
+    setNonDebugMetadataAttrs(inst, callOp);
     setFastmathFlagsAttr(inst, callOp);
     if (!callInst->getType()->isVoidTy())
       mapValue(inst, callOp.getResult());
     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);
+    // Set non-debug metadata attributes.
+    setNonDebugMetadataAttrs(inst, lpOp);
+    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()) {
           SymbolRefAttr::get(builder.getContext(), callee->getName()), operands,
           lookupBlock(invokeInst->getNormalDest()), normalArgs,
           lookupBlock(invokeInst->getUnwindDest()), unwindArgs);
     } else {
       invokeOp = builder.create<InvokeOp>(
           loc, types, operands, lookupBlock(invokeInst->getNormalDest()),
           normalArgs, lookupBlock(invokeInst->getUnwindDest()), unwindArgs);
     }
+    // Set non-debug metadata attributes.
+    setNonDebugMetadataAttrs(inst, invokeOp);
     if (!invokeInst->getType()->isVoidTy())
       mapValue(inst, invokeOp.getResults().front());
     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);
+    // Set non-debug metadata attributes.
+    setNonDebugMetadataAttrs(inst, gepOp);
+    mapValue(inst, gepOp);
     return success();
   }
 
   return emitError(loc) << "unhandled instruction " << diag(*inst);
 }
 
 LogicalResult ModuleImport::processInstruction(llvm::Instruction *inst) {
   // FIXME: Support uses of SubtargetData.
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()))
+  if (failed(moduleImport.querySupportedIntrinsicsAndMetadata()))
     return {};
   if (failed(moduleImport.convertGlobals()))
     return {};
   if (failed(moduleImport.convertFunctions()))
     return {};
 
   return module;
 }

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

 
 declare void @llvm.gcroot(ptr %arg0, ptr %arg1)
 
 ; CHECK: 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: 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"}

mlir/test/Target/LLVMIR/Import/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}