[mlir][llvmir] Simpler error handling in ConvertFromLLVMIR (nfc).

[gysit]

Summary

The revision renames some methods of the Importer and changes
the error handling to be closer the ModuleTranslation. In particular,
processValue -> lookupValue and processType -> convertType
now fail if the translation fails (instead of returning an error),
which simplifies the error handling.

The revision prepares a follow up commit that will import
LLVMIR intrinsics using tablegen.

[ftynse]

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

546–560

This part looks more than just "lookup". ..

[gysit]

Address comment.

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

546–560

True it may be petter to keep the naming processValue / processValues an only rename once it is a lookup only.

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

 namespace {
 class Importer {
 public:
   Importer(MLIRContext *context, ModuleOp module)
       : b(context), context(context), module(module), typeTranslator(*context) {
     b.setInsertionPointToStart(module.getBody());
   }
 
+  /// Returns the remapped version of `value` or a placeholder that will be
+  /// remapped later if the defining instruction has not yet been visited.
+  Value lookupValue(llvm::Value *value);
+
+  /// Calls `lookupValue` for a range of `values` and returns their remapped
+  /// values or placeholders if the defining instructions have not yet been
+  /// visited.
+  SmallVector<Value> lookupValues(ArrayRef<llvm::Value *> values);
+
+  /// Translate the debug location to a FileLineColLoc, if `loc` is non-null.
+  /// Otherwise, return UnknownLoc.
+  Location translateLoc(llvm::DILocation *loc);
+
+  /// Converts the type from LLVM to MLIR LLVM dialect.
+  Type convertType(llvm::Type *type);
+
   /// Imports `f` into the current module.
   LogicalResult processFunction(llvm::Function *f);
 
   /// Converts function attributes of LLVM Function \p f
   /// into LLVM dialect attributes of LLVMFuncOp \p funcOp.
   void processFunctionAttributes(llvm::Function *f, LLVMFuncOp funcOp);
 
   /// Imports GV as a GlobalOp, creating it if it doesn't exist.
   GlobalOp processGlobal(llvm::GlobalVariable *gv);
 
 private:
   /// Returns personality of `f` as a FlatSymbolRefAttr.
   FlatSymbolRefAttr getPersonalityAsAttr(llvm::Function *f);
   /// Imports `bb` into `block`, which must be initially empty.
   LogicalResult processBasicBlock(llvm::BasicBlock *bb, Block *block);
   /// Imports `inst` and populates instMap[inst] with the imported Value.
   LogicalResult processInstruction(llvm::Instruction *inst);
-  /// Creates an LLVM-compatible MLIR type for `type`.
-  Type processType(llvm::Type *type);
-  /// `value` is an SSA-use. Return the remapped version of `value` or a
-  /// placeholder that will be remapped later if this is an instruction that
-  /// has not yet been visited.
-  Value processValue(llvm::Value *value);
-  /// Translate the debug location to a FileLineColLoc, if `loc` is non-null.
-  /// Otherwise, return UnknownLoc.
-  Location processDebugLoc(llvm::DILocation *loc);
   /// `br` branches to `target`. Append the block arguments to attach to the
   /// generated branch op to `blockArguments`. These should be in the same order
   /// as the PHIs in `target`.
   LogicalResult processBranchArgs(llvm::Instruction *br,
                                   llvm::BasicBlock *target,
                                   SmallVectorImpl<Value> &blockArguments);
   /// Returns the builtin type equivalent to be used in attributes for the given
   /// LLVM IR dialect type.
private:
   DenseMap<llvm::Value *, Operation *> unknownInstMap;
   /// Uniquing map of GlobalVariables.
   DenseMap<llvm::GlobalVariable *, GlobalOp> globals;
   /// The stateful type translator (contains named structs).
   LLVM::TypeFromLLVMIRTranslator typeTranslator;
 };
 } // namespace
 
-Location Importer::processDebugLoc(llvm::DILocation *loc) {
+Location Importer::translateLoc(llvm::DILocation *loc) {
   if (!loc)
     return UnknownLoc::get(context);
 
   return FileLineColLoc::get(context, loc->getFilename(), loc->getLine(),
                              loc->getColumn());
 }
 
-Type Importer::processType(llvm::Type *type) {
-  if (Type result = typeTranslator.translateType(type))
-    return result;
-
-  // FIXME: Diagnostic should be able to natively handle types that have
-  // operator<<(raw_ostream&) defined.
-  std::string s;
-  llvm::raw_string_ostream os(s);
-  os << *type;
-  emitError(UnknownLoc::get(context)) << "unhandled type: " << os.str();
-  return nullptr;
+Type Importer::convertType(llvm::Type *type) {
+  return typeTranslator.translateType(type);
 }
 
 // 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 (auto *c = dyn_cast<llvm::ConstantFP>(value)) {
     assert(floatTy && "unsupported floating point type");
     return b.getFloatAttr(floatTy, c->getValueAPF());
   }
   if (auto *f = dyn_cast<llvm::Function>(value))
     return SymbolRefAttr::get(b.getContext(), f->getName());
 
   // Convert constant data to a dense elements attribute.
   if (auto *cd = dyn_cast<llvm::ConstantDataSequential>(value)) {
-    Type type = processType(cd->getElementType());
-    if (!type)
-      return nullptr;
-
-    auto attrType = getStdTypeForAttr(processType(cd->getType()))
+    Type type = convertType(cd->getElementType());
+    auto attrType = getStdTypeForAttr(convertType(cd->getType()))
                         .dyn_cast_or_null<ShapedType>();
     if (!attrType)
       return nullptr;
 
     if (type.isa<IntegerType>()) {
       SmallVector<APInt, 8> values;
       values.reserve(cd->getNumElements());
       for (unsigned i = 0, e = cd->getNumElements(); i < e; ++i)
if (auto *cd = dyn_cast<llvm::ConstantDataSequential>(value)) {
     }
 
     return nullptr;
   }
 
   // Unpack constant aggregates to create dense elements attribute whenever
   // possible. Return nullptr (failure) otherwise.
   if (isa<llvm::ConstantAggregate>(value)) {
-    auto outerType = getStdTypeForAttr(processType(value->getType()))
+    auto outerType = getStdTypeForAttr(convertType(value->getType()))
                          .dyn_cast_or_null<ShapedType>();
     if (!outerType)
       return nullptr;
 
     SmallVector<Attribute, 8> values;
     SmallVector<int64_t, 8> shape;
 
     for (unsigned i = 0, e = value->getNumOperands(); i < e; ++i) {
GlobalOp Importer::processGlobal(llvm::GlobalVariable *gv) {
   auto it = globals.find(gv);
   if (it != globals.end())
     return it->second;
 
   OpBuilder b(module.getBody(), getGlobalInsertPt());
   Attribute valueAttr;
   if (gv->hasInitializer())
     valueAttr = getConstantAsAttr(gv->getInitializer());
-  Type type = processType(gv->getValueType());
-  if (!type)
-    return nullptr;
+  Type type = convertType(gv->getValueType());
 
   uint64_t alignment = 0;
   llvm::MaybeAlign maybeAlign = gv->getAlign();
   if (maybeAlign.has_value()) {
     llvm::Align align = maybeAlign.value();
     alignment = align.value();
   }
 
GlobalOp Importer::processGlobal(llvm::GlobalVariable *gv) {
   return globals[gv] = op;
 }
 
 Value Importer::processConstant(llvm::Constant *c) {
   OpBuilder bEntry(currentEntryBlock, currentEntryBlock->begin());
   if (Attribute attr = getConstantAsAttr(c)) {
     // These constants can be represented as attributes.
     OpBuilder b(currentEntryBlock, currentEntryBlock->begin());
-    Type type = processType(c->getType());
-    if (!type)
-      return nullptr;
+    Type type = convertType(c->getType());
     if (auto symbolRef = attr.dyn_cast<FlatSymbolRefAttr>())
       return bEntry.create<AddressOfOp>(UnknownLoc::get(context), type,
                                         symbolRef.getValue());
     return bEntry.create<ConstantOp>(UnknownLoc::get(context), type, attr);
   }
   if (auto *cn = dyn_cast<llvm::ConstantPointerNull>(c)) {
-    Type type = processType(cn->getType());
-    if (!type)
-      return nullptr;
+    Type type = convertType(cn->getType());
     return bEntry.create<NullOp>(UnknownLoc::get(context), type);
   }
   if (auto *gv = dyn_cast<llvm::GlobalVariable>(c))
     return bEntry.create<AddressOfOp>(UnknownLoc::get(context),
                                       processGlobal(gv));
 
   if (auto *ce = dyn_cast<llvm::ConstantExpr>(c)) {
     llvm::Instruction *i = ce->getAsInstruction();
if (auto *ce = dyn_cast<llvm::ConstantExpr>(c)) {
     Value value = instMap[i];
     instMap.erase(i);
     // Remove this zombie LLVM instruction now, leaving us only with the MLIR
     // op.
     i->deleteValue();
     return value;
   }
   if (auto *ue = dyn_cast<llvm::UndefValue>(c)) {
-    Type type = processType(ue->getType());
-    if (!type)
-      return nullptr;
+    Type type = convertType(ue->getType());
     return bEntry.create<UndefOp>(UnknownLoc::get(context), type);
   }
 
   if (isa<llvm::ConstantAggregate>(c) || isa<llvm::ConstantAggregateZero>(c)) {
     unsigned numElements = c->getNumOperands();
     std::function<llvm::Constant *(unsigned)> getElement =
         [&](unsigned index) -> llvm::Constant * {
       return c->getAggregateElement(index);
     };
     // llvm::ConstantAggregateZero doesn't take any operand
     // so its getNumOperands is always zero.
     if (auto *caz = dyn_cast<llvm::ConstantAggregateZero>(c)) {
       numElements = caz->getElementCount().getFixedValue();
       // We want to capture the pointer rather than reference
       // to the pointer since the latter will become dangling upon
       // exiting the scope.
       getElement = [=](unsigned index) -> llvm::Constant * {
         return caz->getElementValue(index);
       };
     }
 
     // Generate a llvm.undef as the root value first.
-    Type rootType = processType(c->getType());
-    if (!rootType)
-      return nullptr;
+    Type rootType = convertType(c->getType());
     bool useInsertValue = rootType.isa<LLVMArrayType, LLVMStructType>();
     assert((useInsertValue || LLVM::isCompatibleVectorType(rootType)) &&
            "unrecognized aggregate type");
     Value root = bEntry.create<UndefOp>(UnknownLoc::get(context), rootType);
     for (unsigned i = 0; i < numElements; ++i) {
       llvm::Constant *element = getElement(i);
       Value elementValue = processConstant(element);
       if (!elementValue)
if (isa<llvm::ConstantAggregate>(c) || isa<llvm::ConstantAggregateZero>(c)) {
     }
     return root;
   }
 
   emitError(UnknownLoc::get(context)) << "unhandled constant: " << diag(*c);
   return nullptr;
 }
 
-Value Importer::processValue(llvm::Value *value) {
+Value Importer::lookupValue(llvm::Value *value) {
   auto it = instMap.find(value);
   if (it != instMap.end())
     return it->second;
 
   // We don't expect to see instructions in dominator order. If we haven't seen
   // this instruction yet, create an unknown op and remap it later.
   if (isa<llvm::Instruction>(value)) {
-    Type type = processType(value->getType());
-    if (!type)
-      return nullptr;
+    Type type = convertType(value->getType());
     unknownInstMap[value] =
         b.create(UnknownLoc::get(context), b.getStringAttr("llvm.unknown"),
                  /*operands=*/{}, type);
     return unknownInstMap[value]->getResult(0);
   }
 
   if (auto *c = dyn_cast<llvm::Constant>(value))
     return processConstant(c);
 
-  emitError(UnknownLoc::get(context)) << "unhandled value: " << diag(*value);
-  return nullptr;
+  llvm::errs() << diag(*value) << "\n";
+  llvm_unreachable("unhandled value");
+}
+
+SmallVector<Value> Importer::lookupValues(ArrayRef<llvm::Value *> values) {
+  SmallVector<Value> remapped;
+  remapped.reserve(values.size());
+  for (llvm::Value *value : values)
+    remapped.push_back(lookupValue(value));
+  return remapped;
 }
 
 /// Return the MLIR OperationName for the given LLVM opcode.
 static StringRef lookupOperationNameFromOpcode(unsigned opcode) {
 // Maps from LLVM opcode to MLIR OperationName. This is deliberately ordered
 // as in llvm/IR/Instructions.def to aid comprehension and spot missing
 // instructions.
 #define INST(llvm_n, mlir_n)                                                   \

 
 // `br` branches to `target`. Return the branch arguments to `br`, in the
 // same order of the PHIs in `target`.
 LogicalResult
 Importer::processBranchArgs(llvm::Instruction *br, llvm::BasicBlock *target,
                             SmallVectorImpl<Value> &blockArguments) {
   for (auto inst = target->begin(); isa<llvm::PHINode>(inst); ++inst) {
     auto *pn = cast<llvm::PHINode>(&*inst);
-    Value value = processValue(pn->getIncomingValueForBlock(br->getParent()));
-    if (!value)
-      return failure();
+    Value value = lookupValue(pn->getIncomingValueForBlock(br->getParent()));
     blockArguments.push_back(value);
   }
   return success();
 }
 
 LogicalResult Importer::processInstruction(llvm::Instruction *inst) {
   // FIXME: Support uses of SubtargetData. Currently inbounds GEPs, fast-math
   // flags and call / operand attributes are not supported.
-  Location loc = processDebugLoc(inst->getDebugLoc());
+  Location loc = translateLoc(inst->getDebugLoc());
   assert(!instMap.count(inst) &&
          "processInstruction must be called only once per instruction!");
   switch (inst->getOpcode()) {
   default:
     return emitError(loc) << "unknown instruction: " << diag(*inst);
   case llvm::Instruction::Add:
   case llvm::Instruction::FAdd:
   case llvm::Instruction::Sub:
LogicalResult Importer::processInstruction(llvm::Instruction *inst) {
   case llvm::Instruction::Freeze:
   case llvm::Instruction::BitCast:
   case llvm::Instruction::ExtractElement:
   case llvm::Instruction::InsertElement:
   case llvm::Instruction::Select:
   case llvm::Instruction::FNeg:
   case llvm::Instruction::Unreachable: {
     OperationState state(loc, lookupOperationNameFromOpcode(inst->getOpcode()));
-    SmallVector<Value, 4> ops;
-    ops.reserve(inst->getNumOperands());
-    for (auto *op : inst->operand_values()) {
-      Value value = processValue(op);
-      if (!value)
-        return failure();
-      ops.push_back(value);
-    }
-    state.addOperands(ops);
+    SmallVector<llvm::Value *> operands(inst->operand_values());
+    SmallVector<Value> ops = lookupValues(operands);
     if (!inst->getType()->isVoidTy()) {
-      Type type = processType(inst->getType());
-      if (!type)
-        return failure();
+      Type type = convertType(inst->getType());
       state.addTypes(type);
     }
+    state.addOperands(ops);
     Operation *op = b.create(state);
     if (!inst->getType()->isVoidTy())
       instMap[inst] = op->getResult(0);
     return success();
   }
   case llvm::Instruction::Alloca: {
-    Value size = processValue(inst->getOperand(0));
-    if (!size)
-      return failure();
-
+    Value size = lookupValue(inst->getOperand(0));
     auto *allocaInst = cast<llvm::AllocaInst>(inst);
     instMap[inst] =
-        b.create<AllocaOp>(loc, processType(inst->getType()),
-                           processType(allocaInst->getAllocatedType()), size,
+        b.create<AllocaOp>(loc, convertType(inst->getType()),
+                           convertType(allocaInst->getAllocatedType()), size,
                            allocaInst->getAlign().value());
     return success();
   }
   case llvm::Instruction::ICmp: {
-    Value lhs = processValue(inst->getOperand(0));
-    Value rhs = processValue(inst->getOperand(1));
-    if (!lhs || !rhs)
-      return failure();
+    Value lhs = lookupValue(inst->getOperand(0));
+    Value rhs = lookupValue(inst->getOperand(1));
     instMap[inst] = b.create<ICmpOp>(
         loc, getICmpPredicate(cast<llvm::ICmpInst>(inst)->getPredicate()), lhs,
         rhs);
     return success();
   }
   case llvm::Instruction::FCmp: {
-    Value lhs = processValue(inst->getOperand(0));
-    Value rhs = processValue(inst->getOperand(1));
-    if (!lhs || !rhs)
-      return failure();
+    Value lhs = lookupValue(inst->getOperand(0));
+    Value rhs = lookupValue(inst->getOperand(1));
 
     if (lhs.getType() != rhs.getType())
       return failure();
 
     Type boolType = b.getI1Type();
     Type resType = boolType;
     if (LLVM::isCompatibleVectorType(lhs.getType())) {
       unsigned numElements =
           LLVM::getVectorNumElements(lhs.getType()).getFixedValue();
       resType = VectorType::get({numElements}, boolType);
     }
 
     instMap[inst] = b.create<FCmpOp>(
         loc, resType,
         getFCmpPredicate(cast<llvm::FCmpInst>(inst)->getPredicate()), lhs, rhs);
     return success();
   }
   case llvm::Instruction::Br: {
     auto *brInst = cast<llvm::BranchInst>(inst);
     OperationState state(loc,
                          brInst->isConditional() ? "llvm.cond_br" : "llvm.br");
     if (brInst->isConditional()) {
-      Value condition = processValue(brInst->getCondition());
-      if (!condition)
-        return failure();
+      Value condition = lookupValue(brInst->getCondition());
       state.addOperands(condition);
     }
 
     std::array<int32_t, 3> operandSegmentSizes = {1, 0, 0};
     for (int i : llvm::seq<int>(0, brInst->getNumSuccessors())) {
       auto *succ = brInst->getSuccessor(i);
       SmallVector<Value, 4> blockArguments;
       if (failed(processBranchArgs(brInst, succ, blockArguments)))
case llvm::Instruction::Br: {
     }
 
     b.create(state);
     return success();
   }
   case llvm::Instruction::Switch: {
     auto *swInst = cast<llvm::SwitchInst>(inst);
     // Process the condition value.
-    Value condition = processValue(swInst->getCondition());
-    if (!condition)
-      return failure();
-
+    Value condition = lookupValue(swInst->getCondition());
     SmallVector<Value> defaultBlockArgs;
     // Process the default case.
     llvm::BasicBlock *defaultBB = swInst->getDefaultDest();
     if (failed(processBranchArgs(swInst, defaultBB, defaultBlockArgs)))
       return failure();
 
     // Process the cases.
     unsigned numCases = swInst->getNumCases();
for (const auto &en : llvm::enumerate(swInst->cases())) {
       caseBlocks[i] = blocks[succBB];
     }
 
     b.create<SwitchOp>(loc, condition, blocks[defaultBB], defaultBlockArgs,
                        caseValues, caseBlocks, caseOperandRefs);
     return success();
   }
   case llvm::Instruction::PHI: {
-    Type type = processType(inst->getType());
-    if (!type)
-      return failure();
+    Type type = convertType(inst->getType());
     instMap[inst] = b.getInsertionBlock()->addArgument(
-        type, processDebugLoc(inst->getDebugLoc()));
+        type, translateLoc(inst->getDebugLoc()));
     return success();
   }
   case llvm::Instruction::Call: {
     llvm::CallInst *ci = cast<llvm::CallInst>(inst);
-    SmallVector<Value, 4> ops;
-    ops.reserve(inst->getNumOperands());
-    for (auto &op : ci->args()) {
-      Value arg = processValue(op.get());
-      if (!arg)
-        return failure();
-      ops.push_back(arg);
-    }
-
+    SmallVector<llvm::Value *> args(ci->args());
+    SmallVector<Value> ops = lookupValues(args);
     SmallVector<Type, 2> tys;
     if (!ci->getType()->isVoidTy()) {
-      Type type = processType(inst->getType());
-      if (!type)
-        return failure();
+      Type type = convertType(inst->getType());
       tys.push_back(type);
     }
     Operation *op;
     if (llvm::Function *callee = ci->getCalledFunction()) {
       // For all intrinsics, try to generate to the corresponding op.
       if (callee->isIntrinsic()) {
         auto id = callee->getIntrinsicID();
         StringRef opName = lookupOperationNameFromIntrinsicID(id);
         if (!opName.empty()) {
           OperationState state(loc, opName);
           state.addOperands(ops);
           state.addTypes(tys);
           Operation *op = b.create(state);
           if (!inst->getType()->isVoidTy())
             instMap[inst] = op->getResult(0);
           return success();
         }
       }
       op = b.create<CallOp>(
           loc, tys, SymbolRefAttr::get(b.getContext(), callee->getName()), ops);
     } else {
-      Value calledValue = processValue(ci->getCalledOperand());
-      if (!calledValue)
-        return failure();
+      Value calledValue = lookupValue(ci->getCalledOperand());
       ops.insert(ops.begin(), calledValue);
       op = b.create<CallOp>(loc, tys, ops);
     }
     if (!ci->getType()->isVoidTy())
       instMap[inst] = op->getResult(0);
     return success();
   }
   case llvm::Instruction::LandingPad: {
     llvm::LandingPadInst *lpi = cast<llvm::LandingPadInst>(inst);
     SmallVector<Value, 4> ops;
 
     for (unsigned i = 0, ie = lpi->getNumClauses(); i < ie; i++)
       ops.push_back(processConstant(lpi->getClause(i)));
 
-    Type ty = processType(lpi->getType());
-    if (!ty)
-      return failure();
-
+    Type ty = convertType(lpi->getType());
     instMap[inst] = b.create<LandingpadOp>(loc, ty, lpi->isCleanup(), ops);
     return success();
   }
   case llvm::Instruction::Invoke: {
     llvm::InvokeInst *ii = cast<llvm::InvokeInst>(inst);
 
     SmallVector<Type, 2> tys;
     if (!ii->getType()->isVoidTy())
-      tys.push_back(processType(inst->getType()));
+      tys.push_back(convertType(inst->getType()));
 
-    SmallVector<Value, 4> ops;
-    ops.reserve(inst->getNumOperands() + 1);
-    for (auto &op : ii->args())
-      ops.push_back(processValue(op.get()));
+    SmallVector<llvm::Value *> args(ii->args());
+    SmallVector<Value> ops = lookupValues(args);
 
     SmallVector<Value, 4> normalArgs, unwindArgs;
     (void)processBranchArgs(ii, ii->getNormalDest(), normalArgs);
     (void)processBranchArgs(ii, ii->getUnwindDest(), unwindArgs);
 
     Operation *op;
     if (llvm::Function *callee = ii->getCalledFunction()) {
       op = b.create<InvokeOp>(
           loc, tys, SymbolRefAttr::get(b.getContext(), callee->getName()), ops,
           blocks[ii->getNormalDest()], normalArgs, blocks[ii->getUnwindDest()],
           unwindArgs);
     } else {
-      ops.insert(ops.begin(), processValue(ii->getCalledOperand()));
+      ops.insert(ops.begin(), lookupValue(ii->getCalledOperand()));
       op = b.create<InvokeOp>(loc, tys, ops, blocks[ii->getNormalDest()],
                               normalArgs, blocks[ii->getUnwindDest()],
                               unwindArgs);
     }
 
     if (!ii->getType()->isVoidTy())
       instMap[inst] = op->getResult(0);
     return success();
for (unsigned i = 0, e = ssNs.size(); i != e; i++) {
       }
     }
     b.create<FenceOp>(loc, getLLVMAtomicOrdering(fence->getOrdering()),
                       syncscope);
     return success();
   }
   case llvm::Instruction::AtomicRMW: {
     auto *atomicInst = cast<llvm::AtomicRMWInst>(inst);
-    Value ptr = processValue(atomicInst->getPointerOperand());
-    Value val = processValue(atomicInst->getValOperand());
-    if (!ptr || !val)
-      return failure();
+    Value ptr = lookupValue(atomicInst->getPointerOperand());
+    Value val = lookupValue(atomicInst->getValOperand());
 
     LLVM::AtomicBinOp binOp = getLLVMAtomicBinOp(atomicInst->getOperation());
     LLVM::AtomicOrdering ordering =
         getLLVMAtomicOrdering(atomicInst->getOrdering());
 
-    Type type = processType(inst->getType());
-    if (!type)
-      return failure();
-
+    Type type = convertType(inst->getType());
     instMap[inst] = b.create<AtomicRMWOp>(loc, type, binOp, ptr, val, ordering);
     return success();
   }
   case llvm::Instruction::AtomicCmpXchg: {
     auto *cmpXchgInst = cast<llvm::AtomicCmpXchgInst>(inst);
-    Value ptr = processValue(cmpXchgInst->getPointerOperand());
-    Value cmpVal = processValue(cmpXchgInst->getCompareOperand());
-    Value newVal = processValue(cmpXchgInst->getNewValOperand());
-    if (!ptr || !cmpVal || !newVal)
-      return failure();
+    Value ptr = lookupValue(cmpXchgInst->getPointerOperand());
+    Value cmpVal = lookupValue(cmpXchgInst->getCompareOperand());
+    Value newVal = lookupValue(cmpXchgInst->getNewValOperand());
 
     LLVM::AtomicOrdering ordering =
         getLLVMAtomicOrdering(cmpXchgInst->getSuccessOrdering());
     LLVM::AtomicOrdering failOrdering =
         getLLVMAtomicOrdering(cmpXchgInst->getFailureOrdering());
 
-    Type type = processType(inst->getType());
-    if (!type)
-      return failure();
-
+    Type type = convertType(inst->getType());
     instMap[inst] = b.create<AtomicCmpXchgOp>(loc, type, ptr, cmpVal, newVal,
                                               ordering, failOrdering);
     return success();
   }
   case llvm::Instruction::GetElementPtr: {
     // FIXME: Support inbounds GEPs.
     llvm::GetElementPtrInst *gep = cast<llvm::GetElementPtrInst>(inst);
-    Value basePtr = processValue(gep->getOperand(0));
-    Type sourceElementType = processType(gep->getSourceElementType());
+    Value basePtr = lookupValue(gep->getOperand(0));
+    Type sourceElementType = convertType(gep->getSourceElementType());
 
     // 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(gep->operand_values())) {
-      Value val = processValue(operand);
-      if (!val)
-        return failure();
+      Value val = lookupValue(operand);
       indices.push_back(val);
     }
 
-    Type type = processType(inst->getType());
-    if (!type)
-      return failure();
+    Type type = convertType(inst->getType());
     instMap[inst] =
         b.create<GEPOp>(loc, type, sourceElementType, basePtr, indices);
     return success();
   }
   case llvm::Instruction::InsertValue: {
     auto *ivInst = cast<llvm::InsertValueInst>(inst);
-    Value inserted = processValue(ivInst->getInsertedValueOperand());
-    if (!inserted)
-      return failure();
-    Value aggOperand = processValue(ivInst->getAggregateOperand());
-    if (!aggOperand)
-      return failure();
+    Value inserted = lookupValue(ivInst->getInsertedValueOperand());
+    Value aggOperand = lookupValue(ivInst->getAggregateOperand());
 
     SmallVector<int64_t> indices;
     llvm::append_range(indices, ivInst->getIndices());
     instMap[inst] = b.create<InsertValueOp>(loc, aggOperand, inserted, indices);
     return success();
   }
   case llvm::Instruction::ExtractValue: {
     auto *evInst = cast<llvm::ExtractValueInst>(inst);
-    Value aggOperand = processValue(evInst->getAggregateOperand());
-    if (!aggOperand)
-      return failure();
-
-    Type type = processType(inst->getType());
-    if (!type)
-      return failure();
+    Value aggOperand = lookupValue(evInst->getAggregateOperand());
 
     SmallVector<int64_t> indices;
     llvm::append_range(indices, evInst->getIndices());
     instMap[inst] = b.create<ExtractValueOp>(loc, aggOperand, indices);
     return success();
   }
   case llvm::Instruction::ShuffleVector: {
     auto *svInst = cast<llvm::ShuffleVectorInst>(inst);
-    Value vec1 = processValue(svInst->getOperand(0));
-    if (!vec1)
-      return failure();
-    Value vec2 = processValue(svInst->getOperand(1));
-    if (!vec2)
-      return failure();
+    Value vec1 = lookupValue(svInst->getOperand(0));
+    Value vec2 = lookupValue(svInst->getOperand(1));
 
     SmallVector<int32_t> mask(svInst->getShuffleMask());
     instMap[inst] = b.create<ShuffleVectorOp>(loc, vec1, vec2, mask);
     return success();
   }
   }
 }
 

 }
 
 LogicalResult Importer::processFunction(llvm::Function *f) {
   blocks.clear();
   instMap.clear();
   unknownInstMap.clear();
 
   auto functionType =
-      processType(f->getFunctionType()).dyn_cast<LLVMFunctionType>();
-  if (!functionType)
-    return failure();
-
+      convertType(f->getFunctionType()).dyn_cast<LLVMFunctionType>();
   if (f->isIntrinsic()) {
     StringRef opName = lookupOperationNameFromIntrinsicID(f->getIntrinsicID());
     // Skip the intrinsic decleration if we could found a corresponding op.
     if (!opName.empty())
       return success();
   }
 
   bool dsoLocal = f->hasLocalLinkage();
   CConv cconv = convertCConvFromLLVM(f->getCallingConv());
 
   b.setInsertionPoint(module.getBody(), getFuncInsertPt());
   LLVMFuncOp fop = b.create<LLVMFuncOp>(
       UnknownLoc::get(context), f->getName(), functionType,
       convertLinkageFromLLVM(f->getLinkage()), dsoLocal, cconv);
 
   for (const auto &arg : llvm::enumerate(functionType.getParams())) {
     llvm::SmallVector<NamedAttribute, 1> argAttrs;
     if (auto *type = f->getParamByValType(arg.index())) {
-      auto mlirType = processType(type);
+      auto mlirType = convertType(type);
       argAttrs.push_back(
           NamedAttribute(b.getStringAttr(LLVMDialect::getByValAttrName()),
                          TypeAttr::get(mlirType)));
     }
     if (auto *type = f->getParamByRefType(arg.index())) {
-      auto mlirType = processType(type);
+      auto mlirType = convertType(type);
       argAttrs.push_back(
           NamedAttribute(b.getStringAttr(LLVMDialect::getByRefAttrName()),
                          TypeAttr::get(mlirType)));
     }
     if (auto *type = f->getParamStructRetType(arg.index())) {
-      auto mlirType = processType(type);
+      auto mlirType = convertType(type);
       argAttrs.push_back(
           NamedAttribute(b.getStringAttr(LLVMDialect::getStructRetAttrName()),
                          TypeAttr::get(mlirType)));
     }
     if (auto *type = f->getParamInAllocaType(arg.index())) {
-      auto mlirType = processType(type);
+      auto mlirType = convertType(type);
       argAttrs.push_back(
           NamedAttribute(b.getStringAttr(LLVMDialect::getInAllocaAttrName()),
                          TypeAttr::get(mlirType)));
     }
 
     fop.setArgAttrs(arg.index(), argAttrs);
   }