[mlir][llvm] Improve LLVM IR import error handling.

[gysit]

Summary

Instead of exiting in the middle of the import handle errors more
gracefully by printing an error message and returning failure. The
revision handles and tests the import of unsupported instructions,
values, constants, and intrinsics.

Depends on D139404

[ftynse]

Nice!

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

725–731

Nit: braces when more than one line in the body.

858–861

I suppose it should be possible to construct a FileLineColLoc from LLVM location info

mlir/tools/mlir-tblgen/LLVMIRConversionGen.cpp

247

Nit: consider a more unique name, like _llvmir_gen_operand.

[gysit]

Address review comments and rebase.

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

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

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

def LLVM_ReturnOp : LLVM_TerminatorOp<"return", [Pure, ReturnLike]> {
   string llvmInstName = "Ret";
   string llvmBuilder = [{
     if ($_numOperands != 0)
       builder.CreateRet($arg);
     else
       builder.CreateRetVoid();
   }];
   string mlirBuilder = [{
-    $_builder.create<LLVM::ReturnOp>($_location, convertValues(llvmOperands));
+    FailureOr<SmallVector<Value>> mlirOperands = convertValues(llvmOperands);
+    if (failed(mlirOperands))
+      return failure();
+    $_builder.create<LLVM::ReturnOp>($_location, *mlirOperands);
   }];
 }
 
 def LLVM_ResumeOp : LLVM_TerminatorOp<"resume"> {
   let arguments = (ins LLVM_Type:$value);
   let assemblyFormat = "$value attr-dict `:` type($value)";
   let hasVerifier = 1;
   string llvmInstName = "Resume";

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InlineAsm.h"
+#include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/SourceMgr.h"
 
void mapBlock(llvm::BasicBlock *llvm, Block *mlir) {
     assert(result.second && "attempting to map a block that is already mapped");
   }
 
   /// Returns the MLIR block mapped to the given LLVM block.
   Block *lookupBlock(llvm::BasicBlock *block) const {
     return blockMapping.lookup(block);
   }
 
-  /// Converts an LLVM value either to the mapped MLIR value or to a constant
-  /// using the `convertConstant` method.
-  Value convertValue(llvm::Value *value);
+  /// Converts an LLVM value to an MLIR value, or returns failure if the
+  /// conversion fails. Uses the `convertConstant` method to translate constant
+  /// LLVM values.
+  FailureOr<Value> convertValue(llvm::Value *value);
 
   /// Converts a range of LLVM values to a range of MLIR values using the
-  /// `convertValue` method.
-  SmallVector<Value> convertValues(ArrayRef<llvm::Value *> values);
+  /// `convertValue` method, or returns failure if the conversion fails.
+  FailureOr<SmallVector<Value>> convertValues(ArrayRef<llvm::Value *> values);
 
-  /// Converts `value` to an integer attribute. Asserts if the conversion fails.
+  /// Converts `value` to an integer attribute. Asserts if the matching fails.
   IntegerAttr matchIntegerAttr(llvm::Value *value);
 
-  /// Converts `value` to a local variable attribute.
+  /// Converts `value` to a local variable attribute. Asserts if the matching
+  /// fails.
   DILocalVariableAttr matchLocalVariableAttr(llvm::Value *value);
 
   /// Translates the debug location.
   Location translateLoc(llvm::DILocation *loc) {
     return debugImporter.translateLoc(loc);
   }
 
   /// Converts the type from LLVM to MLIR LLVM dialect.
   Type convertType(llvm::Type *type) {
     return typeTranslator.translateType(type);
   }
 
   /// Converts an LLVM intrinsic to an MLIR LLVM dialect operation if an MLIR
   /// counterpart exists. Otherwise, returns failure.
-  LogicalResult convertIntrinsic(OpBuilder &odsBuilder, llvm::CallInst *inst);
+  LogicalResult convertIntrinsic(OpBuilder &odsBuilder, llvm::CallInst *inst,
+                                 llvm::Intrinsic::ID intrinsicID);
 
-  /// Converts an LLVM instruction to an MLIR LLVM dialect operation if the
-  /// operation defines an MLIR Builder. Otherwise, returns failure.
+  /// Converts an LLVM instruction to an MLIR LLVM dialect operation if an MLIR
+  /// counterpart exists. Otherwise, returns failure.
   LogicalResult convertOperation(OpBuilder &odsBuilder,
                                  llvm::Instruction *inst);
 
   /// Imports `func` into the current module.
   LogicalResult processFunction(llvm::Function *func);
 
   /// Converts function attributes of LLVM Function \p func
   /// into LLVM dialect attributes of LLVMFuncOp \p funcOp.
private:
   /// 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);
   /// Appends the converted result type and operands of `callInst` to the
   /// `types` and `operands` arrays. For indirect calls, the method additionally
   /// inserts the called function at the beginning of the `operands` array.
-  void convertCallTypeAndOperands(llvm::CallBase *callInst,
+  LogicalResult convertCallTypeAndOperands(llvm::CallBase *callInst,
                                            SmallVectorImpl<Type> &types,
                                            SmallVectorImpl<Value> &operands);
   /// Returns the builtin type equivalent to be used in attributes for the given
   /// LLVM IR dialect type.
   Type getStdTypeForAttr(Type type);
   /// Returns `value` as an attribute to attach to a GlobalOp.
   Attribute getConstantAsAttr(llvm::Constant *value);
   /// Returns the topologically sorted set of transitive dependencies needed to
   /// convert the given constant.
   SetVector<llvm::Constant *> getConstantsToConvert(llvm::Constant *constant);
-  /// Converts an LLVM constant to an MLIR value produced by a ConstantOp,
+  /// Converts an LLVM constant to an MLIR value, or returns failure if the
+  /// conversion fails. The MLIR value may be produced by a ConstantOp,
   /// AddressOfOp, NullOp, or a side-effect free operation (for ConstantExprs or
   /// ConstantGEPs).
-  Value convertConstant(llvm::Constant *constant);
-  /// Converts an LLVM constant and its transitive dependencies to MLIR
+  FailureOr<Value> convertConstant(llvm::Constant *constant);
+  /// Converts an LLVM constant and its transitive constant dependencies to MLIR
   /// operations by converting them in topological order using the
-  /// `convertConstant` method. All operations are inserted at the
-  /// start of the current function entry block.
-  Value convertConstantExpr(llvm::Constant *constant);
+  /// `convertConstant` method, or returns failure if the conversion of any of
+  /// them fails. All operations are inserted at the start of the current
+  /// function entry block.
+  FailureOr<Value> convertConstantExpr(llvm::Constant *constant);
 
   /// Builder pointing at where the next instruction should be generated.
   OpBuilder builder;
   /// Block to insert the next constant into.
   Block *constantInsertionBlock = nullptr;
   /// Operation to insert the next constant after.
   Operation *constantInsertionOp = nullptr;
   /// Operation to insert the next global after.
private:
   DenseMap<llvm::GlobalVariable *, GlobalOp> globals;
   /// The stateful type translator (contains named structs).
   LLVM::TypeFromLLVMIRTranslator typeTranslator;
   /// Stateful debug information importer.
   DebugImporter debugImporter;
 };
 } // namespace
 
-LogicalResult Importer::convertIntrinsic(OpBuilder &odsBuilder,
-                                         llvm::CallInst *inst) {
-  // Check if the callee is an intrinsic.
-  llvm::Function *callee = inst->getCalledFunction();
-  if (!callee || !callee->isIntrinsic())
-    return failure();
-
-  // Check if the intrinsic is convertible to an MLIR dialect counterpart.
-  llvm::Intrinsic::ID intrinsicID = callee->getIntrinsicID();
-  if (!isConvertibleIntrinsic(intrinsicID))
-    return failure();
-
-  // Copy the call arguments to initialize operands array reference used by
-  // the conversion.
-  SmallVector<llvm::Value *> args(inst->args());
-  ArrayRef<llvm::Value *> llvmOperands(args);
-#include "mlir/Dialect/LLVMIR/LLVMIntrinsicFromLLVMIRConversions.inc"
-
-  return failure();
-}
-
-LogicalResult Importer::convertOperation(OpBuilder &odsBuilder,
-                                         llvm::Instruction *inst) {
-  // Copy the instruction operands to initialize the operands array reference
-  // used by the conversion.
-  SmallVector<llvm::Value *> operands(inst->operands());
-  ArrayRef<llvm::Value *> llvmOperands(operands);
-#include "mlir/Dialect/LLVMIR/LLVMOpFromLLVMIRConversions.inc"
-
-  return failure();
-}
-
 // We only need integers, floats, doubles, and vectors and tensors thereof for
 // attributes. Scalar and vector types are converted to the standard
 // equivalents. Array types are converted to ranked tensors; nested array types
 // are converted to multi-dimensional tensors or vectors, depending on the
 // innermost type being a scalar or a vector.
 Type Importer::getStdTypeForAttr(Type type) {
   if (!type)
     return nullptr;
GlobalOp globalOp = builder.create<GlobalOp>(
       /*dso_local=*/globalVar->isDSOLocal(),
       /*thread_local=*/globalVar->isThreadLocal());
   globalInsertionOp = globalOp;
 
   if (globalVar->hasInitializer() && !valueAttr) {
     clearBlockAndValueMapping();
     Block *block = builder.createBlock(&globalOp.getInitializerRegion());
     setConstantInsertionPointToStart(block);
-    Value value = convertConstantExpr(globalVar->getInitializer());
-    builder.create<ReturnOp>(globalOp.getLoc(), value);
+    FailureOr<Value> initializer =
+        convertConstantExpr(globalVar->getInitializer());
+    if (failed(initializer))
+      return {};
+    builder.create<ReturnOp>(globalOp.getLoc(), initializer.value());
   }
   if (globalVar->hasAtLeastLocalUnnamedAddr()) {
     globalOp.setUnnamedAddr(
         convertUnnamedAddrFromLLVM(globalVar->getUnnamedAddr()));
   }
   if (globalVar->hasSection())
     globalOp.setSection(globalVar->getSection());
 
   return globals[globalVar] = globalOp;
 }
 
 SetVector<llvm::Constant *>
 Importer::getConstantsToConvert(llvm::Constant *constant) {
   // Traverse the constant dependencies in post order.
   SmallVector<llvm::Constant *> workList;
   SmallVector<llvm::Constant *> orderedList;
   workList.push_back(constant);
   while (!workList.empty()) {
     llvm::Constant *current = workList.pop_back_val();
     // Skip constants that have been converted before and store all other ones.
     if (valueMapping.count(constant))
       continue;
     orderedList.push_back(current);
-    // Add the current constant's dependencies to the work list.
-    for (llvm::Value *operand : current->operands()) {
-      assert(isa<llvm::Constant>(operand) &&
-             "expected constants to have constant operands only");
-      workList.push_back(cast<llvm::Constant>(operand));
-    }
+    // Add the current constant's dependencies to the work list. Only add
+    // constant dependencies and skip any other values such as basic block
+    // addresses.
+    for (llvm::Value *operand : current->operands())
+      if (auto *constDependency = dyn_cast<llvm::Constant>(operand))
+        workList.push_back(constDependency);
     // Use the `getElementValue` method to add the dependencies of zero
     // initialized aggregate constants since they do not take any operands.
     if (auto *constAgg = dyn_cast<llvm::ConstantAggregateZero>(current)) {
       unsigned numElements = constAgg->getElementCount().getFixedValue();
       for (unsigned i = 0, e = numElements; i != e; ++i)
         workList.push_back(constAgg->getElementValue(i));
     }
   }
 
   // Add the constants in reverse post order to the result set to ensure all
   // dependencies are satisfied. Avoid storing duplicates since LLVM constants
   // are uniqued and only one `valueMapping` entry per constant is possible.
   SetVector<llvm::Constant *> orderedSet;
   for (llvm::Constant *orderedConst : llvm::reverse(orderedList))
     orderedSet.insert(orderedConst);
   return orderedSet;
 }
 
-Value Importer::convertConstant(llvm::Constant *constant) {
+FailureOr<Value> Importer::convertConstant(llvm::Constant *constant) {
   // Constants have no location attached.
   Location loc = UnknownLoc::get(context);
 
   // Convert constants that can be represented as attributes.
   if (Attribute attr = getConstantAsAttr(constant)) {
     Type type = convertType(constant->getType());
-    if (auto symbolRef = attr.dyn_cast<FlatSymbolRefAttr>())
-      return builder.create<AddressOfOp>(loc, type, symbolRef.getValue());
-    return builder.create<ConstantOp>(loc, type, attr);
+    if (auto symbolRef = attr.dyn_cast<FlatSymbolRefAttr>()) {
+      return builder.create<AddressOfOp>(loc, type, symbolRef.getValue())
+          .getResult();
+    }
+    return builder.create<ConstantOp>(loc, type, attr).getResult();
   }
 
   // Convert null pointer constants.
   if (auto *nullPtr = dyn_cast<llvm::ConstantPointerNull>(constant)) {
     Type type = convertType(nullPtr->getType());
-    return builder.create<NullOp>(loc, type);
+    return builder.create<NullOp>(loc, type).getResult();
   }
 
   // Convert undef.
   if (auto *undefVal = dyn_cast<llvm::UndefValue>(constant)) {
     Type type = convertType(undefVal->getType());
-    return builder.create<UndefOp>(loc, type);
+    return builder.create<UndefOp>(loc, type).getResult();
   }
 
   // Convert global variable accesses.
-  if (auto *globalVar = dyn_cast<llvm::GlobalVariable>(constant))
-    return builder.create<AddressOfOp>(loc, processGlobal(globalVar));
+  if (auto *globalVar = dyn_cast<llvm::GlobalVariable>(constant)) {
+    return builder.create<AddressOfOp>(loc, processGlobal(globalVar))
+        .getResult();
+  }
 
   // Convert constant expressions.
   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([&]() {
       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);
     }));
     if (failed(processInstruction(inst)))
-      return nullptr;
+      return failure();
     return lookupValue(inst);
   }
 
   // Convert aggregate constants.
   if (isa<llvm::ConstantAggregate>(constant) ||
       isa<llvm::ConstantAggregateZero>(constant)) {
     // Lookup the aggregate elements that have been converted before.
     SmallVector<Value> elementValues;
for (const auto &it : llvm::enumerate(elementValues)) {
             builder.create<ConstantOp>(loc, builder.getI32Type(), indexAttr);
         root = builder.create<InsertElementOp>(loc, rootType, root, it.value(),
                                                indexValue);
       }
     }
     return root;
   }
 
-  return nullptr;
+  return emitError(loc) << "unhandled constant " << diag(*constant);
 }
 
-Value Importer::convertConstantExpr(llvm::Constant *constant) {
+FailureOr<Value> Importer::convertConstantExpr(llvm::Constant *constant) {
   assert(constantInsertionBlock &&
          "expected the constant insertion block to be non-null");
 
   // Insert the constant after the last one or at the start or the entry block.
   OpBuilder::InsertionGuard guard(builder);
   if (!constantInsertionOp) {
     builder.setInsertionPointToStart(constantInsertionBlock);
   } else {
     builder.setInsertionPointAfter(constantInsertionOp);
   }
 
   // Convert all constants of the expression and add them to `valueMapping`.
   SetVector<llvm::Constant *> constantsToConvert =
       getConstantsToConvert(constant);
   for (llvm::Constant *constantToConvert : constantsToConvert) {
-    if (Value value = convertConstant(constantToConvert)) {
-      mapValue(constantToConvert, value);
-      continue;
-    }
-
-    llvm::errs() << diag(*constantToConvert) << "\n";
-    llvm_unreachable("unhandled constant");
+    FailureOr<Value> converted = convertConstant(constantToConvert);
+    if (failed(converted))
+      return failure();
+    mapValue(constantToConvert, converted.value());
   }
 
   // Update the constant insertion point and return the converted constant.
   Value result = lookupValue(constant);
   constantInsertionOp = result.getDefiningOp();
   return result;
 }
 
-Value Importer::convertValue(llvm::Value *value) {
+FailureOr<Value> Importer::convertValue(llvm::Value *value) {
   // A value may be wrapped as metadata, for example, when passed to a debug
   // intrinsic. Unwrap these values before the conversion.
   if (auto *nodeAsVal = dyn_cast<llvm::MetadataAsValue>(value))
     if (auto *node = dyn_cast<llvm::ValueAsMetadata>(nodeAsVal->getMetadata()))
       value = node->getValue();
 
   // Return the mapped value if it has been converted before.
   if (valueMapping.count(value))
     return lookupValue(value);
 
   // Convert constants such as immediate values that have no mapping yet.
   if (auto *constant = dyn_cast<llvm::Constant>(value))
     return convertConstantExpr(constant);
 
-  llvm::errs() << diag(*value) << "\n";
-  llvm_unreachable("unhandled value");
+  Location loc = UnknownLoc::get(context);
+  if (auto *inst = dyn_cast<llvm::Instruction>(value))
+    loc = translateLoc(inst->getDebugLoc());
+  return emitError(loc) << "unhandled value " << diag(*value);
 }
 
-SmallVector<Value> Importer::convertValues(ArrayRef<llvm::Value *> values) {
+FailureOr<SmallVector<Value>>
+Importer::convertValues(ArrayRef<llvm::Value *> values) {
   SmallVector<Value> remapped;
   remapped.reserve(values.size());
-  for (llvm::Value *value : values)
-    remapped.push_back(convertValue(value));
+  for (llvm::Value *value : values) {
+    FailureOr<Value> converted = convertValue(value);
+    if (failed(converted))
+      return failure();
+    remapped.push_back(converted.value());
+  }
   return remapped;
 }
 
 IntegerAttr Importer::matchIntegerAttr(llvm::Value *value) {
   IntegerAttr integerAttr;
-  bool success = matchPattern(convertValue(value), m_Constant(&integerAttr));
+  FailureOr<Value> converted = convertValue(value);
+  bool success = succeeded(converted) &&
+                 matchPattern(converted.value(), m_Constant(&integerAttr));
   assert(success && "expected a constant value");
   (void)success;
   return integerAttr;
 }
 
 DILocalVariableAttr Importer::matchLocalVariableAttr(llvm::Value *value) {
   auto *nodeAsVal = cast<llvm::MetadataAsValue>(value);
   auto *node = cast<llvm::DILocalVariable>(nodeAsVal->getMetadata());
   return debugImporter.translate(node);
 }
 
 LogicalResult
 Importer::convertBranchArgs(llvm::Instruction *branch, llvm::BasicBlock *target,
                             SmallVectorImpl<Value> &blockArguments) {
   for (auto inst = target->begin(); isa<llvm::PHINode>(inst); ++inst) {
-    auto *phi = cast<llvm::PHINode>(&*inst);
-    llvm::Value *value = phi->getIncomingValueForBlock(branch->getParent());
-    blockArguments.push_back(convertValue(value));
+    auto *phiInst = cast<llvm::PHINode>(&*inst);
+    llvm::Value *value = phiInst->getIncomingValueForBlock(branch->getParent());
+    FailureOr<Value> converted = convertValue(value);
+    if (failed(converted))
+      return failure();
+    blockArguments.push_back(converted.value());
   }
   return success();
 }
 
-void Importer::convertCallTypeAndOperands(llvm::CallBase *callInst,
-                                          SmallVectorImpl<Type> &types,
-                                          SmallVectorImpl<Value> &operands) {
+LogicalResult
+Importer::convertCallTypeAndOperands(llvm::CallBase *callInst,
   if (!callInst->getType()->isVoidTy())
     types.push_back(convertType(callInst->getType()));
 
   if (!callInst->getCalledFunction()) {
-    Value called = convertValue(callInst->getCalledOperand());
-    operands.push_back(called);
+    FailureOr<Value> called = convertValue(callInst->getCalledOperand());
+    if (failed(called))
+      return failure();
+    operands.push_back(called.value());
   }
   SmallVector<llvm::Value *> args(callInst->args());
-  llvm::append_range(operands, convertValues(args));
+  FailureOr<SmallVector<Value>> arguments = convertValues(args);
+  if (failed(arguments))
+    return failure();
+  llvm::append_range(operands, arguments.value());
+  return success();
 }
 
-LogicalResult Importer::processInstruction(llvm::Instruction *inst) {
-  // FIXME: Support uses of SubtargetData.
-  // FIXME: Add support for inbounds GEPs.
-  // FIXME: Add support for fast-math flags and call / operand attributes.
-  // FIXME: Add support for the indirectbr, cleanupret, catchret, catchswitch,
-  // callbr, vaarg, landingpad, catchpad, cleanuppad instructions.
+LogicalResult Importer::convertIntrinsic(OpBuilder &odsBuilder,
+                                         llvm::CallInst *inst,
+                                         llvm::Intrinsic::ID intrinsicID) {
+  Location loc = translateLoc(inst->getDebugLoc());
 
-  // Convert all intrinsics that provide an MLIR builder.
-  if (auto *callInst = dyn_cast<llvm::CallInst>(inst))
-    if (succeeded(convertIntrinsic(builder, callInst)))
-      return success();
+  // Check if the intrinsic is convertible to an MLIR dialect counterpart and
+  // copy the arguments to an an LLVM operands array reference for conversion.
+  if (isConvertibleIntrinsic(intrinsicID)) {
+    SmallVector<llvm::Value *> args(inst->args());
+    ArrayRef<llvm::Value *> llvmOperands(args);
+#include "mlir/Dialect/LLVMIR/LLVMIntrinsicFromLLVMIRConversions.inc"
+  }
 
-  // Convert all operations that provide an MLIR builder.
-  if (succeeded(convertOperation(builder, inst)))
-    return success();
+  return emitError(loc) << "unhandled intrinsic " << diag(*inst);
+}
+
+LogicalResult Importer::convertOperation(OpBuilder &odsBuilder,
+                                         llvm::Instruction *inst) {
+  // Copy the operands to an LLVM operands array reference for conversion.
+  SmallVector<llvm::Value *> operands(inst->operands());
+  ArrayRef<llvm::Value *> llvmOperands(operands);
+
+  // Convert all instructions that provide an MLIR builder.
+#include "mlir/Dialect/LLVMIR/LLVMOpFromLLVMIRConversions.inc"
 
   // Convert all remaining instructions that do not provide an MLIR builder.
   Location loc = translateLoc(inst->getDebugLoc());
   if (inst->getOpcode() == llvm::Instruction::Br) {
     auto *brInst = cast<llvm::BranchInst>(inst);
 
     SmallVector<Block *> succBlocks;
     SmallVector<SmallVector<Value>> succBlockArgs;
     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()) {
-      Value condition = convertValue(brInst->getCondition());
-      builder.create<LLVM::CondBrOp>(loc, condition, succBlocks.front(),
+      FailureOr<Value> condition = convertValue(brInst->getCondition());
+      if (failed(condition))
+        return failure();
+      builder.create<LLVM::CondBrOp>(loc, condition.value(), succBlocks.front(),
                                      succBlockArgs.front(), succBlocks.back(),
                                      succBlockArgs.back());
     } else {
       builder.create<LLVM::BrOp>(loc, succBlockArgs.front(),
                                  succBlocks.front());
     }
     return success();
   }
   if (inst->getOpcode() == llvm::Instruction::Switch) {
     auto *swInst = cast<llvm::SwitchInst>(inst);
     // Process the condition value.
-    Value condition = convertValue(swInst->getCondition());
+    FailureOr<Value> condition = convertValue(swInst->getCondition());
+    if (failed(condition))
+      return failure();
     SmallVector<Value> defaultBlockArgs;
     // Process the default case.
     llvm::BasicBlock *defaultBB = swInst->getDefaultDest();
     if (failed(convertBranchArgs(swInst, defaultBB, defaultBlockArgs)))
       return failure();
 
     // Process the cases.
     unsigned numCases = swInst->getNumCases();
     SmallVector<SmallVector<Value>> caseOperands(numCases);
     SmallVector<ValueRange> caseOperandRefs(numCases);
     SmallVector<int32_t> caseValues(numCases);
     SmallVector<Block *> caseBlocks(numCases);
     for (const auto &it : llvm::enumerate(swInst->cases())) {
       const llvm::SwitchInst::CaseHandle &caseHandle = it.value();
       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),
+    builder.create<SwitchOp>(loc, condition.value(), lookupBlock(defaultBB),
                              defaultBlockArgs, caseValues, caseBlocks,
                              caseOperandRefs);
     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;
-    convertCallTypeAndOperands(callInst, types, 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);
     }
     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())) {
-      Value operand = convertConstantExpr(lpInst->getClause(i));
-      operands.push_back(operand);
+      FailureOr<Value> operand = convertConstantExpr(lpInst->getClause(i));
+      if (failed(operand))
+        return failure();
+      operands.push_back(operand.value());
     }
 
     Type type = convertType(lpInst->getType());
     Value res =
         builder.create<LandingpadOp>(loc, type, lpInst->isCleanup(), operands);
     mapValue(inst, res);
     return success();
   }
   if (inst->getOpcode() == llvm::Instruction::Invoke) {
     auto *invokeInst = cast<llvm::InvokeInst>(inst);
 
     SmallVector<Type> types;
     SmallVector<Value> operands;
-    convertCallTypeAndOperands(invokeInst, types, operands);
+    if (failed(convertCallTypeAndOperands(invokeInst, types, operands)))
+      return failure();
 
     SmallVector<Value> normalArgs, unwindArgs;
     (void)convertBranchArgs(invokeInst, invokeInst->getNormalDest(),
                             normalArgs);
     (void)convertBranchArgs(invokeInst, invokeInst->getUnwindDest(),
                             unwindArgs);
 
     InvokeOp invokeOp;
if (inst->getOpcode() == llvm::Instruction::Invoke) {
     if (!invokeInst->getType()->isVoidTy())
       mapValue(inst, invokeOp.getResults().front());
     return success();
   }
   if (inst->getOpcode() == llvm::Instruction::GetElementPtr) {
     // FIXME: Support inbounds GEPs.
     auto *gepInst = cast<llvm::GetElementPtrInst>(inst);
     Type sourceElementType = convertType(gepInst->getSourceElementType());
-    Value basePtr = convertValue(gepInst->getOperand(0));
+    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())) {
-      Value index = convertValue(operand);
-      indices.push_back(index);
+      FailureOr<Value> index = convertValue(operand);
+      if (failed(index))
+        return failure();
+      indices.push_back(index.value());
     }
 
     Type type = convertType(inst->getType());
-    Value res =
-        builder.create<GEPOp>(loc, type, sourceElementType, basePtr, indices);
+    Value res = builder.create<GEPOp>(loc, type, sourceElementType,
+                                      basePtr.value(), indices);
     mapValue(inst, res);
     return success();
   }
 
-  return emitError(loc) << "unknown instruction: " << diag(*inst);
+  return emitError(loc) << "unhandled instruction " << diag(*inst);
+}
+
+LogicalResult Importer::processInstruction(llvm::Instruction *inst) {
+  // FIXME: Support uses of SubtargetData.
+  // FIXME: Add support for inbounds GEPs.
+  // FIXME: Add support for fast-math flags and call / operand attributes.
+  // FIXME: Add support for the indirectbr, cleanupret, catchret, catchswitch,
+  // callbr, vaarg, landingpad, catchpad, cleanuppad instructions.
+
+  // Convert LLVM intrinsics calls to MLIR intrinsics.
+  if (auto *callInst = dyn_cast<llvm::CallInst>(inst)) {
+    llvm::Function *callee = callInst->getCalledFunction();
+    if (callee && callee->isIntrinsic())
+      return convertIntrinsic(builder, callInst, callInst->getIntrinsicID());
+  }
+
+  // Convert all remaining LLVM instructions to MLIR operations.
+  return convertOperation(builder, inst);
 }
 
 FlatSymbolRefAttr Importer::getPersonalityAsAttr(llvm::Function *f) {
   if (!f->hasPersonalityFn())
     return nullptr;
 
   llvm::Constant *pf = f->getPersonalityFn();
 

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]
+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)
+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)
+define void @unhandled_intrinsic(ptr %arg0, ptr %arg1) {
+  call void @llvm.gcroot(ptr %arg0, ptr %arg1)
+  ret void
+}

mlir/tools/mlir-tblgen/LLVMIRConversionGen.cpp

static LogicalResult emitOneMLIRBuilder(const Record &record, raw_ostream &os,
   if (llvmArgIndices.size() != static_cast<size_t>(op.getNumArgs())) {
     return emitError(
         record,
         "expected 'llvmArgIndices' size to match the number of arguments");
   }
 
   // Progressively create the builder string by replacing $-variables. Keep only
   // the not-yet-traversed part of the builder pattern to avoid re-traversing
-  // the string multiple times.
-  std::string builder;
-  llvm::raw_string_ostream bs(builder);
+  // the string multiple times. Additionally, emit an argument string
+  // immediately before the builder string. This argument string converts all
+  // operands used by the builder to MLIR values and returns failure if one of
+  // the conversions fails.
+  std::string arguments, builder;
+  llvm::raw_string_ostream as(arguments), bs(builder);
   while (StringLoc loc = findNextVariable(builderStrRef)) {
     auto name = loc.in(builderStrRef).drop_front();
     // First, insert the non-matched part as is.
     bs << builderStrRef.substr(0, loc.pos);
     // Then, rewrite the name based on its kind.
     FailureOr<int> argIndex = getArgumentIndex(op, name);
     if (succeeded(argIndex)) {
       // Access the LLVM IR operand that maps to the given argument index using
       // the provided argument indices mapping.
       int64_t idx = llvmArgIndices[*argIndex];
       if (idx < 0) {
         return emitError(
             record, "expected non-negative operand index for argument " + name);
       }
       if (isAttributeName(op, name)) {
         bs << formatv("llvmOperands[{0}]", idx);
       } else {
-        bool isVariadicOperand = isVariadicOperandName(op, name);
-        auto result =
-            isVariadicOperand
-                ? formatv("convertValues(llvmOperands.drop_front({0}))", idx)
-                : formatv("convertValue(llvmOperands[{0}])", idx);
-        bs << result;
+        if (isVariadicOperandName(op, name)) {
+          as << formatv(
+              "FailureOr<SmallVector<Value>> _llvmir_gen_operand_{0} = "
+              "convertValues(llvmOperands.drop_front({1}));\n",
+              name, idx);
+        } else {
+          as << formatv("FailureOr<Value> _llvmir_gen_operand_{0} = "
+                        "convertValue(llvmOperands[{1}]);\n",
+                        name, idx);
+        }
+        as << formatv("if (failed(_llvmir_gen_operand_{0}))\n"
+                      "  return failure();\n",
+                      name);
+        bs << formatv("_llvmir_gen_operand_{0}.value()", name);
       }
     } else if (isResultName(op, name)) {
       if (op.getNumResults() != 1)
         return emitError(record, "expected op to have one result");
-      bs << formatv("mapValue(inst)");
+      bs << "mapValue(inst)";
     } else if (name == "_int_attr") {
       bs << "matchIntegerAttr";
     } else if (name == "_var_attr") {
       bs << "matchLocalVariableAttr";
     } else if (name == "_resultType") {
       bs << "convertType(inst->getType())";
     } else if (name == "_location") {
       bs << "translateLoc(inst->getDebugLoc())";
     } else if (name == "_builder") {
       bs << "odsBuilder";
     } else if (name == "_qualCppClassName") {
       bs << op.getQualCppClassName();
     } else if (name == "$") {
       bs << '$';
     } else {
       return emitError(
           record, "expected keyword, argument, or result, but got " + name);
     }
     // Finally, only keep the untraversed part of the string.
     builderStrRef = builderStrRef.substr(loc.pos + loc.length);
   }
 
-  // Output the check and the builder string.
+  // Output the check, the argument conversion, and the builder string.
   os << "if (" << conditionFn(record) << ") {\n";
+  os << as.str() << "\n";
   os << bs.str() << builderStrRef << "\n";
   os << "  return success();\n";
   os << "}\n";
 
   return success();
 }
 
 // Emit all intrinsic MLIR builders. Returns false on success because of the