1 //===- ModuleTranslation.cpp - MLIR to LLVM conversion --------------------===//
2 //
3 // Part of the LLVM 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 "DebugTranslation.h"
17 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
18 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
19 #include "mlir/IR/Attributes.h"
20 #include "mlir/IR/BuiltinOps.h"
21 #include "mlir/IR/BuiltinTypes.h"
22 #include "mlir/IR/RegionGraphTraits.h"
23 #include "mlir/Support/LLVM.h"
24 #include "mlir/Target/LLVMIR/TypeTranslation.h"
25 #include "llvm/ADT/TypeSwitch.h"
26 
27 #include "llvm/ADT/PostOrderIterator.h"
28 #include "llvm/ADT/SetVector.h"
29 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
30 #include "llvm/IR/BasicBlock.h"
31 #include "llvm/IR/CFG.h"
32 #include "llvm/IR/Constants.h"
33 #include "llvm/IR/DerivedTypes.h"
34 #include "llvm/IR/IRBuilder.h"
35 #include "llvm/IR/InlineAsm.h"
36 #include "llvm/IR/LLVMContext.h"
37 #include "llvm/IR/MDBuilder.h"
38 #include "llvm/IR/Module.h"
39 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
40 #include "llvm/Transforms/Utils/Cloning.h"
41 
42 using namespace mlir;
43 using namespace mlir::LLVM;
44 using namespace mlir::LLVM::detail;
45 
46 #include "mlir/Dialect/LLVMIR/LLVMConversionEnumsToLLVM.inc"
47 
48 /// Builds a constant of a sequential LLVM type `type`, potentially containing
49 /// other sequential types recursively, from the individual constant values
50 /// provided in `constants`. `shape` contains the number of elements in nested
51 /// sequential types. Reports errors at `loc` and returns nullptr on error.
52 static llvm::Constant *
53 buildSequentialConstant(ArrayRef<llvm::Constant *> &constants,
54                         ArrayRef<int64_t> shape, llvm::Type *type,
55                         Location loc) {
56   if (shape.empty()) {
57     llvm::Constant *result = constants.front();
58     constants = constants.drop_front();
59     return result;
60   }
61 
62   llvm::Type *elementType;
63   if (auto *arrayTy = dyn_cast<llvm::ArrayType>(type)) {
64     elementType = arrayTy->getElementType();
65   } else if (auto *vectorTy = dyn_cast<llvm::VectorType>(type)) {
66     elementType = vectorTy->getElementType();
67   } else {
68     emitError(loc) << "expected sequential LLVM types wrapping a scalar";
69     return nullptr;
70   }
71 
72   SmallVector<llvm::Constant *, 8> nested;
73   nested.reserve(shape.front());
74   for (int64_t i = 0; i < shape.front(); ++i) {
75     nested.push_back(buildSequentialConstant(constants, shape.drop_front(),
76                                              elementType, loc));
77     if (!nested.back())
78       return nullptr;
79   }
80 
81   if (shape.size() == 1 && type->isVectorTy())
82     return llvm::ConstantVector::get(nested);
83   return llvm::ConstantArray::get(
84       llvm::ArrayType::get(elementType, shape.front()), nested);
85 }
86 
87 /// Returns the first non-sequential type nested in sequential types.
88 static llvm::Type *getInnermostElementType(llvm::Type *type) {
89   do {
90     if (auto *arrayTy = dyn_cast<llvm::ArrayType>(type)) {
91       type = arrayTy->getElementType();
92     } else if (auto *vectorTy = dyn_cast<llvm::VectorType>(type)) {
93       type = vectorTy->getElementType();
94     } else {
95       return type;
96     }
97   } while (1);
98 }
99 
100 /// Create an LLVM IR constant of `llvmType` from the MLIR attribute `attr`.
101 /// This currently supports integer, floating point, splat and dense element
102 /// attributes and combinations thereof.  In case of error, report it to `loc`
103 /// and return nullptr.
104 llvm::Constant *ModuleTranslation::getLLVMConstant(llvm::Type *llvmType,
105                                                    Attribute attr,
106                                                    Location loc) {
107   if (!attr)
108     return llvm::UndefValue::get(llvmType);
109   if (llvmType->isStructTy()) {
110     emitError(loc, "struct types are not supported in constants");
111     return nullptr;
112   }
113   // For integer types, we allow a mismatch in sizes as the index type in
114   // MLIR might have a different size than the index type in the LLVM module.
115   if (auto intAttr = attr.dyn_cast<IntegerAttr>())
116     return llvm::ConstantInt::get(
117         llvmType,
118         intAttr.getValue().sextOrTrunc(llvmType->getIntegerBitWidth()));
119   if (auto floatAttr = attr.dyn_cast<FloatAttr>())
120     return llvm::ConstantFP::get(llvmType, floatAttr.getValue());
121   if (auto funcAttr = attr.dyn_cast<FlatSymbolRefAttr>())
122     return llvm::ConstantExpr::getBitCast(
123         functionMapping.lookup(funcAttr.getValue()), llvmType);
124   if (auto splatAttr = attr.dyn_cast<SplatElementsAttr>()) {
125     llvm::Type *elementType;
126     uint64_t numElements;
127     if (auto *arrayTy = dyn_cast<llvm::ArrayType>(llvmType)) {
128       elementType = arrayTy->getElementType();
129       numElements = arrayTy->getNumElements();
130     } else {
131       auto *vectorTy = cast<llvm::FixedVectorType>(llvmType);
132       elementType = vectorTy->getElementType();
133       numElements = vectorTy->getNumElements();
134     }
135     // Splat value is a scalar. Extract it only if the element type is not
136     // another sequence type. The recursion terminates because each step removes
137     // one outer sequential type.
138     bool elementTypeSequential =
139         isa<llvm::ArrayType, llvm::VectorType>(elementType);
140     llvm::Constant *child = getLLVMConstant(
141         elementType,
142         elementTypeSequential ? splatAttr : splatAttr.getSplatValue(), loc);
143     if (!child)
144       return nullptr;
145     if (llvmType->isVectorTy())
146       return llvm::ConstantVector::getSplat(
147           llvm::ElementCount::get(numElements, /*Scalable=*/false), child);
148     if (llvmType->isArrayTy()) {
149       auto *arrayType = llvm::ArrayType::get(elementType, numElements);
150       SmallVector<llvm::Constant *, 8> constants(numElements, child);
151       return llvm::ConstantArray::get(arrayType, constants);
152     }
153   }
154 
155   if (auto elementsAttr = attr.dyn_cast<ElementsAttr>()) {
156     assert(elementsAttr.getType().hasStaticShape());
157     assert(elementsAttr.getNumElements() != 0 &&
158            "unexpected empty elements attribute");
159     assert(!elementsAttr.getType().getShape().empty() &&
160            "unexpected empty elements attribute shape");
161 
162     SmallVector<llvm::Constant *, 8> constants;
163     constants.reserve(elementsAttr.getNumElements());
164     llvm::Type *innermostType = getInnermostElementType(llvmType);
165     for (auto n : elementsAttr.getValues<Attribute>()) {
166       constants.push_back(getLLVMConstant(innermostType, n, loc));
167       if (!constants.back())
168         return nullptr;
169     }
170     ArrayRef<llvm::Constant *> constantsRef = constants;
171     llvm::Constant *result = buildSequentialConstant(
172         constantsRef, elementsAttr.getType().getShape(), llvmType, loc);
173     assert(constantsRef.empty() && "did not consume all elemental constants");
174     return result;
175   }
176 
177   if (auto stringAttr = attr.dyn_cast<StringAttr>()) {
178     return llvm::ConstantDataArray::get(
179         llvmModule->getContext(), ArrayRef<char>{stringAttr.getValue().data(),
180                                                  stringAttr.getValue().size()});
181   }
182   emitError(loc, "unsupported constant value");
183   return nullptr;
184 }
185 
186 /// Convert MLIR integer comparison predicate to LLVM IR comparison predicate.
187 static llvm::CmpInst::Predicate getLLVMCmpPredicate(ICmpPredicate p) {
188   switch (p) {
189   case LLVM::ICmpPredicate::eq:
190     return llvm::CmpInst::Predicate::ICMP_EQ;
191   case LLVM::ICmpPredicate::ne:
192     return llvm::CmpInst::Predicate::ICMP_NE;
193   case LLVM::ICmpPredicate::slt:
194     return llvm::CmpInst::Predicate::ICMP_SLT;
195   case LLVM::ICmpPredicate::sle:
196     return llvm::CmpInst::Predicate::ICMP_SLE;
197   case LLVM::ICmpPredicate::sgt:
198     return llvm::CmpInst::Predicate::ICMP_SGT;
199   case LLVM::ICmpPredicate::sge:
200     return llvm::CmpInst::Predicate::ICMP_SGE;
201   case LLVM::ICmpPredicate::ult:
202     return llvm::CmpInst::Predicate::ICMP_ULT;
203   case LLVM::ICmpPredicate::ule:
204     return llvm::CmpInst::Predicate::ICMP_ULE;
205   case LLVM::ICmpPredicate::ugt:
206     return llvm::CmpInst::Predicate::ICMP_UGT;
207   case LLVM::ICmpPredicate::uge:
208     return llvm::CmpInst::Predicate::ICMP_UGE;
209   }
210   llvm_unreachable("incorrect comparison predicate");
211 }
212 
213 static llvm::CmpInst::Predicate getLLVMCmpPredicate(FCmpPredicate p) {
214   switch (p) {
215   case LLVM::FCmpPredicate::_false:
216     return llvm::CmpInst::Predicate::FCMP_FALSE;
217   case LLVM::FCmpPredicate::oeq:
218     return llvm::CmpInst::Predicate::FCMP_OEQ;
219   case LLVM::FCmpPredicate::ogt:
220     return llvm::CmpInst::Predicate::FCMP_OGT;
221   case LLVM::FCmpPredicate::oge:
222     return llvm::CmpInst::Predicate::FCMP_OGE;
223   case LLVM::FCmpPredicate::olt:
224     return llvm::CmpInst::Predicate::FCMP_OLT;
225   case LLVM::FCmpPredicate::ole:
226     return llvm::CmpInst::Predicate::FCMP_OLE;
227   case LLVM::FCmpPredicate::one:
228     return llvm::CmpInst::Predicate::FCMP_ONE;
229   case LLVM::FCmpPredicate::ord:
230     return llvm::CmpInst::Predicate::FCMP_ORD;
231   case LLVM::FCmpPredicate::ueq:
232     return llvm::CmpInst::Predicate::FCMP_UEQ;
233   case LLVM::FCmpPredicate::ugt:
234     return llvm::CmpInst::Predicate::FCMP_UGT;
235   case LLVM::FCmpPredicate::uge:
236     return llvm::CmpInst::Predicate::FCMP_UGE;
237   case LLVM::FCmpPredicate::ult:
238     return llvm::CmpInst::Predicate::FCMP_ULT;
239   case LLVM::FCmpPredicate::ule:
240     return llvm::CmpInst::Predicate::FCMP_ULE;
241   case LLVM::FCmpPredicate::une:
242     return llvm::CmpInst::Predicate::FCMP_UNE;
243   case LLVM::FCmpPredicate::uno:
244     return llvm::CmpInst::Predicate::FCMP_UNO;
245   case LLVM::FCmpPredicate::_true:
246     return llvm::CmpInst::Predicate::FCMP_TRUE;
247   }
248   llvm_unreachable("incorrect comparison predicate");
249 }
250 
251 static llvm::AtomicRMWInst::BinOp getLLVMAtomicBinOp(AtomicBinOp op) {
252   switch (op) {
253   case LLVM::AtomicBinOp::xchg:
254     return llvm::AtomicRMWInst::BinOp::Xchg;
255   case LLVM::AtomicBinOp::add:
256     return llvm::AtomicRMWInst::BinOp::Add;
257   case LLVM::AtomicBinOp::sub:
258     return llvm::AtomicRMWInst::BinOp::Sub;
259   case LLVM::AtomicBinOp::_and:
260     return llvm::AtomicRMWInst::BinOp::And;
261   case LLVM::AtomicBinOp::nand:
262     return llvm::AtomicRMWInst::BinOp::Nand;
263   case LLVM::AtomicBinOp::_or:
264     return llvm::AtomicRMWInst::BinOp::Or;
265   case LLVM::AtomicBinOp::_xor:
266     return llvm::AtomicRMWInst::BinOp::Xor;
267   case LLVM::AtomicBinOp::max:
268     return llvm::AtomicRMWInst::BinOp::Max;
269   case LLVM::AtomicBinOp::min:
270     return llvm::AtomicRMWInst::BinOp::Min;
271   case LLVM::AtomicBinOp::umax:
272     return llvm::AtomicRMWInst::BinOp::UMax;
273   case LLVM::AtomicBinOp::umin:
274     return llvm::AtomicRMWInst::BinOp::UMin;
275   case LLVM::AtomicBinOp::fadd:
276     return llvm::AtomicRMWInst::BinOp::FAdd;
277   case LLVM::AtomicBinOp::fsub:
278     return llvm::AtomicRMWInst::BinOp::FSub;
279   }
280   llvm_unreachable("incorrect atomic binary operator");
281 }
282 
283 static llvm::AtomicOrdering getLLVMAtomicOrdering(AtomicOrdering ordering) {
284   switch (ordering) {
285   case LLVM::AtomicOrdering::not_atomic:
286     return llvm::AtomicOrdering::NotAtomic;
287   case LLVM::AtomicOrdering::unordered:
288     return llvm::AtomicOrdering::Unordered;
289   case LLVM::AtomicOrdering::monotonic:
290     return llvm::AtomicOrdering::Monotonic;
291   case LLVM::AtomicOrdering::acquire:
292     return llvm::AtomicOrdering::Acquire;
293   case LLVM::AtomicOrdering::release:
294     return llvm::AtomicOrdering::Release;
295   case LLVM::AtomicOrdering::acq_rel:
296     return llvm::AtomicOrdering::AcquireRelease;
297   case LLVM::AtomicOrdering::seq_cst:
298     return llvm::AtomicOrdering::SequentiallyConsistent;
299   }
300   llvm_unreachable("incorrect atomic ordering");
301 }
302 
303 ModuleTranslation::ModuleTranslation(Operation *module,
304                                      std::unique_ptr<llvm::Module> llvmModule)
305     : mlirModule(module), llvmModule(std::move(llvmModule)),
306       debugTranslation(
307           std::make_unique<DebugTranslation>(module, *this->llvmModule)),
308       ompDialect(module->getContext()->getLoadedDialect("omp")),
309       typeTranslator(this->llvmModule->getContext()) {
310   assert(satisfiesLLVMModule(mlirModule) &&
311          "mlirModule should honor LLVM's module semantics.");
312 }
313 ModuleTranslation::~ModuleTranslation() {
314   if (ompBuilder)
315     ompBuilder->finalize();
316 }
317 
318 /// Get the SSA value passed to the current block from the terminator operation
319 /// of its predecessor.
320 static Value getPHISourceValue(Block *current, Block *pred,
321                                unsigned numArguments, unsigned index) {
322   Operation &terminator = *pred->getTerminator();
323   if (isa<LLVM::BrOp>(terminator))
324     return terminator.getOperand(index);
325 
326   SuccessorRange successors = terminator.getSuccessors();
327   assert(std::adjacent_find(successors.begin(), successors.end()) ==
328              successors.end() &&
329          "successors with arguments in LLVM branches must be different blocks");
330   (void)successors;
331 
332   // For instructions that branch based on a condition value, we need to take
333   // the operands for the branch that was taken.
334   if (auto condBranchOp = dyn_cast<LLVM::CondBrOp>(terminator)) {
335     // For conditional branches, we take the operands from either the "true" or
336     // the "false" branch.
337     return condBranchOp.getSuccessor(0) == current
338                ? condBranchOp.trueDestOperands()[index]
339                : condBranchOp.falseDestOperands()[index];
340   } else if (auto switchOp = dyn_cast<LLVM::SwitchOp>(terminator)) {
341     // For switches, we take the operands from either the default case, or from
342     // the case branch that was taken.
343     if (switchOp.defaultDestination() == current)
344       return switchOp.defaultOperands()[index];
345     for (auto i : llvm::enumerate(switchOp.caseDestinations()))
346       if (i.value() == current)
347         return switchOp.getCaseOperands(i.index())[index];
348   }
349 
350   llvm_unreachable("only branch or switch operations can be terminators of a "
351                    "block that has successors");
352 }
353 
354 /// Connect the PHI nodes to the results of preceding blocks.
355 template <typename T>
356 static void connectPHINodes(
357     T &func, const DenseMap<Value, llvm::Value *> &valueMapping,
358     const DenseMap<Block *, llvm::BasicBlock *> &blockMapping,
359     const DenseMap<Operation *, llvm::Instruction *> &branchMapping) {
360   // Skip the first block, it cannot be branched to and its arguments correspond
361   // to the arguments of the LLVM function.
362   for (auto it = std::next(func.begin()), eit = func.end(); it != eit; ++it) {
363     Block *bb = &*it;
364     llvm::BasicBlock *llvmBB = blockMapping.lookup(bb);
365     auto phis = llvmBB->phis();
366     auto numArguments = bb->getNumArguments();
367     assert(numArguments == std::distance(phis.begin(), phis.end()));
368     for (auto &numberedPhiNode : llvm::enumerate(phis)) {
369       auto &phiNode = numberedPhiNode.value();
370       unsigned index = numberedPhiNode.index();
371       for (auto *pred : bb->getPredecessors()) {
372         // Find the LLVM IR block that contains the converted terminator
373         // instruction and use it in the PHI node. Note that this block is not
374         // necessarily the same as blockMapping.lookup(pred), some operations
375         // (in particular, OpenMP operations using OpenMPIRBuilder) may have
376         // split the blocks.
377         llvm::Instruction *terminator =
378             branchMapping.lookup(pred->getTerminator());
379         assert(terminator && "missing the mapping for a terminator");
380         phiNode.addIncoming(valueMapping.lookup(getPHISourceValue(
381                                 bb, pred, numArguments, index)),
382                             terminator->getParent());
383       }
384     }
385   }
386 }
387 
388 /// Sort function blocks topologically.
389 template <typename T>
390 static llvm::SetVector<Block *> topologicalSort(T &f) {
391   // For each block that has not been visited yet (i.e. that has no
392   // predecessors), add it to the list as well as its successors.
393   llvm::SetVector<Block *> blocks;
394   for (Block &b : f) {
395     if (blocks.count(&b) == 0) {
396       llvm::ReversePostOrderTraversal<Block *> traversal(&b);
397       blocks.insert(traversal.begin(), traversal.end());
398     }
399   }
400   assert(blocks.size() == f.getBlocks().size() && "some blocks are not sorted");
401 
402   return blocks;
403 }
404 
405 /// Convert the OpenMP parallel Operation to LLVM IR.
406 LogicalResult
407 ModuleTranslation::convertOmpParallel(Operation &opInst,
408                                       llvm::IRBuilder<> &builder) {
409   using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy;
410   // TODO: support error propagation in OpenMPIRBuilder and use it instead of
411   // relying on captured variables.
412   LogicalResult bodyGenStatus = success();
413 
414   auto bodyGenCB = [&](InsertPointTy allocaIP, InsertPointTy codeGenIP,
415                        llvm::BasicBlock &continuationIP) {
416     llvm::LLVMContext &llvmContext = llvmModule->getContext();
417 
418     llvm::BasicBlock *codeGenIPBB = codeGenIP.getBlock();
419     llvm::Instruction *codeGenIPBBTI = codeGenIPBB->getTerminator();
420     ompContinuationIPStack.push_back(&continuationIP);
421 
422     // ParallelOp has only `1` region associated with it.
423     auto &region = cast<omp::ParallelOp>(opInst).getRegion();
424     for (auto &bb : region) {
425       auto *llvmBB = llvm::BasicBlock::Create(
426           llvmContext, "omp.par.region", codeGenIP.getBlock()->getParent());
427       blockMapping[&bb] = llvmBB;
428     }
429 
430     convertOmpOpRegions(region, valueMapping, blockMapping, codeGenIPBBTI,
431                         continuationIP, builder, bodyGenStatus);
432     ompContinuationIPStack.pop_back();
433 
434   };
435 
436   // TODO: Perform appropriate actions according to the data-sharing
437   // attribute (shared, private, firstprivate, ...) of variables.
438   // Currently defaults to shared.
439   auto privCB = [&](InsertPointTy allocaIP, InsertPointTy codeGenIP,
440                     llvm::Value &, llvm::Value &vPtr,
441                     llvm::Value *&replacementValue) -> InsertPointTy {
442     replacementValue = &vPtr;
443 
444     return codeGenIP;
445   };
446 
447   // TODO: Perform finalization actions for variables. This has to be
448   // called for variables which have destructors/finalizers.
449   auto finiCB = [&](InsertPointTy codeGenIP) {};
450 
451   llvm::Value *ifCond = nullptr;
452   if (auto ifExprVar = cast<omp::ParallelOp>(opInst).if_expr_var())
453     ifCond = valueMapping.lookup(ifExprVar);
454   llvm::Value *numThreads = nullptr;
455   if (auto numThreadsVar = cast<omp::ParallelOp>(opInst).num_threads_var())
456     numThreads = valueMapping.lookup(numThreadsVar);
457   llvm::omp::ProcBindKind pbKind = llvm::omp::OMP_PROC_BIND_default;
458   if (auto bind = cast<omp::ParallelOp>(opInst).proc_bind_val())
459     pbKind = llvm::omp::getProcBindKind(bind.getValue());
460   // TODO: Is the Parallel construct cancellable?
461   bool isCancellable = false;
462   // TODO: Determine the actual alloca insertion point, e.g., the function
463   // entry or the alloca insertion point as provided by the body callback
464   // above.
465   llvm::OpenMPIRBuilder::InsertPointTy allocaIP(builder.saveIP());
466   if (failed(bodyGenStatus))
467     return failure();
468   builder.restoreIP(
469       ompBuilder->createParallel(builder, allocaIP, bodyGenCB, privCB, finiCB,
470                                  ifCond, numThreads, pbKind, isCancellable));
471   return success();
472 }
473 
474 void ModuleTranslation::convertOmpOpRegions(
475     Region &region, DenseMap<Value, llvm::Value *> &valueMapping,
476     DenseMap<Block *, llvm::BasicBlock *> &blockMapping,
477     llvm::Instruction *codeGenIPBBTI, llvm::BasicBlock &continuationIP,
478     llvm::IRBuilder<> &builder, LogicalResult &bodyGenStatus) {
479   // Convert blocks one by one in topological order to ensure
480   // defs are converted before uses.
481   llvm::SetVector<Block *> blocks = topologicalSort(region);
482   for (auto indexedBB : llvm::enumerate(blocks)) {
483     Block *bb = indexedBB.value();
484     llvm::BasicBlock *curLLVMBB = blockMapping[bb];
485     if (bb->isEntryBlock()) {
486       assert(codeGenIPBBTI->getNumSuccessors() == 1 &&
487              "OpenMPIRBuilder provided entry block has multiple successors");
488       assert(codeGenIPBBTI->getSuccessor(0) == &continuationIP &&
489              "ContinuationIP is not the successor of OpenMPIRBuilder "
490              "provided entry block");
491       codeGenIPBBTI->setSuccessor(0, curLLVMBB);
492     }
493 
494     if (failed(convertBlock(*bb, /*ignoreArguments=*/indexedBB.index() == 0))) {
495       bodyGenStatus = failure();
496       return;
497     }
498   }
499   // Finally, after all blocks have been traversed and values mapped,
500   // connect the PHI nodes to the results of preceding blocks.
501   connectPHINodes(region, valueMapping, blockMapping, branchMapping);
502 }
503 
504 LogicalResult ModuleTranslation::convertOmpMaster(Operation &opInst,
505                                                   llvm::IRBuilder<> &builder) {
506   using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy;
507   // TODO: support error propagation in OpenMPIRBuilder and use it instead of
508   // relying on captured variables.
509   LogicalResult bodyGenStatus = success();
510 
511   auto bodyGenCB = [&](InsertPointTy allocaIP, InsertPointTy codeGenIP,
512                        llvm::BasicBlock &continuationIP) {
513     llvm::LLVMContext &llvmContext = llvmModule->getContext();
514 
515     llvm::BasicBlock *codeGenIPBB = codeGenIP.getBlock();
516     llvm::Instruction *codeGenIPBBTI = codeGenIPBB->getTerminator();
517     ompContinuationIPStack.push_back(&continuationIP);
518 
519     // MasterOp has only `1` region associated with it.
520     auto &region = cast<omp::MasterOp>(opInst).getRegion();
521     for (auto &bb : region) {
522       auto *llvmBB = llvm::BasicBlock::Create(
523           llvmContext, "omp.master.region", codeGenIP.getBlock()->getParent());
524       blockMapping[&bb] = llvmBB;
525     }
526     convertOmpOpRegions(region, valueMapping, blockMapping, codeGenIPBBTI,
527                         continuationIP, builder, bodyGenStatus);
528     ompContinuationIPStack.pop_back();
529   };
530 
531   // TODO: Perform finalization actions for variables. This has to be
532   // called for variables which have destructors/finalizers.
533   auto finiCB = [&](InsertPointTy codeGenIP) {};
534 
535   builder.restoreIP(ompBuilder->createMaster(builder, bodyGenCB, finiCB));
536   return success();
537 }
538 
539 /// Given an OpenMP MLIR operation, create the corresponding LLVM IR
540 /// (including OpenMP runtime calls).
541 LogicalResult
542 ModuleTranslation::convertOmpOperation(Operation &opInst,
543                                        llvm::IRBuilder<> &builder) {
544   if (!ompBuilder) {
545     ompBuilder = std::make_unique<llvm::OpenMPIRBuilder>(*llvmModule);
546     ompBuilder->initialize();
547   }
548   return llvm::TypeSwitch<Operation *, LogicalResult>(&opInst)
549       .Case([&](omp::BarrierOp) {
550         ompBuilder->createBarrier(builder.saveIP(), llvm::omp::OMPD_barrier);
551         return success();
552       })
553       .Case([&](omp::TaskwaitOp) {
554         ompBuilder->createTaskwait(builder.saveIP());
555         return success();
556       })
557       .Case([&](omp::TaskyieldOp) {
558         ompBuilder->createTaskyield(builder.saveIP());
559         return success();
560       })
561       .Case([&](omp::FlushOp) {
562         // No support in Openmp runtime function (__kmpc_flush) to accept
563         // the argument list.
564         // OpenMP standard states the following:
565         //  "An implementation may implement a flush with a list by ignoring
566         //   the list, and treating it the same as a flush without a list."
567         //
568         // The argument list is discarded so that, flush with a list is treated
569         // same as a flush without a list.
570         ompBuilder->createFlush(builder.saveIP());
571         return success();
572       })
573       .Case([&](omp::TerminatorOp) {
574         builder.CreateBr(ompContinuationIPStack.back());
575         return success();
576       })
577       .Case(
578           [&](omp::ParallelOp) { return convertOmpParallel(opInst, builder); })
579       .Case([&](omp::MasterOp) { return convertOmpMaster(opInst, builder); })
580       .Default([&](Operation *inst) {
581         return inst->emitError("unsupported OpenMP operation: ")
582                << inst->getName();
583       });
584 }
585 
586 /// Given a single MLIR operation, create the corresponding LLVM IR operation
587 /// using the `builder`.  LLVM IR Builder does not have a generic interface so
588 /// this has to be a long chain of `if`s calling different functions with a
589 /// different number of arguments.
590 LogicalResult ModuleTranslation::convertOperation(Operation &opInst,
591                                                   llvm::IRBuilder<> &builder) {
592   auto extractPosition = [](ArrayAttr attr) {
593     SmallVector<unsigned, 4> position;
594     position.reserve(attr.size());
595     for (Attribute v : attr)
596       position.push_back(v.cast<IntegerAttr>().getValue().getZExtValue());
597     return position;
598   };
599 
600 #include "mlir/Dialect/LLVMIR/LLVMConversions.inc"
601 
602   // Emit function calls.  If the "callee" attribute is present, this is a
603   // direct function call and we also need to look up the remapped function
604   // itself.  Otherwise, this is an indirect call and the callee is the first
605   // operand, look it up as a normal value.  Return the llvm::Value representing
606   // the function result, which may be of llvm::VoidTy type.
607   auto convertCall = [this, &builder](Operation &op) -> llvm::Value * {
608     auto operands = lookupValues(op.getOperands());
609     ArrayRef<llvm::Value *> operandsRef(operands);
610     if (auto attr = op.getAttrOfType<FlatSymbolRefAttr>("callee")) {
611       return builder.CreateCall(functionMapping.lookup(attr.getValue()),
612                                 operandsRef);
613     } else {
614       auto *calleePtrType =
615           cast<llvm::PointerType>(operandsRef.front()->getType());
616       auto *calleeType =
617           cast<llvm::FunctionType>(calleePtrType->getElementType());
618       return builder.CreateCall(calleeType, operandsRef.front(),
619                                 operandsRef.drop_front());
620     }
621   };
622 
623   // Emit calls.  If the called function has a result, remap the corresponding
624   // value.  Note that LLVM IR dialect CallOp has either 0 or 1 result.
625   if (isa<LLVM::CallOp>(opInst)) {
626     llvm::Value *result = convertCall(opInst);
627     if (opInst.getNumResults() != 0) {
628       valueMapping[opInst.getResult(0)] = result;
629       return success();
630     }
631     // Check that LLVM call returns void for 0-result functions.
632     return success(result->getType()->isVoidTy());
633   }
634 
635   if (auto inlineAsmOp = dyn_cast<LLVM::InlineAsmOp>(opInst)) {
636     // TODO: refactor function type creation which usually occurs in std-LLVM
637     // conversion.
638     SmallVector<LLVM::LLVMType, 8> operandTypes;
639     operandTypes.reserve(inlineAsmOp.operands().size());
640     for (auto t : inlineAsmOp.operands().getTypes())
641       operandTypes.push_back(t.cast<LLVM::LLVMType>());
642 
643     LLVM::LLVMType resultType;
644     if (inlineAsmOp.getNumResults() == 0) {
645       resultType = LLVM::LLVMType::getVoidTy(mlirModule->getContext());
646     } else {
647       assert(inlineAsmOp.getNumResults() == 1);
648       resultType = inlineAsmOp.getResultTypes()[0].cast<LLVM::LLVMType>();
649     }
650     auto ft = LLVM::LLVMType::getFunctionTy(resultType, operandTypes,
651                                             /*isVarArg=*/false);
652     llvm::InlineAsm *inlineAsmInst =
653         inlineAsmOp.asm_dialect().hasValue()
654             ? llvm::InlineAsm::get(
655                   static_cast<llvm::FunctionType *>(convertType(ft)),
656                   inlineAsmOp.asm_string(), inlineAsmOp.constraints(),
657                   inlineAsmOp.has_side_effects(), inlineAsmOp.is_align_stack(),
658                   convertAsmDialectToLLVM(*inlineAsmOp.asm_dialect()))
659             : llvm::InlineAsm::get(
660                   static_cast<llvm::FunctionType *>(convertType(ft)),
661                   inlineAsmOp.asm_string(), inlineAsmOp.constraints(),
662                   inlineAsmOp.has_side_effects(), inlineAsmOp.is_align_stack());
663     llvm::Value *result =
664         builder.CreateCall(inlineAsmInst, lookupValues(inlineAsmOp.operands()));
665     if (opInst.getNumResults() != 0)
666       valueMapping[opInst.getResult(0)] = result;
667     return success();
668   }
669 
670   if (auto invOp = dyn_cast<LLVM::InvokeOp>(opInst)) {
671     auto operands = lookupValues(opInst.getOperands());
672     ArrayRef<llvm::Value *> operandsRef(operands);
673     if (auto attr = opInst.getAttrOfType<FlatSymbolRefAttr>("callee")) {
674       builder.CreateInvoke(functionMapping.lookup(attr.getValue()),
675                            blockMapping[invOp.getSuccessor(0)],
676                            blockMapping[invOp.getSuccessor(1)], operandsRef);
677     } else {
678       auto *calleePtrType =
679           cast<llvm::PointerType>(operandsRef.front()->getType());
680       auto *calleeType =
681           cast<llvm::FunctionType>(calleePtrType->getElementType());
682       builder.CreateInvoke(
683           calleeType, operandsRef.front(), blockMapping[invOp.getSuccessor(0)],
684           blockMapping[invOp.getSuccessor(1)], operandsRef.drop_front());
685     }
686     return success();
687   }
688 
689   if (auto lpOp = dyn_cast<LLVM::LandingpadOp>(opInst)) {
690     llvm::Type *ty = convertType(lpOp.getType().cast<LLVMType>());
691     llvm::LandingPadInst *lpi =
692         builder.CreateLandingPad(ty, lpOp.getNumOperands());
693 
694     // Add clauses
695     for (auto operand : lookupValues(lpOp.getOperands())) {
696       // All operands should be constant - checked by verifier
697       if (auto constOperand = dyn_cast<llvm::Constant>(operand))
698         lpi->addClause(constOperand);
699     }
700     valueMapping[lpOp.getResult()] = lpi;
701     return success();
702   }
703 
704   // Emit branches.  We need to look up the remapped blocks and ignore the block
705   // arguments that were transformed into PHI nodes.
706   if (auto brOp = dyn_cast<LLVM::BrOp>(opInst)) {
707     llvm::BranchInst *branch =
708         builder.CreateBr(blockMapping[brOp.getSuccessor()]);
709     branchMapping.try_emplace(&opInst, branch);
710     return success();
711   }
712   if (auto condbrOp = dyn_cast<LLVM::CondBrOp>(opInst)) {
713     auto weights = condbrOp.branch_weights();
714     llvm::MDNode *branchWeights = nullptr;
715     if (weights) {
716       // Map weight attributes to LLVM metadata.
717       auto trueWeight =
718           weights.getValue().getValue(0).cast<IntegerAttr>().getInt();
719       auto falseWeight =
720           weights.getValue().getValue(1).cast<IntegerAttr>().getInt();
721       branchWeights =
722           llvm::MDBuilder(llvmModule->getContext())
723               .createBranchWeights(static_cast<uint32_t>(trueWeight),
724                                    static_cast<uint32_t>(falseWeight));
725     }
726     llvm::BranchInst *branch = builder.CreateCondBr(
727         valueMapping.lookup(condbrOp.getOperand(0)),
728         blockMapping[condbrOp.getSuccessor(0)],
729         blockMapping[condbrOp.getSuccessor(1)], branchWeights);
730     branchMapping.try_emplace(&opInst, branch);
731     return success();
732   }
733   if (auto switchOp = dyn_cast<LLVM::SwitchOp>(opInst)) {
734     llvm::MDNode *branchWeights = nullptr;
735     if (auto weights = switchOp.branch_weights()) {
736       llvm::SmallVector<uint32_t> weightValues;
737       weightValues.reserve(weights->size());
738       for (llvm::APInt weight : weights->cast<DenseIntElementsAttr>())
739         weightValues.push_back(weight.getLimitedValue());
740       branchWeights = llvm::MDBuilder(llvmModule->getContext())
741                           .createBranchWeights(weightValues);
742     }
743 
744     llvm::SwitchInst *switchInst =
745         builder.CreateSwitch(valueMapping[switchOp.value()],
746                              blockMapping[switchOp.defaultDestination()],
747                              switchOp.caseDestinations().size(), branchWeights);
748 
749     auto *ty = llvm::cast<llvm::IntegerType>(
750         convertType(switchOp.value().getType().cast<LLVMType>()));
751     for (auto i :
752          llvm::zip(switchOp.case_values()->cast<DenseIntElementsAttr>(),
753                    switchOp.caseDestinations()))
754       switchInst->addCase(
755           llvm::ConstantInt::get(ty, std::get<0>(i).getLimitedValue()),
756           blockMapping[std::get<1>(i)]);
757 
758     branchMapping.try_emplace(&opInst, switchInst);
759     return success();
760   }
761 
762   // Emit addressof.  We need to look up the global value referenced by the
763   // operation and store it in the MLIR-to-LLVM value mapping.  This does not
764   // emit any LLVM instruction.
765   if (auto addressOfOp = dyn_cast<LLVM::AddressOfOp>(opInst)) {
766     LLVM::GlobalOp global = addressOfOp.getGlobal();
767     LLVM::LLVMFuncOp function = addressOfOp.getFunction();
768 
769     // The verifier should not have allowed this.
770     assert((global || function) &&
771            "referencing an undefined global or function");
772 
773     valueMapping[addressOfOp.getResult()] =
774         global ? globalsMapping.lookup(global)
775                : functionMapping.lookup(function.getName());
776     return success();
777   }
778 
779   if (ompDialect && opInst.getDialect() == ompDialect)
780     return convertOmpOperation(opInst, builder);
781 
782   return opInst.emitError("unsupported or non-LLVM operation: ")
783          << opInst.getName();
784 }
785 
786 /// Convert block to LLVM IR.  Unless `ignoreArguments` is set, emit PHI nodes
787 /// to define values corresponding to the MLIR block arguments.  These nodes
788 /// are not connected to the source basic blocks, which may not exist yet.
789 LogicalResult ModuleTranslation::convertBlock(Block &bb, bool ignoreArguments) {
790   llvm::IRBuilder<> builder(blockMapping[&bb]);
791   auto *subprogram = builder.GetInsertBlock()->getParent()->getSubprogram();
792 
793   // Before traversing operations, make block arguments available through
794   // value remapping and PHI nodes, but do not add incoming edges for the PHI
795   // nodes just yet: those values may be defined by this or following blocks.
796   // This step is omitted if "ignoreArguments" is set.  The arguments of the
797   // first block have been already made available through the remapping of
798   // LLVM function arguments.
799   if (!ignoreArguments) {
800     auto predecessors = bb.getPredecessors();
801     unsigned numPredecessors =
802         std::distance(predecessors.begin(), predecessors.end());
803     for (auto arg : bb.getArguments()) {
804       auto wrappedType = arg.getType().dyn_cast<LLVM::LLVMType>();
805       if (!wrappedType)
806         return emitError(bb.front().getLoc(),
807                          "block argument does not have an LLVM type");
808       llvm::Type *type = convertType(wrappedType);
809       llvm::PHINode *phi = builder.CreatePHI(type, numPredecessors);
810       valueMapping[arg] = phi;
811     }
812   }
813 
814   // Traverse operations.
815   for (auto &op : bb) {
816     // Set the current debug location within the builder.
817     builder.SetCurrentDebugLocation(
818         debugTranslation->translateLoc(op.getLoc(), subprogram));
819 
820     if (failed(convertOperation(op, builder)))
821       return failure();
822   }
823 
824   return success();
825 }
826 
827 /// Create named global variables that correspond to llvm.mlir.global
828 /// definitions.
829 LogicalResult ModuleTranslation::convertGlobals() {
830   for (auto op : getModuleBody(mlirModule).getOps<LLVM::GlobalOp>()) {
831     llvm::Type *type = convertType(op.getType());
832     llvm::Constant *cst = llvm::UndefValue::get(type);
833     if (op.getValueOrNull()) {
834       // String attributes are treated separately because they cannot appear as
835       // in-function constants and are thus not supported by getLLVMConstant.
836       if (auto strAttr = op.getValueOrNull().dyn_cast_or_null<StringAttr>()) {
837         cst = llvm::ConstantDataArray::getString(
838             llvmModule->getContext(), strAttr.getValue(), /*AddNull=*/false);
839         type = cst->getType();
840       } else if (!(cst = getLLVMConstant(type, op.getValueOrNull(),
841                                          op.getLoc()))) {
842         return failure();
843       }
844     } else if (Block *initializer = op.getInitializerBlock()) {
845       llvm::IRBuilder<> builder(llvmModule->getContext());
846       for (auto &op : initializer->without_terminator()) {
847         if (failed(convertOperation(op, builder)) ||
848             !isa<llvm::Constant>(valueMapping.lookup(op.getResult(0))))
849           return emitError(op.getLoc(), "unemittable constant value");
850       }
851       ReturnOp ret = cast<ReturnOp>(initializer->getTerminator());
852       cst = cast<llvm::Constant>(valueMapping.lookup(ret.getOperand(0)));
853     }
854 
855     auto linkage = convertLinkageToLLVM(op.linkage());
856     bool anyExternalLinkage =
857         ((linkage == llvm::GlobalVariable::ExternalLinkage &&
858           isa<llvm::UndefValue>(cst)) ||
859          linkage == llvm::GlobalVariable::ExternalWeakLinkage);
860     auto addrSpace = op.addr_space();
861     auto *var = new llvm::GlobalVariable(
862         *llvmModule, type, op.constant(), linkage,
863         anyExternalLinkage ? nullptr : cst, op.sym_name(),
864         /*InsertBefore=*/nullptr, llvm::GlobalValue::NotThreadLocal, addrSpace);
865 
866     globalsMapping.try_emplace(op, var);
867   }
868 
869   return success();
870 }
871 
872 /// Attempts to add an attribute identified by `key`, optionally with the given
873 /// `value` to LLVM function `llvmFunc`. Reports errors at `loc` if any. If the
874 /// attribute has a kind known to LLVM IR, create the attribute of this kind,
875 /// otherwise keep it as a string attribute. Performs additional checks for
876 /// attributes known to have or not have a value in order to avoid assertions
877 /// inside LLVM upon construction.
878 static LogicalResult checkedAddLLVMFnAttribute(Location loc,
879                                                llvm::Function *llvmFunc,
880                                                StringRef key,
881                                                StringRef value = StringRef()) {
882   auto kind = llvm::Attribute::getAttrKindFromName(key);
883   if (kind == llvm::Attribute::None) {
884     llvmFunc->addFnAttr(key, value);
885     return success();
886   }
887 
888   if (llvm::Attribute::doesAttrKindHaveArgument(kind)) {
889     if (value.empty())
890       return emitError(loc) << "LLVM attribute '" << key << "' expects a value";
891 
892     int result;
893     if (!value.getAsInteger(/*Radix=*/0, result))
894       llvmFunc->addFnAttr(
895           llvm::Attribute::get(llvmFunc->getContext(), kind, result));
896     else
897       llvmFunc->addFnAttr(key, value);
898     return success();
899   }
900 
901   if (!value.empty())
902     return emitError(loc) << "LLVM attribute '" << key
903                           << "' does not expect a value, found '" << value
904                           << "'";
905 
906   llvmFunc->addFnAttr(kind);
907   return success();
908 }
909 
910 /// Attaches the attributes listed in the given array attribute to `llvmFunc`.
911 /// Reports error to `loc` if any and returns immediately. Expects `attributes`
912 /// to be an array attribute containing either string attributes, treated as
913 /// value-less LLVM attributes, or array attributes containing two string
914 /// attributes, with the first string being the name of the corresponding LLVM
915 /// attribute and the second string beings its value. Note that even integer
916 /// attributes are expected to have their values expressed as strings.
917 static LogicalResult
918 forwardPassthroughAttributes(Location loc, Optional<ArrayAttr> attributes,
919                              llvm::Function *llvmFunc) {
920   if (!attributes)
921     return success();
922 
923   for (Attribute attr : *attributes) {
924     if (auto stringAttr = attr.dyn_cast<StringAttr>()) {
925       if (failed(
926               checkedAddLLVMFnAttribute(loc, llvmFunc, stringAttr.getValue())))
927         return failure();
928       continue;
929     }
930 
931     auto arrayAttr = attr.dyn_cast<ArrayAttr>();
932     if (!arrayAttr || arrayAttr.size() != 2)
933       return emitError(loc)
934              << "expected 'passthrough' to contain string or array attributes";
935 
936     auto keyAttr = arrayAttr[0].dyn_cast<StringAttr>();
937     auto valueAttr = arrayAttr[1].dyn_cast<StringAttr>();
938     if (!keyAttr || !valueAttr)
939       return emitError(loc)
940              << "expected arrays within 'passthrough' to contain two strings";
941 
942     if (failed(checkedAddLLVMFnAttribute(loc, llvmFunc, keyAttr.getValue(),
943                                          valueAttr.getValue())))
944       return failure();
945   }
946   return success();
947 }
948 
949 LogicalResult ModuleTranslation::convertOneFunction(LLVMFuncOp func) {
950   // Clear the block, branch value mappings, they are only relevant within one
951   // function.
952   blockMapping.clear();
953   valueMapping.clear();
954   branchMapping.clear();
955   llvm::Function *llvmFunc = functionMapping.lookup(func.getName());
956 
957   // Translate the debug information for this function.
958   debugTranslation->translate(func, *llvmFunc);
959 
960   // Add function arguments to the value remapping table.
961   // If there was noalias info then we decorate each argument accordingly.
962   unsigned int argIdx = 0;
963   for (auto kvp : llvm::zip(func.getArguments(), llvmFunc->args())) {
964     llvm::Argument &llvmArg = std::get<1>(kvp);
965     BlockArgument mlirArg = std::get<0>(kvp);
966 
967     if (auto attr = func.getArgAttrOfType<BoolAttr>(
968             argIdx, LLVMDialect::getNoAliasAttrName())) {
969       // NB: Attribute already verified to be boolean, so check if we can indeed
970       // attach the attribute to this argument, based on its type.
971       auto argTy = mlirArg.getType().dyn_cast<LLVM::LLVMType>();
972       if (!argTy.isPointerTy())
973         return func.emitError(
974             "llvm.noalias attribute attached to LLVM non-pointer argument");
975       if (attr.getValue())
976         llvmArg.addAttr(llvm::Attribute::AttrKind::NoAlias);
977     }
978 
979     if (auto attr = func.getArgAttrOfType<IntegerAttr>(
980             argIdx, LLVMDialect::getAlignAttrName())) {
981       // NB: Attribute already verified to be int, so check if we can indeed
982       // attach the attribute to this argument, based on its type.
983       auto argTy = mlirArg.getType().dyn_cast<LLVM::LLVMType>();
984       if (!argTy.isPointerTy())
985         return func.emitError(
986             "llvm.align attribute attached to LLVM non-pointer argument");
987       llvmArg.addAttrs(
988           llvm::AttrBuilder().addAlignmentAttr(llvm::Align(attr.getInt())));
989     }
990 
991     valueMapping[mlirArg] = &llvmArg;
992     argIdx++;
993   }
994 
995   // Check the personality and set it.
996   if (func.personality().hasValue()) {
997     llvm::Type *ty = llvm::Type::getInt8PtrTy(llvmFunc->getContext());
998     if (llvm::Constant *pfunc =
999             getLLVMConstant(ty, func.personalityAttr(), func.getLoc()))
1000       llvmFunc->setPersonalityFn(pfunc);
1001   }
1002 
1003   // First, create all blocks so we can jump to them.
1004   llvm::LLVMContext &llvmContext = llvmFunc->getContext();
1005   for (auto &bb : func) {
1006     auto *llvmBB = llvm::BasicBlock::Create(llvmContext);
1007     llvmBB->insertInto(llvmFunc);
1008     blockMapping[&bb] = llvmBB;
1009   }
1010 
1011   // Then, convert blocks one by one in topological order to ensure defs are
1012   // converted before uses.
1013   auto blocks = topologicalSort(func);
1014   for (auto indexedBB : llvm::enumerate(blocks)) {
1015     auto *bb = indexedBB.value();
1016     if (failed(convertBlock(*bb, /*ignoreArguments=*/indexedBB.index() == 0)))
1017       return failure();
1018   }
1019 
1020   // Finally, after all blocks have been traversed and values mapped, connect
1021   // the PHI nodes to the results of preceding blocks.
1022   connectPHINodes(func, valueMapping, blockMapping, branchMapping);
1023   return success();
1024 }
1025 
1026 LogicalResult ModuleTranslation::checkSupportedModuleOps(Operation *m) {
1027   for (Operation &o : getModuleBody(m).getOperations())
1028     if (!isa<LLVM::LLVMFuncOp, LLVM::GlobalOp>(&o) && !o.isKnownTerminator())
1029       return o.emitOpError("unsupported module-level operation");
1030   return success();
1031 }
1032 
1033 LogicalResult ModuleTranslation::convertFunctionSignatures() {
1034   // Declare all functions first because there may be function calls that form a
1035   // call graph with cycles, or global initializers that reference functions.
1036   for (auto function : getModuleBody(mlirModule).getOps<LLVMFuncOp>()) {
1037     llvm::FunctionCallee llvmFuncCst = llvmModule->getOrInsertFunction(
1038         function.getName(),
1039         cast<llvm::FunctionType>(convertType(function.getType())));
1040     llvm::Function *llvmFunc = cast<llvm::Function>(llvmFuncCst.getCallee());
1041     llvmFunc->setLinkage(convertLinkageToLLVM(function.linkage()));
1042     functionMapping[function.getName()] = llvmFunc;
1043 
1044     // Forward the pass-through attributes to LLVM.
1045     if (failed(forwardPassthroughAttributes(function.getLoc(),
1046                                             function.passthrough(), llvmFunc)))
1047       return failure();
1048   }
1049 
1050   return success();
1051 }
1052 
1053 LogicalResult ModuleTranslation::convertFunctions() {
1054   // Convert functions.
1055   for (auto function : getModuleBody(mlirModule).getOps<LLVMFuncOp>()) {
1056     // Ignore external functions.
1057     if (function.isExternal())
1058       continue;
1059 
1060     if (failed(convertOneFunction(function)))
1061       return failure();
1062   }
1063 
1064   return success();
1065 }
1066 
1067 llvm::Type *ModuleTranslation::convertType(LLVMType type) {
1068   return typeTranslator.translateType(type);
1069 }
1070 
1071 /// A helper to look up remapped operands in the value remapping table.`
1072 SmallVector<llvm::Value *, 8>
1073 ModuleTranslation::lookupValues(ValueRange values) {
1074   SmallVector<llvm::Value *, 8> remapped;
1075   remapped.reserve(values.size());
1076   for (Value v : values) {
1077     assert(valueMapping.count(v) && "referencing undefined value");
1078     remapped.push_back(valueMapping.lookup(v));
1079   }
1080   return remapped;
1081 }
1082 
1083 std::unique_ptr<llvm::Module> ModuleTranslation::prepareLLVMModule(
1084     Operation *m, llvm::LLVMContext &llvmContext, StringRef name) {
1085   m->getContext()->getOrLoadDialect<LLVM::LLVMDialect>();
1086   auto llvmModule = std::make_unique<llvm::Module>(name, llvmContext);
1087   if (auto dataLayoutAttr =
1088           m->getAttr(LLVM::LLVMDialect::getDataLayoutAttrName()))
1089     llvmModule->setDataLayout(dataLayoutAttr.cast<StringAttr>().getValue());
1090   if (auto targetTripleAttr =
1091           m->getAttr(LLVM::LLVMDialect::getTargetTripleAttrName()))
1092     llvmModule->setTargetTriple(targetTripleAttr.cast<StringAttr>().getValue());
1093 
1094   // Inject declarations for `malloc` and `free` functions that can be used in
1095   // memref allocation/deallocation coming from standard ops lowering.
1096   llvm::IRBuilder<> builder(llvmContext);
1097   llvmModule->getOrInsertFunction("malloc", builder.getInt8PtrTy(),
1098                                   builder.getInt64Ty());
1099   llvmModule->getOrInsertFunction("free", builder.getVoidTy(),
1100                                   builder.getInt8PtrTy());
1101 
1102   return llvmModule;
1103 }
1104