[mlir][llvm] Introduce a mapValue function in LLVMIR import (nfc).

[gysit]

Summary

The revision adds a mapValue function to the Importer, which can be used
in the MLIR builders to provide controlled accesses to the result
mapping of the imported instructions. Additionally, the change allows us
to avoid accessing a private member variable of the Importer class,
which simplifies future refactorings that aim at factoring out a
conversion interface (similar to the MLIR to LLVM translation). The
revision also renames the variables used when emitting the MLIR builders
to prepare the generalization to non-intrinsic instructions. In
particular, it renames callInst to inst and it passes in the instruction
arguments using an llvmOperands array rather than accessing the call
arguments directly.

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;", "");
 
   // A builder to construct the MLIR LLVM dialect operation given the matching
-  // LLVM IR intrinsic instruction `callInst`. The following $-variables exist:
-  //   - $name - substituted by the remapped `callInst` argument using the
-  //             the index of the MLIR operation argument with the given name;
+  // LLVM IR instruction `inst` and its operands `llvmOperands`. The
+  // following $-variables exist:
+  //   - $name - substituted by the remapped `inst` operand value at the index
+  //             of the MLIR operation argument with the given name, or if the
+  //             name matches the result name, by a reference to store the
+  //             result of the newly created MLIR operation to;
   //   - $_int_attr - substituted by a call to an integer attribute matcher;
   //   - $_resultType - substituted with the MLIR result type;
   //   - $_location - substituted with the MLIR location;
   //   - $_builder - substituted with the MLIR builder;
   //   - $_qualCppClassName - substitiuted with the MLIR operation class name.
   // Additionally, `$$` can be used to produce the dollar character.
   // NOTE: The $name variable resolution assumes the MLIR and LLVM argument
   // orders match and there are no optional or variadic arguments.
   string mlirBuilder = [{
-    SmallVector<llvm::Value *> operands(callInst->args());
     SmallVector<Type> resultTypes =
-    }] # !if(!gt(numResults, 0),
-      "{$_resultType};", "{};") # [{
+    }] # !if(!gt(numResults, 0), "{$_resultType};", "{};") # [{
     Operation *op = $_builder.create<$_qualCppClassName>(
       $_location,
       resultTypes,
-      processValues(operands));
-    }] # !if(!gt(numResults, 0),
-      "instMap[callInst] = op->getResult(0);", "(void)op;");
+      processValues(llvmOperands));
+    }] # !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,
                   bit requiresAliasScope = 0>

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());
   }
 
+  /// Stores the mapping between an LLVM value and its MLIR counterpart.
+  void mapValue(llvm::Value *llvm, Value mlir) { mapValue(llvm) = mlir; }
+
+  /// Provides write-once access to store the MLIR value corresponding to the
+  /// given LLVM value.
+  Value &mapValue(llvm::Value *value) {
+    Value &mlir = valueMapping[value];
+    assert(mlir == nullptr &&
+           "attempting to map a value that is already mapped");
+    return mlir;
+  }
+
   /// Returns the remapped version of `value` or a placeholder that will be
   /// remapped later if the defining instruction has not yet been visited.
   Value processValue(llvm::Value *value);
 
   /// Calls `processValue` for a range of `values` and returns their remapped
   /// values or placeholders if the defining instructions have not yet been
   /// visited.
   SmallVector<Value> processValues(ArrayRef<llvm::Value *> values);
 
   /// Converts `value` to an integer attribute. Asserts if the conversion fails.
   IntegerAttr matchIntegerAttr(Value value);
 
   /// 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);
 
   /// Converts an LLVM intrinsic to an MLIR LLVM dialect operation if an MLIR
   /// counterpart exists. Otherwise, returns failure.
-  LogicalResult convertIntrinsic(OpBuilder &odsBuilder,
-                                 llvm::CallInst *callInst);
+  LogicalResult convertIntrinsic(OpBuilder &odsBuilder, llvm::CallInst *inst);
 
   /// 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.
+  /// 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
private:
 
   /// Functions are always inserted before the module terminator.
   Block::iterator getFuncInsertPt() {
     return std::prev(module.getBody()->end());
   }
 
   /// Remapped blocks, for the current function.
   DenseMap<llvm::BasicBlock *, Block *> blocks;
-  /// Remapped values. These are function-local.
-  DenseMap<llvm::Value *, Value> instMap;
+  /// Mappings between original and imported values. These are function-local.
+  DenseMap<llvm::Value *, Value> valueMapping;
   /// Instructions that had not been defined when first encountered as a use.
   /// Maps to the dummy Operation that was created in processValue().
   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::translateLoc(llvm::DILocation *loc) {
   if (!loc)
     return UnknownLoc::get(context);
 
   return FileLineColLoc::get(context, loc->getFilename(), loc->getLine(),
                              loc->getColumn());
 }
 
 Type Importer::convertType(llvm::Type *type) {
   return typeTranslator.translateType(type);
 }
 
 LogicalResult Importer::convertIntrinsic(OpBuilder &odsBuilder,
-                                         llvm::CallInst *callInst) {
-  llvm::Function *callee = callInst->getCalledFunction();
+                                         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 an operands array used by the conversion.
+  SmallVector<llvm::Value *> llvmOperands(inst->args());
 #include "mlir/Dialect/LLVMIR/LLVMIntrinsicFromLLVMIRConversions.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
return bEntry.create<AddressOfOp>(UnknownLoc::get(context),
                                       processGlobal(gv));
 
   if (auto *ce = dyn_cast<llvm::ConstantExpr>(c)) {
     llvm::Instruction *i = ce->getAsInstruction();
     OpBuilder::InsertionGuard guard(b);
     b.setInsertionPoint(currentEntryBlock, currentEntryBlock->begin());
     if (failed(processInstruction(i)))
       return nullptr;
-    assert(instMap.count(i));
+    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 = instMap[i];
-    instMap.erase(i);
+    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)) {
     Type type = convertType(ue->getType());
     return bEntry.create<UndefOp>(UnknownLoc::get(context), type);
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) {
-  auto it = instMap.find(value);
-  if (it != instMap.end())
+  auto it = valueMapping.find(value);
+  if (it != valueMapping.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 = convertType(value->getType());
     unknownInstMap[value] =
         b.create(UnknownLoc::get(context), b.getStringAttr("llvm.unknown"),
for (auto inst = target->begin(); isa<llvm::PHINode>(inst); ++inst) {
     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.
+
+  // Convert all intrinsics that provide an MLIR builder.
+  if (auto callInst = dyn_cast<llvm::CallInst>(inst))
+    if (succeeded(convertIntrinsic(b, callInst)))
+      return success();
+
   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:
   case llvm::Instruction::FSub:
   case llvm::Instruction::Mul:
case llvm::Instruction::Unreachable: {
     SmallVector<Value> ops = processValues(operands);
     if (!inst->getType()->isVoidTy()) {
       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);
+      mapValue(inst, op->getResult(0));
     return success();
   }
   case llvm::Instruction::Alloca: {
     Value size = processValue(inst->getOperand(0));
     auto *allocaInst = cast<llvm::AllocaInst>(inst);
-    instMap[inst] =
-        b.create<AllocaOp>(loc, convertType(inst->getType()),
-                           convertType(allocaInst->getAllocatedType()), size,
-                           allocaInst->getAlign().value());
+    Value res = b.create<AllocaOp>(loc, convertType(inst->getType()),
+                                   convertType(allocaInst->getAllocatedType()),
+                                   size, allocaInst->getAlign().value());
+    mapValue(inst, res);
     return success();
   }
   case llvm::Instruction::ICmp: {
     Value lhs = processValue(inst->getOperand(0));
     Value rhs = processValue(inst->getOperand(1));
-    instMap[inst] = b.create<ICmpOp>(
+    Value res = b.create<ICmpOp>(
         loc, getICmpPredicate(cast<llvm::ICmpInst>(inst)->getPredicate()), lhs,
         rhs);
+    mapValue(inst, res);
     return success();
   }
   case llvm::Instruction::FCmp: {
     Value lhs = processValue(inst->getOperand(0));
     Value rhs = processValue(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>(
+    Value res = b.create<FCmpOp>(
         loc, resType,
         getFCmpPredicate(cast<llvm::FCmpInst>(inst)->getPredicate()), lhs, rhs);
+    mapValue(inst, res);
     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());
case llvm::Instruction::Switch: {
     }
 
     b.create<SwitchOp>(loc, condition, blocks[defaultBB], defaultBlockArgs,
                        caseValues, caseBlocks, caseOperandRefs);
     return success();
   }
   case llvm::Instruction::PHI: {
     Type type = convertType(inst->getType());
-    instMap[inst] = b.getInsertionBlock()->addArgument(
-        type, translateLoc(inst->getDebugLoc()));
+    mapValue(inst, b.getInsertionBlock()->addArgument(
+                       type, translateLoc(inst->getDebugLoc())));
     return success();
   }
   case llvm::Instruction::Call: {
     llvm::CallInst *ci = cast<llvm::CallInst>(inst);
-
-    // For all intrinsics, try to generate to the corresponding op.
-    if (succeeded(convertIntrinsic(b, ci)))
-      return success();
-
     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);
     } else {
       Value calledValue = processValue(ci->getCalledOperand());
       ops.insert(ops.begin(), calledValue);
       op = b.create<CallOp>(loc, tys, ops);
     }
     if (!ci->getType()->isVoidTy())
-      instMap[inst] = op->getResult(0);
+      mapValue(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 = convertType(lpi->getType());
-    instMap[inst] = b.create<LandingpadOp>(loc, ty, lpi->isCleanup(), ops);
+    Value res = b.create<LandingpadOp>(loc, ty, lpi->isCleanup(), ops);
+    mapValue(inst, res);
     return success();
   }
   case llvm::Instruction::Invoke: {
     llvm::InvokeInst *ii = cast<llvm::InvokeInst>(inst);
 
     SmallVector<Type, 2> tys;
     if (!ii->getType()->isVoidTy())
       tys.push_back(convertType(inst->getType()));
case llvm::Instruction::Invoke: {
     } else {
       ops.insert(ops.begin(), processValue(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);
+      mapValue(inst, op->getResult(0));
     return success();
   }
   case llvm::Instruction::Fence: {
     StringRef syncscope;
     SmallVector<StringRef, 4> ssNs;
     llvm::LLVMContext &llvmContext = inst->getContext();
     llvm::FenceInst *fence = cast<llvm::FenceInst>(inst);
     llvmContext.getSyncScopeNames(ssNs);
case llvm::Instruction::AtomicRMW: {
     Value ptr = processValue(atomicInst->getPointerOperand());
     Value val = processValue(atomicInst->getValOperand());
 
     LLVM::AtomicBinOp binOp = getLLVMAtomicBinOp(atomicInst->getOperation());
     LLVM::AtomicOrdering ordering =
         getLLVMAtomicOrdering(atomicInst->getOrdering());
 
     Type type = convertType(inst->getType());
-    instMap[inst] = b.create<AtomicRMWOp>(loc, type, binOp, ptr, val, ordering);
+    Value res = b.create<AtomicRMWOp>(loc, type, binOp, ptr, val, ordering);
+    mapValue(inst, res);
     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());
 
     LLVM::AtomicOrdering ordering =
         getLLVMAtomicOrdering(cmpXchgInst->getSuccessOrdering());
     LLVM::AtomicOrdering failOrdering =
         getLLVMAtomicOrdering(cmpXchgInst->getFailureOrdering());
 
     Type type = convertType(inst->getType());
-    instMap[inst] = b.create<AtomicCmpXchgOp>(loc, type, ptr, cmpVal, newVal,
-                                              ordering, failOrdering);
+    Value res = b.create<AtomicCmpXchgOp>(loc, type, ptr, cmpVal, newVal,
+    mapValue(inst, res);
     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 = 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());
-    instMap[inst] =
-        b.create<GEPOp>(loc, type, sourceElementType, basePtr, indices);
+    Value res = b.create<GEPOp>(loc, type, sourceElementType, basePtr, indices);
+    mapValue(inst, res);
     return success();
   }
   case llvm::Instruction::InsertValue: {
     auto *ivInst = cast<llvm::InsertValueInst>(inst);
     Value inserted = processValue(ivInst->getInsertedValueOperand());
     Value aggOperand = processValue(ivInst->getAggregateOperand());
 
     SmallVector<int64_t> indices;
     llvm::append_range(indices, ivInst->getIndices());
-    instMap[inst] = b.create<InsertValueOp>(loc, aggOperand, inserted, indices);
+    Value res = b.create<InsertValueOp>(loc, aggOperand, inserted, indices);
+    mapValue(inst, res);
     return success();
   }
   case llvm::Instruction::ExtractValue: {
     auto *evInst = cast<llvm::ExtractValueInst>(inst);
     Value aggOperand = processValue(evInst->getAggregateOperand());
 
     SmallVector<int64_t> indices;
     llvm::append_range(indices, evInst->getIndices());
-    instMap[inst] = b.create<ExtractValueOp>(loc, aggOperand, indices);
+    Value res = b.create<ExtractValueOp>(loc, aggOperand, indices);
+    mapValue(inst, res);
     return success();
   }
   case llvm::Instruction::ShuffleVector: {
     auto *svInst = cast<llvm::ShuffleVectorInst>(inst);
     Value vec1 = processValue(svInst->getOperand(0));
     Value vec2 = processValue(svInst->getOperand(1));
 
     SmallVector<int32_t> mask(svInst->getShuffleMask());
-    instMap[inst] = b.create<ShuffleVectorOp>(loc, vec1, vec2, mask);
+    Value res = b.create<ShuffleVectorOp>(loc, vec1, vec2, mask);
+    mapValue(inst, res);
     return success();
   }
   }
 }
 
 FlatSymbolRefAttr Importer::getPersonalityAsAttr(llvm::Function *f) {
   if (!f->hasPersonalityFn())
     return nullptr;
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) {
   blocks.clear();
-  instMap.clear();
+  valueMapping.clear();
   unknownInstMap.clear();
 
   auto functionType =
       convertType(f->getFunctionType()).dyn_cast<LLVMFunctionType>();
   if (f->isIntrinsic() && isConvertibleIntrinsic(f->getIntrinsicID()))
     return success();
 
   bool dsoLocal = f->hasLocalLinkage();
LogicalResult Importer::processFunction(llvm::Function *f) {
   for (llvm::BasicBlock &bb : *f) {
     blockList.push_back(b.createBlock(&fop.getBody(), fop.getBody().end()));
     blocks[&bb] = blockList.back();
   }
   currentEntryBlock = blockList[0];
 
   // Add function arguments to the entry block.
   for (const auto &kv : llvm::enumerate(f->args())) {
-    instMap[&kv.value()] = blockList[0]->addArgument(
-        functionType.getParamType(kv.index()), fop.getLoc());
+    mapValue(&kv.value(),
+             blockList[0]->addArgument(functionType.getParamType(kv.index()),
+                                       fop.getLoc()));
   }
 
   for (auto bbs : llvm::zip(*f, blockList)) {
     if (failed(processBasicBlock(&std::get<0>(bbs), std::get<1>(bbs))))
       return failure();
   }
 
   // Now that all instructions are guaranteed to have been visited, ensure
   // any unknown uses we encountered are remapped.
   for (auto &llvmAndUnknown : unknownInstMap) {
-    assert(instMap.count(llvmAndUnknown.first));
-    Value newValue = instMap[llvmAndUnknown.first];
+    assert(valueMapping.count(llvmAndUnknown.first));
+    Value newValue = valueMapping[llvmAndUnknown.first];
     Value oldValue = llvmAndUnknown.second->getResult(0);
     oldValue.replaceAllUsesWith(newValue);
     llvmAndUnknown.second->erase();
   }
   return success();
 }
 
 LogicalResult Importer::processBasicBlock(llvm::BasicBlock *bb, Block *block) {

mlir/tools/mlir-tblgen/LLVMIRConversionGen.cpp

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)) {
       // Process the argument value assuming the MLIR and LLVM operand orders
       // match and there are no optional or variadic arguments.
-      bs << formatv("processValue(callInst->getArgOperand({0}))", *argIndex);
+      bs << formatv("processValue(llvmOperands[{0}])", *argIndex);
+    } else if (isResultName(op, name)) {
+      assert(op.getNumResults() == 1 &&
+             "expected operation to have one result");
+      bs << formatv("mapValue(inst)");
     } else if (name == "_int_attr") {
       bs << "matchIntegerAttr";
     } else if (name == "_resultType") {
-      bs << "convertType(callInst->getType())";
+      bs << "convertType(inst->getType())";
     } else if (name == "_location") {
-      bs << "translateLoc(callInst->getDebugLoc())";
+      bs << "translateLoc(inst->getDebugLoc())";
     } else if (name == "_builder") {
       bs << "odsBuilder";
     } else if (name == "_qualCppClassName") {
       bs << op.getQualCppClassName();
     } else if (name == "$") {
       bs << '$';
     } else {
       return emitError(name +
-                       " is neither a known keyword nor an argument of " +
+                       " is not a known keyword, argument, or result of " +
                        op.getOperationName());
     }
     // Finally, only keep the untraversed part of the string.
     builderStrRef = builderStrRef.substr(loc.pos + loc.length);
   }
 
   // Output the check and the builder string.
   os << "if (intrinsicID == llvm::Intrinsic::"