1 //===- ModuleTranslation.cpp - MLIR to LLVM conversion --------------------===//
2 //
3 // Part of the MLIR Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the translation between an MLIR LLVM dialect module and
10 // the corresponding LLVMIR module. It only handles core LLVM IR operations.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "mlir/Target/LLVMIR/ModuleTranslation.h"
15 
16 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
17 #include "mlir/IR/Attributes.h"
18 #include "mlir/IR/Module.h"
19 #include "mlir/IR/StandardTypes.h"
20 #include "mlir/Support/LLVM.h"
21 
22 #include "llvm/ADT/SetVector.h"
23 #include "llvm/IR/BasicBlock.h"
24 #include "llvm/IR/Constants.h"
25 #include "llvm/IR/DerivedTypes.h"
26 #include "llvm/IR/IRBuilder.h"
27 #include "llvm/IR/LLVMContext.h"
28 #include "llvm/IR/Module.h"
29 #include "llvm/Transforms/Utils/Cloning.h"
30 
31 using namespace mlir;
32 using namespace mlir::LLVM;
33 
34 /// Builds a constant of a sequential LLVM type `type`, potentially containing
35 /// other sequential types recursively, from the individual constant values
36 /// provided in `constants`. `shape` contains the number of elements in nested
37 /// sequential types. Reports errors at `loc` and returns nullptr on error.
38 static llvm::Constant *
39 buildSequentialConstant(ArrayRef<llvm::Constant *> &constants,
40                         ArrayRef<int64_t> shape, llvm::Type *type,
41                         Location loc) {
42   if (shape.empty()) {
43     llvm::Constant *result = constants.front();
44     constants = constants.drop_front();
45     return result;
46   }
47 
48   if (!isa<llvm::SequentialType>(type)) {
49     emitError(loc) << "expected sequential LLVM types wrapping a scalar";
50     return nullptr;
51   }
52 
53   llvm::Type *elementType = type->getSequentialElementType();
54   SmallVector<llvm::Constant *, 8> nested;
55   nested.reserve(shape.front());
56   for (int64_t i = 0; i < shape.front(); ++i) {
57     nested.push_back(buildSequentialConstant(constants, shape.drop_front(),
58                                              elementType, loc));
59     if (!nested.back())
60       return nullptr;
61   }
62 
63   if (shape.size() == 1 && type->isVectorTy())
64     return llvm::ConstantVector::get(nested);
65   return llvm::ConstantArray::get(
66       llvm::ArrayType::get(elementType, shape.front()), nested);
67 }
68 
69 /// Returns the first non-sequential type nested in sequential types.
70 static llvm::Type *getInnermostElementType(llvm::Type *type) {
71   while (isa<llvm::SequentialType>(type))
72     type = type->getSequentialElementType();
73   return type;
74 }
75 
76 /// Create an LLVM IR constant of `llvmType` from the MLIR attribute `attr`.
77 /// This currently supports integer, floating point, splat and dense element
78 /// attributes and combinations thereof.  In case of error, report it to `loc`
79 /// and return nullptr.
80 llvm::Constant *ModuleTranslation::getLLVMConstant(llvm::Type *llvmType,
81                                                    Attribute attr,
82                                                    Location loc) {
83   if (!attr)
84     return llvm::UndefValue::get(llvmType);
85   if (llvmType->isStructTy()) {
86     emitError(loc, "struct types are not supported in constants");
87     return nullptr;
88   }
89   if (auto intAttr = attr.dyn_cast<IntegerAttr>())
90     return llvm::ConstantInt::get(llvmType, intAttr.getValue());
91   if (auto floatAttr = attr.dyn_cast<FloatAttr>())
92     return llvm::ConstantFP::get(llvmType, floatAttr.getValue());
93   if (auto funcAttr = attr.dyn_cast<FlatSymbolRefAttr>())
94     return functionMapping.lookup(funcAttr.getValue());
95   if (auto splatAttr = attr.dyn_cast<SplatElementsAttr>()) {
96     auto *sequentialType = cast<llvm::SequentialType>(llvmType);
97     auto elementType = sequentialType->getElementType();
98     uint64_t numElements = sequentialType->getNumElements();
99     // Splat value is a scalar. Extract it only if the element type is not
100     // another sequence type. The recursion terminates because each step removes
101     // one outer sequential type.
102     llvm::Constant *child = getLLVMConstant(
103         elementType,
104         isa<llvm::SequentialType>(elementType) ? splatAttr
105                                                : splatAttr.getSplatValue(),
106         loc);
107     if (!child)
108       return nullptr;
109     if (llvmType->isVectorTy())
110       return llvm::ConstantVector::getSplat(numElements, child);
111     if (llvmType->isArrayTy()) {
112       auto arrayType = llvm::ArrayType::get(elementType, numElements);
113       SmallVector<llvm::Constant *, 8> constants(numElements, child);
114       return llvm::ConstantArray::get(arrayType, constants);
115     }
116   }
117 
118   if (auto elementsAttr = attr.dyn_cast<ElementsAttr>()) {
119     assert(elementsAttr.getType().hasStaticShape());
120     assert(elementsAttr.getNumElements() != 0 &&
121            "unexpected empty elements attribute");
122     assert(!elementsAttr.getType().getShape().empty() &&
123            "unexpected empty elements attribute shape");
124 
125     SmallVector<llvm::Constant *, 8> constants;
126     constants.reserve(elementsAttr.getNumElements());
127     llvm::Type *innermostType = getInnermostElementType(llvmType);
128     for (auto n : elementsAttr.getValues<Attribute>()) {
129       constants.push_back(getLLVMConstant(innermostType, n, loc));
130       if (!constants.back())
131         return nullptr;
132     }
133     ArrayRef<llvm::Constant *> constantsRef = constants;
134     llvm::Constant *result = buildSequentialConstant(
135         constantsRef, elementsAttr.getType().getShape(), llvmType, loc);
136     assert(constantsRef.empty() && "did not consume all elemental constants");
137     return result;
138   }
139 
140   if (auto stringAttr = attr.dyn_cast<StringAttr>()) {
141     return llvm::ConstantDataArray::get(
142         llvmModule->getContext(), ArrayRef<char>{stringAttr.getValue().data(),
143                                                  stringAttr.getValue().size()});
144   }
145   emitError(loc, "unsupported constant value");
146   return nullptr;
147 }
148 
149 /// Convert MLIR integer comparison predicate to LLVM IR comparison predicate.
150 static llvm::CmpInst::Predicate getLLVMCmpPredicate(ICmpPredicate p) {
151   switch (p) {
152   case LLVM::ICmpPredicate::eq:
153     return llvm::CmpInst::Predicate::ICMP_EQ;
154   case LLVM::ICmpPredicate::ne:
155     return llvm::CmpInst::Predicate::ICMP_NE;
156   case LLVM::ICmpPredicate::slt:
157     return llvm::CmpInst::Predicate::ICMP_SLT;
158   case LLVM::ICmpPredicate::sle:
159     return llvm::CmpInst::Predicate::ICMP_SLE;
160   case LLVM::ICmpPredicate::sgt:
161     return llvm::CmpInst::Predicate::ICMP_SGT;
162   case LLVM::ICmpPredicate::sge:
163     return llvm::CmpInst::Predicate::ICMP_SGE;
164   case LLVM::ICmpPredicate::ult:
165     return llvm::CmpInst::Predicate::ICMP_ULT;
166   case LLVM::ICmpPredicate::ule:
167     return llvm::CmpInst::Predicate::ICMP_ULE;
168   case LLVM::ICmpPredicate::ugt:
169     return llvm::CmpInst::Predicate::ICMP_UGT;
170   case LLVM::ICmpPredicate::uge:
171     return llvm::CmpInst::Predicate::ICMP_UGE;
172   }
173   llvm_unreachable("incorrect comparison predicate");
174 }
175 
176 static llvm::CmpInst::Predicate getLLVMCmpPredicate(FCmpPredicate p) {
177   switch (p) {
178   case LLVM::FCmpPredicate::_false:
179     return llvm::CmpInst::Predicate::FCMP_FALSE;
180   case LLVM::FCmpPredicate::oeq:
181     return llvm::CmpInst::Predicate::FCMP_OEQ;
182   case LLVM::FCmpPredicate::ogt:
183     return llvm::CmpInst::Predicate::FCMP_OGT;
184   case LLVM::FCmpPredicate::oge:
185     return llvm::CmpInst::Predicate::FCMP_OGE;
186   case LLVM::FCmpPredicate::olt:
187     return llvm::CmpInst::Predicate::FCMP_OLT;
188   case LLVM::FCmpPredicate::ole:
189     return llvm::CmpInst::Predicate::FCMP_OLE;
190   case LLVM::FCmpPredicate::one:
191     return llvm::CmpInst::Predicate::FCMP_ONE;
192   case LLVM::FCmpPredicate::ord:
193     return llvm::CmpInst::Predicate::FCMP_ORD;
194   case LLVM::FCmpPredicate::ueq:
195     return llvm::CmpInst::Predicate::FCMP_UEQ;
196   case LLVM::FCmpPredicate::ugt:
197     return llvm::CmpInst::Predicate::FCMP_UGT;
198   case LLVM::FCmpPredicate::uge:
199     return llvm::CmpInst::Predicate::FCMP_UGE;
200   case LLVM::FCmpPredicate::ult:
201     return llvm::CmpInst::Predicate::FCMP_ULT;
202   case LLVM::FCmpPredicate::ule:
203     return llvm::CmpInst::Predicate::FCMP_ULE;
204   case LLVM::FCmpPredicate::une:
205     return llvm::CmpInst::Predicate::FCMP_UNE;
206   case LLVM::FCmpPredicate::uno:
207     return llvm::CmpInst::Predicate::FCMP_UNO;
208   case LLVM::FCmpPredicate::_true:
209     return llvm::CmpInst::Predicate::FCMP_TRUE;
210   }
211   llvm_unreachable("incorrect comparison predicate");
212 }
213 
214 static llvm::AtomicRMWInst::BinOp getLLVMAtomicBinOp(AtomicBinOp op) {
215   switch (op) {
216   case LLVM::AtomicBinOp::xchg:
217     return llvm::AtomicRMWInst::BinOp::Xchg;
218   case LLVM::AtomicBinOp::add:
219     return llvm::AtomicRMWInst::BinOp::Add;
220   case LLVM::AtomicBinOp::sub:
221     return llvm::AtomicRMWInst::BinOp::Sub;
222   case LLVM::AtomicBinOp::_and:
223     return llvm::AtomicRMWInst::BinOp::And;
224   case LLVM::AtomicBinOp::nand:
225     return llvm::AtomicRMWInst::BinOp::Nand;
226   case LLVM::AtomicBinOp::_or:
227     return llvm::AtomicRMWInst::BinOp::Or;
228   case LLVM::AtomicBinOp::_xor:
229     return llvm::AtomicRMWInst::BinOp::Xor;
230   case LLVM::AtomicBinOp::max:
231     return llvm::AtomicRMWInst::BinOp::Max;
232   case LLVM::AtomicBinOp::min:
233     return llvm::AtomicRMWInst::BinOp::Min;
234   case LLVM::AtomicBinOp::umax:
235     return llvm::AtomicRMWInst::BinOp::UMax;
236   case LLVM::AtomicBinOp::umin:
237     return llvm::AtomicRMWInst::BinOp::UMin;
238   case LLVM::AtomicBinOp::fadd:
239     return llvm::AtomicRMWInst::BinOp::FAdd;
240   case LLVM::AtomicBinOp::fsub:
241     return llvm::AtomicRMWInst::BinOp::FSub;
242   }
243   llvm_unreachable("incorrect atomic binary operator");
244 }
245 
246 static llvm::AtomicOrdering getLLVMAtomicOrdering(AtomicOrdering ordering) {
247   switch (ordering) {
248   case LLVM::AtomicOrdering::not_atomic:
249     return llvm::AtomicOrdering::NotAtomic;
250   case LLVM::AtomicOrdering::unordered:
251     return llvm::AtomicOrdering::Unordered;
252   case LLVM::AtomicOrdering::monotonic:
253     return llvm::AtomicOrdering::Monotonic;
254   case LLVM::AtomicOrdering::acquire:
255     return llvm::AtomicOrdering::Acquire;
256   case LLVM::AtomicOrdering::release:
257     return llvm::AtomicOrdering::Release;
258   case LLVM::AtomicOrdering::acq_rel:
259     return llvm::AtomicOrdering::AcquireRelease;
260   case LLVM::AtomicOrdering::seq_cst:
261     return llvm::AtomicOrdering::SequentiallyConsistent;
262   }
263   llvm_unreachable("incorrect atomic ordering");
264 }
265 
266 /// Given a single MLIR operation, create the corresponding LLVM IR operation
267 /// using the `builder`.  LLVM IR Builder does not have a generic interface so
268 /// this has to be a long chain of `if`s calling different functions with a
269 /// different number of arguments.
270 LogicalResult ModuleTranslation::convertOperation(Operation &opInst,
271                                                   llvm::IRBuilder<> &builder) {
272   auto extractPosition = [](ArrayAttr attr) {
273     SmallVector<unsigned, 4> position;
274     position.reserve(attr.size());
275     for (Attribute v : attr)
276       position.push_back(v.cast<IntegerAttr>().getValue().getZExtValue());
277     return position;
278   };
279 
280 #include "mlir/Dialect/LLVMIR/LLVMConversions.inc"
281 
282   // Emit function calls.  If the "callee" attribute is present, this is a
283   // direct function call and we also need to look up the remapped function
284   // itself.  Otherwise, this is an indirect call and the callee is the first
285   // operand, look it up as a normal value.  Return the llvm::Value representing
286   // the function result, which may be of llvm::VoidTy type.
287   auto convertCall = [this, &builder](Operation &op) -> llvm::Value * {
288     auto operands = lookupValues(op.getOperands());
289     ArrayRef<llvm::Value *> operandsRef(operands);
290     if (auto attr = op.getAttrOfType<FlatSymbolRefAttr>("callee")) {
291       return builder.CreateCall(functionMapping.lookup(attr.getValue()),
292                                 operandsRef);
293     } else {
294       return builder.CreateCall(operandsRef.front(), operandsRef.drop_front());
295     }
296   };
297 
298   // Emit calls.  If the called function has a result, remap the corresponding
299   // value.  Note that LLVM IR dialect CallOp has either 0 or 1 result.
300   if (isa<LLVM::CallOp>(opInst)) {
301     llvm::Value *result = convertCall(opInst);
302     if (opInst.getNumResults() != 0) {
303       valueMapping[opInst.getResult(0)] = result;
304       return success();
305     }
306     // Check that LLVM call returns void for 0-result functions.
307     return success(result->getType()->isVoidTy());
308   }
309 
310   // Emit branches.  We need to look up the remapped blocks and ignore the block
311   // arguments that were transformed into PHI nodes.
312   if (auto brOp = dyn_cast<LLVM::BrOp>(opInst)) {
313     builder.CreateBr(blockMapping[brOp.getSuccessor(0)]);
314     return success();
315   }
316   if (auto condbrOp = dyn_cast<LLVM::CondBrOp>(opInst)) {
317     builder.CreateCondBr(valueMapping.lookup(condbrOp.getOperand(0)),
318                          blockMapping[condbrOp.getSuccessor(0)],
319                          blockMapping[condbrOp.getSuccessor(1)]);
320     return success();
321   }
322 
323   // Emit addressof.  We need to look up the global value referenced by the
324   // operation and store it in the MLIR-to-LLVM value mapping.  This does not
325   // emit any LLVM instruction.
326   if (auto addressOfOp = dyn_cast<LLVM::AddressOfOp>(opInst)) {
327     LLVM::GlobalOp global = addressOfOp.getGlobal();
328     // The verifier should not have allowed this.
329     assert(global && "referencing an undefined global");
330 
331     valueMapping[addressOfOp.getResult()] = globalsMapping.lookup(global);
332     return success();
333   }
334 
335   return opInst.emitError("unsupported or non-LLVM operation: ")
336          << opInst.getName();
337 }
338 
339 /// Convert block to LLVM IR.  Unless `ignoreArguments` is set, emit PHI nodes
340 /// to define values corresponding to the MLIR block arguments.  These nodes
341 /// are not connected to the source basic blocks, which may not exist yet.
342 LogicalResult ModuleTranslation::convertBlock(Block &bb, bool ignoreArguments) {
343   llvm::IRBuilder<> builder(blockMapping[&bb]);
344 
345   // Before traversing operations, make block arguments available through
346   // value remapping and PHI nodes, but do not add incoming edges for the PHI
347   // nodes just yet: those values may be defined by this or following blocks.
348   // This step is omitted if "ignoreArguments" is set.  The arguments of the
349   // first block have been already made available through the remapping of
350   // LLVM function arguments.
351   if (!ignoreArguments) {
352     auto predecessors = bb.getPredecessors();
353     unsigned numPredecessors =
354         std::distance(predecessors.begin(), predecessors.end());
355     for (auto arg : bb.getArguments()) {
356       auto wrappedType = arg.getType().dyn_cast<LLVM::LLVMType>();
357       if (!wrappedType)
358         return emitError(bb.front().getLoc(),
359                          "block argument does not have an LLVM type");
360       llvm::Type *type = wrappedType.getUnderlyingType();
361       llvm::PHINode *phi = builder.CreatePHI(type, numPredecessors);
362       valueMapping[arg] = phi;
363     }
364   }
365 
366   // Traverse operations.
367   for (auto &op : bb) {
368     if (failed(convertOperation(op, builder)))
369       return failure();
370   }
371 
372   return success();
373 }
374 
375 /// Convert the LLVM dialect linkage type to LLVM IR linkage type.
376 llvm::GlobalVariable::LinkageTypes convertLinkageType(LLVM::Linkage linkage) {
377   switch (linkage) {
378   case LLVM::Linkage::Private:
379     return llvm::GlobalValue::PrivateLinkage;
380   case LLVM::Linkage::Internal:
381     return llvm::GlobalValue::InternalLinkage;
382   case LLVM::Linkage::AvailableExternally:
383     return llvm::GlobalValue::AvailableExternallyLinkage;
384   case LLVM::Linkage::Linkonce:
385     return llvm::GlobalValue::LinkOnceAnyLinkage;
386   case LLVM::Linkage::Weak:
387     return llvm::GlobalValue::WeakAnyLinkage;
388   case LLVM::Linkage::Common:
389     return llvm::GlobalValue::CommonLinkage;
390   case LLVM::Linkage::Appending:
391     return llvm::GlobalValue::AppendingLinkage;
392   case LLVM::Linkage::ExternWeak:
393     return llvm::GlobalValue::ExternalWeakLinkage;
394   case LLVM::Linkage::LinkonceODR:
395     return llvm::GlobalValue::LinkOnceODRLinkage;
396   case LLVM::Linkage::WeakODR:
397     return llvm::GlobalValue::WeakODRLinkage;
398   case LLVM::Linkage::External:
399     return llvm::GlobalValue::ExternalLinkage;
400   }
401   llvm_unreachable("unknown linkage type");
402 }
403 
404 /// Create named global variables that correspond to llvm.mlir.global
405 /// definitions.
406 void ModuleTranslation::convertGlobals() {
407   for (auto op : getModuleBody(mlirModule).getOps<LLVM::GlobalOp>()) {
408     llvm::Type *type = op.getType().getUnderlyingType();
409     llvm::Constant *cst = llvm::UndefValue::get(type);
410     if (op.getValueOrNull()) {
411       // String attributes are treated separately because they cannot appear as
412       // in-function constants and are thus not supported by getLLVMConstant.
413       if (auto strAttr = op.getValueOrNull().dyn_cast_or_null<StringAttr>()) {
414         cst = llvm::ConstantDataArray::getString(
415             llvmModule->getContext(), strAttr.getValue(), /*AddNull=*/false);
416         type = cst->getType();
417       } else {
418         cst = getLLVMConstant(type, op.getValueOrNull(), op.getLoc());
419       }
420     } else if (Block *initializer = op.getInitializerBlock()) {
421       llvm::IRBuilder<> builder(llvmModule->getContext());
422       for (auto &op : initializer->without_terminator()) {
423         if (failed(convertOperation(op, builder)) ||
424             !isa<llvm::Constant>(valueMapping.lookup(op.getResult(0)))) {
425           emitError(op.getLoc(), "unemittable constant value");
426           return;
427         }
428       }
429       ReturnOp ret = cast<ReturnOp>(initializer->getTerminator());
430       cst = cast<llvm::Constant>(valueMapping.lookup(ret.getOperand(0)));
431     }
432 
433     auto linkage = convertLinkageType(op.linkage());
434     bool anyExternalLinkage =
435         (linkage == llvm::GlobalVariable::ExternalLinkage ||
436          linkage == llvm::GlobalVariable::ExternalWeakLinkage);
437     auto addrSpace = op.addr_space().getLimitedValue();
438     auto *var = new llvm::GlobalVariable(
439         *llvmModule, type, op.constant(), linkage,
440         anyExternalLinkage ? nullptr : cst, op.sym_name(),
441         /*InsertBefore=*/nullptr, llvm::GlobalValue::NotThreadLocal, addrSpace);
442 
443     globalsMapping.try_emplace(op, var);
444   }
445 }
446 
447 /// Get the SSA value passed to the current block from the terminator operation
448 /// of its predecessor.
449 static Value getPHISourceValue(Block *current, Block *pred,
450                                unsigned numArguments, unsigned index) {
451   auto &terminator = *pred->getTerminator();
452   if (isa<LLVM::BrOp>(terminator)) {
453     return terminator.getOperand(index);
454   }
455 
456   // For conditional branches, we need to check if the current block is reached
457   // through the "true" or the "false" branch and take the relevant operands.
458   auto condBranchOp = dyn_cast<LLVM::CondBrOp>(terminator);
459   assert(condBranchOp &&
460          "only branch operations can be terminators of a block that "
461          "has successors");
462   assert((condBranchOp.getSuccessor(0) != condBranchOp.getSuccessor(1)) &&
463          "successors with arguments in LLVM conditional branches must be "
464          "different blocks");
465 
466   return condBranchOp.getSuccessor(0) == current
467              ? terminator.getSuccessorOperand(0, index)
468              : terminator.getSuccessorOperand(1, index);
469 }
470 
471 void ModuleTranslation::connectPHINodes(LLVMFuncOp func) {
472   // Skip the first block, it cannot be branched to and its arguments correspond
473   // to the arguments of the LLVM function.
474   for (auto it = std::next(func.begin()), eit = func.end(); it != eit; ++it) {
475     Block *bb = &*it;
476     llvm::BasicBlock *llvmBB = blockMapping.lookup(bb);
477     auto phis = llvmBB->phis();
478     auto numArguments = bb->getNumArguments();
479     assert(numArguments == std::distance(phis.begin(), phis.end()));
480     for (auto &numberedPhiNode : llvm::enumerate(phis)) {
481       auto &phiNode = numberedPhiNode.value();
482       unsigned index = numberedPhiNode.index();
483       for (auto *pred : bb->getPredecessors()) {
484         phiNode.addIncoming(valueMapping.lookup(getPHISourceValue(
485                                 bb, pred, numArguments, index)),
486                             blockMapping.lookup(pred));
487       }
488     }
489   }
490 }
491 
492 // TODO(mlir-team): implement an iterative version
493 static void topologicalSortImpl(llvm::SetVector<Block *> &blocks, Block *b) {
494   blocks.insert(b);
495   for (Block *bb : b->getSuccessors()) {
496     if (blocks.count(bb) == 0)
497       topologicalSortImpl(blocks, bb);
498   }
499 }
500 
501 /// Sort function blocks topologically.
502 static llvm::SetVector<Block *> topologicalSort(LLVMFuncOp f) {
503   // For each blocks that has not been visited yet (i.e. that has no
504   // predecessors), add it to the list and traverse its successors in DFS
505   // preorder.
506   llvm::SetVector<Block *> blocks;
507   for (Block &b : f.getBlocks()) {
508     if (blocks.count(&b) == 0)
509       topologicalSortImpl(blocks, &b);
510   }
511   assert(blocks.size() == f.getBlocks().size() && "some blocks are not sorted");
512 
513   return blocks;
514 }
515 
516 LogicalResult ModuleTranslation::convertOneFunction(LLVMFuncOp func) {
517   // Clear the block and value mappings, they are only relevant within one
518   // function.
519   blockMapping.clear();
520   valueMapping.clear();
521   llvm::Function *llvmFunc = functionMapping.lookup(func.getName());
522   // Add function arguments to the value remapping table.
523   // If there was noalias info then we decorate each argument accordingly.
524   unsigned int argIdx = 0;
525   for (auto kvp : llvm::zip(func.getArguments(), llvmFunc->args())) {
526     llvm::Argument &llvmArg = std::get<1>(kvp);
527     BlockArgument mlirArg = std::get<0>(kvp);
528 
529     if (auto attr = func.getArgAttrOfType<BoolAttr>(argIdx, "llvm.noalias")) {
530       // NB: Attribute already verified to be boolean, so check if we can indeed
531       // attach the attribute to this argument, based on its type.
532       auto argTy = mlirArg.getType().dyn_cast<LLVM::LLVMType>();
533       if (!argTy.getUnderlyingType()->isPointerTy())
534         return func.emitError(
535             "llvm.noalias attribute attached to LLVM non-pointer argument");
536       if (attr.getValue())
537         llvmArg.addAttr(llvm::Attribute::AttrKind::NoAlias);
538     }
539     valueMapping[mlirArg] = &llvmArg;
540     argIdx++;
541   }
542 
543   // First, create all blocks so we can jump to them.
544   llvm::LLVMContext &llvmContext = llvmFunc->getContext();
545   for (auto &bb : func) {
546     auto *llvmBB = llvm::BasicBlock::Create(llvmContext);
547     llvmBB->insertInto(llvmFunc);
548     blockMapping[&bb] = llvmBB;
549   }
550 
551   // Then, convert blocks one by one in topological order to ensure defs are
552   // converted before uses.
553   auto blocks = topologicalSort(func);
554   for (auto indexedBB : llvm::enumerate(blocks)) {
555     auto *bb = indexedBB.value();
556     if (failed(convertBlock(*bb, /*ignoreArguments=*/indexedBB.index() == 0)))
557       return failure();
558   }
559 
560   // Finally, after all blocks have been traversed and values mapped, connect
561   // the PHI nodes to the results of preceding blocks.
562   connectPHINodes(func);
563   return success();
564 }
565 
566 LogicalResult ModuleTranslation::checkSupportedModuleOps(Operation *m) {
567   for (Operation &o : getModuleBody(m).getOperations())
568     if (!isa<LLVM::LLVMFuncOp>(&o) && !isa<LLVM::GlobalOp>(&o) &&
569         !o.isKnownTerminator())
570       return o.emitOpError("unsupported module-level operation");
571   return success();
572 }
573 
574 LogicalResult ModuleTranslation::convertFunctions() {
575   // Declare all functions first because there may be function calls that form a
576   // call graph with cycles.
577   for (auto function : getModuleBody(mlirModule).getOps<LLVMFuncOp>()) {
578     llvm::FunctionCallee llvmFuncCst = llvmModule->getOrInsertFunction(
579         function.getName(),
580         cast<llvm::FunctionType>(function.getType().getUnderlyingType()));
581     assert(isa<llvm::Function>(llvmFuncCst.getCallee()));
582     functionMapping[function.getName()] =
583         cast<llvm::Function>(llvmFuncCst.getCallee());
584   }
585 
586   // Convert functions.
587   for (auto function : getModuleBody(mlirModule).getOps<LLVMFuncOp>()) {
588     // Ignore external functions.
589     if (function.isExternal())
590       continue;
591 
592     if (failed(convertOneFunction(function)))
593       return failure();
594   }
595 
596   return success();
597 }
598 
599 /// A helper to look up remapped operands in the value remapping table.`
600 SmallVector<llvm::Value *, 8>
601 ModuleTranslation::lookupValues(ValueRange values) {
602   SmallVector<llvm::Value *, 8> remapped;
603   remapped.reserve(values.size());
604   for (Value v : values)
605     remapped.push_back(valueMapping.lookup(v));
606   return remapped;
607 }
608 
609 std::unique_ptr<llvm::Module>
610 ModuleTranslation::prepareLLVMModule(Operation *m) {
611   auto *dialect = m->getContext()->getRegisteredDialect<LLVM::LLVMDialect>();
612   assert(dialect && "LLVM dialect must be registered");
613 
614   auto llvmModule = llvm::CloneModule(dialect->getLLVMModule());
615   if (!llvmModule)
616     return nullptr;
617 
618   llvm::LLVMContext &llvmContext = llvmModule->getContext();
619   llvm::IRBuilder<> builder(llvmContext);
620 
621   // Inject declarations for `malloc` and `free` functions that can be used in
622   // memref allocation/deallocation coming from standard ops lowering.
623   llvmModule->getOrInsertFunction("malloc", builder.getInt8PtrTy(),
624                                   builder.getInt64Ty());
625   llvmModule->getOrInsertFunction("free", builder.getVoidTy(),
626                                   builder.getInt8PtrTy());
627 
628   return llvmModule;
629 }
630