[mlir][llvm] Use longer variable names in LLVM IR import (NFC).

[gysit]

Summary

Rename single letter member variables and function arguments to use
longer names in ConvertFromLLVMIR.cpp. Also drop some uses of auto in
favor our spelling out the type and refactor some llvm::enumerate loops.

[gysit]

Fix formatting.

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

 #include "mlir/Dialect/LLVMIR/LLVMConvertibleLLVMIRIntrinsics.inc"
   };
   return convertibleIntrinsics.contains(id);
 }
 
 // Utility to print an LLVM value as a string for passing to emitError().
 // FIXME: Diagnostic should be able to natively handle types that have
 // operator << (raw_ostream&) defined.
-static std::string diag(llvm::Value &v) {
-  std::string s;
-  llvm::raw_string_ostream os(s);
-  os << v;
+static std::string diag(llvm::Value &value) {
+  std::string str;
+  llvm::raw_string_ostream os(str);
+  os << value;
   return os.str();
 }
 
 /// Creates an attribute containing ABI and preferred alignment numbers parsed
 /// a string. The string may be either "abi:preferred" or just "abi". In the
 /// latter case, the prefrred alignment is considered equal to ABI alignment.
 static DenseIntElementsAttr parseDataLayoutAlignment(MLIRContext &ctx,
                                                      StringRef spec) {
case 80:
     return FloatType::getF80(&ctx);
   case 128:
     return FloatType::getF128(&ctx);
   default:
     return nullptr;
   }
 }
 
-static ICmpPredicate getICmpPredicate(llvm::CmpInst::Predicate p) {
-  switch (p) {
+static ICmpPredicate getICmpPredicate(llvm::CmpInst::Predicate pred) {
+  switch (pred) {
   default:
     llvm_unreachable("incorrect comparison predicate");
   case llvm::CmpInst::Predicate::ICMP_EQ:
     return LLVM::ICmpPredicate::eq;
   case llvm::CmpInst::Predicate::ICMP_NE:
     return LLVM::ICmpPredicate::ne;
   case llvm::CmpInst::Predicate::ICMP_SLT:
     return LLVM::ICmpPredicate::slt;
static ICmpPredicate getICmpPredicate(llvm::CmpInst::Predicate pred) {
   case llvm::CmpInst::Predicate::ICMP_UGT:
     return LLVM::ICmpPredicate::ugt;
   case llvm::CmpInst::Predicate::ICMP_UGE:
     return LLVM::ICmpPredicate::uge;
   }
   llvm_unreachable("incorrect integer comparison predicate");
 }
 
-static FCmpPredicate getFCmpPredicate(llvm::CmpInst::Predicate p) {
-  switch (p) {
+static FCmpPredicate getFCmpPredicate(llvm::CmpInst::Predicate pred) {
+  switch (pred) {
   default:
     llvm_unreachable("incorrect comparison predicate");
   case llvm::CmpInst::Predicate::FCMP_FALSE:
     return LLVM::FCmpPredicate::_false;
   case llvm::CmpInst::Predicate::FCMP_TRUE:
     return LLVM::FCmpPredicate::_true;
   case llvm::CmpInst::Predicate::FCMP_OEQ:
     return LLVM::FCmpPredicate::oeq;
getTopologicallySortedBlocks(llvm::Function *func) {
   return blocks;
 }
 
 // Handles importing globals and functions from an LLVM module.
 namespace {
 class Importer {
 public:
   Importer(MLIRContext *context, ModuleOp module)
-      : b(context), context(context), module(module), typeTranslator(*context) {
-    b.setInsertionPointToStart(module.getBody());
+      : builder(context), context(context), module(module),
+        typeTranslator(*context) {
+    builder.setInsertionPointToStart(module.getBody());
   }
 
   /// Stores the mapping between an LLVM value and its MLIR counterpart.
   void mapValue(llvm::Value *llvm, Value mlir) { mapValue(llvm) = mlir; }
 
   /// Provides write-once access to store the MLIR value corresponding to the
   /// given LLVM value.
   Value &mapValue(llvm::Value *value) {
public:
   /// counterpart exists. Otherwise, returns failure.
   LogicalResult convertIntrinsic(OpBuilder &odsBuilder, llvm::CallInst *inst);
 
   /// Converts an LLVM instruction to an MLIR LLVM dialect operation if the
   /// operation defines an MLIR Builder. Otherwise, returns failure.
   LogicalResult convertOperation(OpBuilder &odsBuilder,
                                  llvm::Instruction *inst);
 
-  /// Imports `f` into the current module.
-  LogicalResult processFunction(llvm::Function *f);
+  /// Imports `func` into the current module.
+  LogicalResult processFunction(llvm::Function *func);
 
-  /// Converts function attributes of LLVM Function \p f
+  /// Converts function attributes of LLVM Function \p func
   /// into LLVM dialect attributes of LLVMFuncOp \p funcOp.
-  void processFunctionAttributes(llvm::Function *f, LLVMFuncOp funcOp);
+  void processFunctionAttributes(llvm::Function *func, 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);
+  /// Returns personality of `func` as a FlatSymbolRefAttr.
+  FlatSymbolRefAttr getPersonalityAsAttr(llvm::Function *func);
   /// Imports `bb` into `block`, which must be initially empty.
   LogicalResult processBasicBlock(llvm::BasicBlock *bb, Block *block);
   /// Imports `inst` and populates valueMapping[inst] with the result of the
   /// imported operation.
   LogicalResult processInstruction(llvm::Instruction *inst);
   /// `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.
   Type getStdTypeForAttr(Type type);
   /// Return `value` as an attribute to attach to a GlobalOp.
   Attribute getConstantAsAttr(llvm::Constant *value);
-  /// Return `c` as an MLIR Value. This could either be a ConstantOp, or
+  /// Return `constant` as an MLIR Value. This could either be a ConstantOp, or
   /// an expanded sequence of ops in the current function's entry block (for
   /// ConstantExprs or ConstantGEPs).
-  Value processConstant(llvm::Constant *c);
+  Value processConstant(llvm::Constant *constant);
 
-  /// The current builder, pointing at where the next Instruction should be
-  /// generated.
-  OpBuilder b;
+  /// Builder pointing at where the next Instruction should be generated.
+  OpBuilder builder;
   /// The current context.
   MLIRContext *context;
   /// The current module being created.
   ModuleOp module;
   /// The entry block of the current function being processed.
   Block *currentEntryBlock = nullptr;
 
   /// Globals are inserted before the first function, if any.
   Block::iterator getGlobalInsertPt() {
-    auto it = module.getBody()->begin();
-    auto endIt = module.getBody()->end();
+    Block::iterator it = module.getBody()->begin();
+    Block::iterator endIt = module.getBody()->end();
     while (it != endIt && !isa<LLVMFuncOp>(it))
       ++it;
     return it;
   }
 
   /// Functions are always inserted before the module terminator.
   Block::iterator getFuncInsertPt() {
     return std::prev(module.getBody()->end());
Type Importer::getStdTypeForAttr(Type type) {
   if (!type)
     return nullptr;
 
   if (type.isa<IntegerType, FloatType>())
     return type;
 
   // LLVM vectors can only contain scalars.
   if (LLVM::isCompatibleVectorType(type)) {
-    auto numElements = LLVM::getVectorNumElements(type);
+    llvm::ElementCount numElements = LLVM::getVectorNumElements(type);
     if (numElements.isScalable()) {
       emitError(UnknownLoc::get(context)) << "scalable vectors not supported";
       return nullptr;
     }
     Type elementType = getStdTypeForAttr(LLVM::getVectorElementType(type));
     if (!elementType)
       return nullptr;
     return VectorType::get(numElements.getKnownMinValue(), elementType);
   }
 
   // LLVM arrays can contain other arrays or vectors.
   if (auto arrayType = type.dyn_cast<LLVMArrayType>()) {
     // Recover the nested array shape.
     SmallVector<int64_t, 4> shape;
     shape.push_back(arrayType.getNumElements());
     while (arrayType.getElementType().isa<LLVMArrayType>()) {
       arrayType = arrayType.getElementType().cast<LLVMArrayType>();
       shape.push_back(arrayType.getNumElements());
     }
 
     // If the innermost type is a vector, use the multi-dimensional vector as
     // attribute type.
     if (LLVM::isCompatibleVectorType(arrayType.getElementType())) {
-      auto numElements = LLVM::getVectorNumElements(arrayType.getElementType());
+      llvm::ElementCount numElements =
+          LLVM::getVectorNumElements(arrayType.getElementType());
       if (numElements.isScalable()) {
         emitError(UnknownLoc::get(context)) << "scalable vectors not supported";
         return nullptr;
       }
       shape.push_back(numElements.getKnownMinValue());
 
       Type elementType = getStdTypeForAttr(
           LLVM::getVectorElementType(arrayType.getElementType()));
Type Importer::getStdTypeForAttr(Type type) {
 
   return nullptr;
 }
 
 // Get the given constant as an attribute. Not all constants can be represented
 // as attributes.
 Attribute Importer::getConstantAsAttr(llvm::Constant *value) {
   if (auto *ci = dyn_cast<llvm::ConstantInt>(value))
-    return b.getIntegerAttr(
+    return builder.getIntegerAttr(
         IntegerType::get(context, ci->getType()->getBitWidth()),
         ci->getValue());
   if (auto *c = dyn_cast<llvm::ConstantDataArray>(value))
     if (c->isString())
-      return b.getStringAttr(c->getAsString());
+      return builder.getStringAttr(c->getAsString());
   if (auto *c = dyn_cast<llvm::ConstantFP>(value)) {
-    auto *type = c->getType();
+    llvm::Type *type = c->getType();
     FloatType floatTy;
     if (type->isBFloatTy())
       floatTy = FloatType::getBF16(context);
     else
       floatTy = getDLFloatType(*context, type->getScalarSizeInBits());
     assert(floatTy && "unsupported floating point type");
-    return b.getFloatAttr(floatTy, c->getValueAPF());
+    return builder.getFloatAttr(floatTy, c->getValueAPF());
   }
   if (auto *f = dyn_cast<llvm::Function>(value))
-    return SymbolRefAttr::get(b.getContext(), f->getName());
+    return SymbolRefAttr::get(builder.getContext(), f->getName());
 
   // Convert constant data to a dense elements attribute.
   if (auto *cd = dyn_cast<llvm::ConstantDataSequential>(value)) {
     Type type = convertType(cd->getElementType());
     auto attrType = getStdTypeForAttr(convertType(cd->getType()))
                         .dyn_cast_or_null<ShapedType>();
     if (!attrType)
       return nullptr;
GlobalOp Importer::processGlobal(llvm::GlobalVariable *gv) {
   if (gv->hasAtLeastLocalUnnamedAddr())
     op.setUnnamedAddr(convertUnnamedAddrFromLLVM(gv->getUnnamedAddr()));
   if (gv->hasSection())
     op.setSection(gv->getSection());
 
   return globals[gv] = op;
 }
 
-Value Importer::processConstant(llvm::Constant *c) {
+Value Importer::processConstant(llvm::Constant *constant) {
   OpBuilder bEntry(currentEntryBlock, currentEntryBlock->begin());
-  if (Attribute attr = getConstantAsAttr(c)) {
+  if (Attribute attr = getConstantAsAttr(constant)) {
     // These constants can be represented as attributes.
     OpBuilder b(currentEntryBlock, currentEntryBlock->begin());
-    Type type = convertType(c->getType());
+    Type type = convertType(constant->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)) {
+  if (auto *cn = dyn_cast<llvm::ConstantPointerNull>(constant)) {
     Type type = convertType(cn->getType());
     return bEntry.create<NullOp>(UnknownLoc::get(context), type);
   }
-  if (auto *gv = dyn_cast<llvm::GlobalVariable>(c))
+  if (auto *gv = dyn_cast<llvm::GlobalVariable>(constant))
     return bEntry.create<AddressOfOp>(UnknownLoc::get(context),
                                       processGlobal(gv));
 
-  if (auto *ce = dyn_cast<llvm::ConstantExpr>(c)) {
+  if (auto *ce = dyn_cast<llvm::ConstantExpr>(constant)) {
     llvm::Instruction *i = ce->getAsInstruction();
-    OpBuilder::InsertionGuard guard(b);
-    b.setInsertionPoint(currentEntryBlock, currentEntryBlock->begin());
+    OpBuilder::InsertionGuard guard(builder);
+    builder.setInsertionPoint(currentEntryBlock, currentEntryBlock->begin());
     if (failed(processInstruction(i)))
       return nullptr;
     assert(valueMapping.count(i));
 
     // If we don't remove entry of `i` here, it's totally possible that the
     // next time llvm::ConstantExpr::getAsInstruction is called again, which
     // always allocates a new Instruction, memory address of the newly
     // created Instruction might be the same as `i`. Making processInstruction
     // falsely believe that the new Instruction has been processed before
     // and raised an assertion error.
     Value value = valueMapping[i];
     valueMapping.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)) {
+  if (auto *ue = dyn_cast<llvm::UndefValue>(constant)) {
     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();
+  if (isa<llvm::ConstantAggregate>(constant) ||
+      isa<llvm::ConstantAggregateZero>(constant)) {
+    unsigned numElements = constant->getNumOperands();
     std::function<llvm::Constant *(unsigned)> getElement =
         [&](unsigned index) -> llvm::Constant * {
-      return c->getAggregateElement(index);
+      return constant->getAggregateElement(index);
     };
     // llvm::ConstantAggregateZero doesn't take any operand
     // so its getNumOperands is always zero.
-    if (auto *caz = dyn_cast<llvm::ConstantAggregateZero>(c)) {
+    if (auto *caz = dyn_cast<llvm::ConstantAggregateZero>(constant)) {
       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 = convertType(c->getType());
+    Type rootType = convertType(constant->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)
for (unsigned i = 0; i < numElements; ++i) {
           return nullptr;
         root = bEntry.create<InsertElementOp>(
             UnknownLoc::get(context), rootType, root, elementValue, indexValue);
       }
     }
     return root;
   }
 
-  emitError(UnknownLoc::get(context)) << "unhandled constant: " << diag(*c);
+  emitError(UnknownLoc::get(context))
+      << "unhandled constant: " << diag(*constant);
   return nullptr;
 }
 
 Value Importer::processValue(llvm::Value *value) {
   auto it = valueMapping.find(value);
   if (it != valueMapping.end())
     return it->second;
 
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 all intrinsics that provide an MLIR builder.
   if (auto *callInst = dyn_cast<llvm::CallInst>(inst))
-    if (succeeded(convertIntrinsic(b, callInst)))
+    if (succeeded(convertIntrinsic(builder, callInst)))
       return success();
 
   // Convert all operations that provide an MLIR builder.
-  if (succeeded(convertOperation(b, inst)))
+  if (succeeded(convertOperation(builder, inst)))
     return success();
 
   // Convert all special 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);
     OperationState state(loc,
                          brInst->isConditional() ? "llvm.cond_br" : "llvm.br");
     if (brInst->isConditional()) {
       Value condition = processValue(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);
+      llvm::BasicBlock *succ = brInst->getSuccessor(i);
       SmallVector<Value, 4> blockArguments;
       if (failed(processBranchArgs(brInst, succ, blockArguments)))
         return failure();
       state.addSuccessors(lookupBlock(succ));
       state.addOperands(blockArguments);
       operandSegmentSizes[i + 1] = blockArguments.size();
     }
 
     if (brInst->isConditional()) {
       state.addAttribute(LLVM::CondBrOp::getOperandSegmentSizeAttr(),
-                         b.getDenseI32ArrayAttr(operandSegmentSizes));
+                         builder.getDenseI32ArrayAttr(operandSegmentSizes));
     }
 
-    b.create(state);
+    builder.create(state);
     return success();
   }
   if (inst->getOpcode() == llvm::Instruction::Switch) {
     auto *swInst = cast<llvm::SwitchInst>(inst);
     // Process the condition value.
     Value condition = processValue(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();
     SmallVector<SmallVector<Value>> caseOperands(numCases);
     SmallVector<ValueRange> caseOperandRefs(numCases);
     SmallVector<int32_t> caseValues(numCases);
     SmallVector<Block *> caseBlocks(numCases);
-    for (const auto &en : llvm::enumerate(swInst->cases())) {
-      const llvm::SwitchInst::CaseHandle &caseHandle = en.value();
-      unsigned i = en.index();
+    for (const auto &it : llvm::enumerate(swInst->cases())) {
+      const llvm::SwitchInst::CaseHandle &caseHandle = it.value();
       llvm::BasicBlock *succBB = caseHandle.getCaseSuccessor();
-      if (failed(processBranchArgs(swInst, succBB, caseOperands[i])))
+      if (failed(processBranchArgs(swInst, succBB, caseOperands[it.index()])))
         return failure();
-      caseOperandRefs[i] = caseOperands[i];
-      caseValues[i] = caseHandle.getCaseValue()->getSExtValue();
-      caseBlocks[i] = lookupBlock(succBB);
+      caseOperandRefs[it.index()] = caseOperands[it.index()];
+      caseValues[it.index()] = caseHandle.getCaseValue()->getSExtValue();
+      caseBlocks[it.index()] = lookupBlock(succBB);
     }
 
-    b.create<SwitchOp>(loc, condition, lookupBlock(defaultBB), defaultBlockArgs,
-                       caseValues, caseBlocks, caseOperandRefs);
+    builder.create<SwitchOp>(loc, condition, lookupBlock(defaultBB),
+                             defaultBlockArgs, caseValues, caseBlocks,
+                             caseOperandRefs);
     return success();
   }
   if (inst->getOpcode() == llvm::Instruction::PHI) {
     Type type = convertType(inst->getType());
-    mapValue(inst, b.getInsertionBlock()->addArgument(
+    mapValue(inst, builder.getInsertionBlock()->addArgument(
                        type, translateLoc(inst->getDebugLoc())));
     return success();
   }
   if (inst->getOpcode() == llvm::Instruction::Call) {
     llvm::CallInst *ci = cast<llvm::CallInst>(inst);
     SmallVector<llvm::Value *> args(ci->args());
     SmallVector<Value> ops = processValues(args);
     SmallVector<Type, 2> tys;
     if (!ci->getType()->isVoidTy()) {
       Type type = convertType(inst->getType());
       tys.push_back(type);
     }
     Operation *op;
     if (llvm::Function *callee = ci->getCalledFunction()) {
-      op = b.create<CallOp>(
-          loc, tys, SymbolRefAttr::get(b.getContext(), callee->getName()), ops);
+      op = builder.create<CallOp>(
+          loc, tys, SymbolRefAttr::get(builder.getContext(), callee->getName()),
+          ops);
     } else {
       Value calledValue = processValue(ci->getCalledOperand());
       ops.insert(ops.begin(), calledValue);
-      op = b.create<CallOp>(loc, tys, ops);
+      op = builder.create<CallOp>(loc, tys, ops);
     }
     if (!ci->getType()->isVoidTy())
       mapValue(inst, op->getResult(0));
     return success();
   }
   if (inst->getOpcode() == 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 = convertType(lpi->getType());
-    Value res = b.create<LandingpadOp>(loc, ty, lpi->isCleanup(), ops);
+    Value res = builder.create<LandingpadOp>(loc, ty, lpi->isCleanup(), ops);
     mapValue(inst, res);
     return success();
   }
   if (inst->getOpcode() == llvm::Instruction::Invoke) {
     llvm::InvokeInst *ii = cast<llvm::InvokeInst>(inst);
 
     SmallVector<Type, 2> tys;
     if (!ii->getType()->isVoidTy())
       tys.push_back(convertType(inst->getType()));
 
     SmallVector<llvm::Value *> args(ii->args());
     SmallVector<Value> ops = processValues(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,
-          lookupBlock(ii->getNormalDest()), normalArgs,
+      op = builder.create<InvokeOp>(
+          loc, tys, SymbolRefAttr::get(builder.getContext(), callee->getName()),
+          ops, lookupBlock(ii->getNormalDest()), normalArgs,
           lookupBlock(ii->getUnwindDest()), unwindArgs);
     } else {
       ops.insert(ops.begin(), processValue(ii->getCalledOperand()));
-      op = b.create<InvokeOp>(loc, tys, ops, lookupBlock(ii->getNormalDest()),
-                              normalArgs, lookupBlock(ii->getUnwindDest()),
-                              unwindArgs);
+      op = builder.create<InvokeOp>(
+          loc, tys, ops, lookupBlock(ii->getNormalDest()), normalArgs,
+          lookupBlock(ii->getUnwindDest()), unwindArgs);
     }
 
     if (!ii->getType()->isVoidTy())
       mapValue(inst, op->getResult(0));
     return success();
   }
   if (inst->getOpcode() == llvm::Instruction::GetElementPtr) {
     // FIXME: Support inbounds GEPs.
     llvm::GetElementPtrInst *gep = cast<llvm::GetElementPtrInst>(inst);
     Value basePtr = processValue(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);
       indices.push_back(val);
     }
 
     Type type = convertType(inst->getType());
-    Value res = b.create<GEPOp>(loc, type, sourceElementType, basePtr, indices);
+    Value res =
+        builder.create<GEPOp>(loc, type, sourceElementType, basePtr, indices);
     mapValue(inst, res);
     return success();
   }
 
   return emitError(loc) << "unknown instruction: " << diag(*inst);
 }
 
 FlatSymbolRefAttr Importer::getPersonalityAsAttr(llvm::Function *f) {
   if (!f->hasPersonalityFn())
     return nullptr;
 
   llvm::Constant *pf = f->getPersonalityFn();
 
   // If it directly has a name, we can use it.
   if (pf->hasName())
-    return SymbolRefAttr::get(b.getContext(), pf->getName());
+    return SymbolRefAttr::get(builder.getContext(), pf->getName());
 
   // If it doesn't have a name, currently, only function pointers that are
   // bitcast to i8* are parsed.
   if (auto *ce = dyn_cast<llvm::ConstantExpr>(pf)) {
     if (ce->getOpcode() == llvm::Instruction::BitCast &&
         ce->getType() == llvm::Type::getInt8PtrTy(f->getContext())) {
       if (auto *func = dyn_cast<llvm::Function>(ce->getOperand(0)))
-        return SymbolRefAttr::get(b.getContext(), func->getName());
+        return SymbolRefAttr::get(builder.getContext(), func->getName());
     }
   }
   return FlatSymbolRefAttr();
 }
 
 void Importer::processFunctionAttributes(llvm::Function *func,
                                          LLVMFuncOp funcOp) {
   auto addNamedUnitAttr = [&](StringRef name) {
     return funcOp->setAttr(name, UnitAttr::get(context));
   };
   if (func->hasFnAttribute(llvm::Attribute::ReadNone))
     addNamedUnitAttr(LLVMDialect::getReadnoneAttrName());
 }
 
-LogicalResult Importer::processFunction(llvm::Function *f) {
+LogicalResult Importer::processFunction(llvm::Function *func) {
   blockMapping.clear();
   valueMapping.clear();
 
   auto functionType =
-      convertType(f->getFunctionType()).dyn_cast<LLVMFunctionType>();
-  if (f->isIntrinsic() && isConvertibleIntrinsic(f->getIntrinsicID()))
+      convertType(func->getFunctionType()).dyn_cast<LLVMFunctionType>();
+  if (func->isIntrinsic() && isConvertibleIntrinsic(func->getIntrinsicID()))
     return success();
 
-  bool dsoLocal = f->hasLocalLinkage();
-  CConv cconv = convertCConvFromLLVM(f->getCallingConv());
+  bool dsoLocal = func->hasLocalLinkage();
+  CConv cconv = convertCConvFromLLVM(func->getCallingConv());
 
-  b.setInsertionPoint(module.getBody(), getFuncInsertPt());
-  LLVMFuncOp fop = b.create<LLVMFuncOp>(
-      UnknownLoc::get(context), f->getName(), functionType,
-      convertLinkageFromLLVM(f->getLinkage()), dsoLocal, cconv);
+  builder.setInsertionPoint(module.getBody(), getFuncInsertPt());
+  LLVMFuncOp funcOp = builder.create<LLVMFuncOp>(
+      UnknownLoc::get(context), func->getName(), functionType,
+      convertLinkageFromLLVM(func->getLinkage()), dsoLocal, cconv);
 
-  for (const auto &arg : llvm::enumerate(functionType.getParams())) {
+  for (const auto &it : llvm::enumerate(functionType.getParams())) {
     llvm::SmallVector<NamedAttribute, 1> argAttrs;
-    if (auto *type = f->getParamByValType(arg.index())) {
-      auto mlirType = convertType(type);
+    if (auto *type = func->getParamByValType(it.index())) {
+      Type mlirType = convertType(type);
       argAttrs.push_back(
-          NamedAttribute(b.getStringAttr(LLVMDialect::getByValAttrName()),
+          NamedAttribute(builder.getStringAttr(LLVMDialect::getByValAttrName()),
                          TypeAttr::get(mlirType)));
     }
-    if (auto *type = f->getParamByRefType(arg.index())) {
-      auto mlirType = convertType(type);
+    if (auto *type = func->getParamByRefType(it.index())) {
+      Type mlirType = convertType(type);
       argAttrs.push_back(
-          NamedAttribute(b.getStringAttr(LLVMDialect::getByRefAttrName()),
+          NamedAttribute(builder.getStringAttr(LLVMDialect::getByRefAttrName()),
                          TypeAttr::get(mlirType)));
     }
-    if (auto *type = f->getParamStructRetType(arg.index())) {
-      auto mlirType = convertType(type);
-      argAttrs.push_back(
-          NamedAttribute(b.getStringAttr(LLVMDialect::getStructRetAttrName()),
-                         TypeAttr::get(mlirType)));
+    if (auto *type = func->getParamStructRetType(it.index())) {
+      Type mlirType = convertType(type);
+      argAttrs.push_back(NamedAttribute(
+          builder.getStringAttr(LLVMDialect::getStructRetAttrName()),
     }
-    if (auto *type = f->getParamInAllocaType(arg.index())) {
-      auto mlirType = convertType(type);
-      argAttrs.push_back(
-          NamedAttribute(b.getStringAttr(LLVMDialect::getInAllocaAttrName()),
-                         TypeAttr::get(mlirType)));
+    if (auto *type = func->getParamInAllocaType(it.index())) {
+      Type mlirType = convertType(type);
+      argAttrs.push_back(NamedAttribute(
+          builder.getStringAttr(LLVMDialect::getInAllocaAttrName()),
     }
 
-    fop.setArgAttrs(arg.index(), argAttrs);
+    funcOp.setArgAttrs(it.index(), argAttrs);
   }
 
-  if (FlatSymbolRefAttr personality = getPersonalityAsAttr(f))
-    fop.setPersonalityAttr(personality);
-  else if (f->hasPersonalityFn())
+  if (FlatSymbolRefAttr personality = getPersonalityAsAttr(func))
+    funcOp.setPersonalityAttr(personality);
+  else if (func->hasPersonalityFn())
     emitWarning(UnknownLoc::get(context),
                 "could not deduce personality, skipping it");
 
-  if (f->hasGC())
-    fop.setGarbageCollector(StringRef(f->getGC()));
+  if (func->hasGC())
+    funcOp.setGarbageCollector(StringRef(func->getGC()));
 
   // Handle Function attributes.
-  processFunctionAttributes(f, fop);
+  processFunctionAttributes(func, funcOp);
 
-  if (f->isDeclaration())
+  if (func->isDeclaration())
     return success();
 
   // Eagerly create all blocks.
-  for (llvm::BasicBlock &bb : *f) {
-    Block *block = b.createBlock(&fop.getBody(), fop.getBody().end());
+  for (llvm::BasicBlock &bb : *func) {
+    Block *block =
+        builder.createBlock(&funcOp.getBody(), funcOp.getBody().end());
     mapBlock(&bb, block);
   }
-  currentEntryBlock = &fop.getFunctionBody().getBlocks().front();
+  currentEntryBlock = &funcOp.getFunctionBody().getBlocks().front();
 
   // Add function arguments to the entry block.
-  for (const auto &it : llvm::enumerate(f->args())) {
-    BlockArgument blockArg = fop.getFunctionBody().addArgument(
-        functionType.getParamType(it.index()), fop.getLoc());
+  for (const auto &it : llvm::enumerate(func->args())) {
+    BlockArgument blockArg = funcOp.getFunctionBody().addArgument(
+        functionType.getParamType(it.index()), funcOp.getLoc());
     mapValue(&it.value(), blockArg);
   }
 
   // Process the blocks in topological order. The ordered traversal ensures
   // operands defined in a dominating block have a valid mapping to an MLIR
   // value once a block is translated.
-  SetVector<llvm::BasicBlock *> blocks = getTopologicallySortedBlocks(f);
+  SetVector<llvm::BasicBlock *> blocks = getTopologicallySortedBlocks(func);
   for (llvm::BasicBlock *bb : blocks) {
     if (failed(processBasicBlock(bb, lookupBlock(bb))))
       return failure();
   }
 
   return success();
 }
 
 LogicalResult Importer::processBasicBlock(llvm::BasicBlock *bb, Block *block) {
-  b.setInsertionPointToStart(block);
+  builder.setInsertionPointToStart(block);
   for (llvm::Instruction &inst : *bb) {
     if (failed(processInstruction(&inst)))
       return failure();
   }
   return success();
 }
 
 OwningOpRef<ModuleOp>