maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/mlir/lib/Target/LLVMIR/ConvertToLLVMIR.cpp

572 lines
22 KiB
C++
Raw Blame History

//===- ConvertToLLVMIR.cpp - MLIR to LLVM IR conversion ---------*- C++ -*-===//
//
// Copyright 2019 The MLIR Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// =============================================================================
//
// This file implements a translation between the MLIR LLVM dialect and LLVM IR.
//
//===----------------------------------------------------------------------===//
#include "mlir/IR/Attributes.h"
#include "mlir/IR/Module.h"
#include "mlir/LLVMIR/LLVMDialect.h"
#include "mlir/StandardOps/StandardOps.h"
#include "mlir/Support/FileUtilities.h"
#include "mlir/Support/LLVM.h"
#include "mlir/Translation.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/Support/ToolOutputFile.h"
#include "llvm/Transforms/Utils/Cloning.h"
using namespace mlir;
namespace {
// Implementation class for module translation. Holds a reference to the module
// being translated, and the mappings between the original and the translated
// functions, basic blocks and values. It is practically easier to hold these
// mappings in one class since the conversion of control flow instructions
// needs to look up block and function mappins.
class ModuleTranslation {
public:
// Translate the given MLIR module expressed in MLIR LLVM IR dialect into an
// LLVM IR module. The MLIR LLVM IR dialect holds a pointer to an
// LLVMContext, the LLVM IR module will be created in that context.
static std::unique_ptr<llvm::Module> translateModule(const Module &m);
private:
explicit ModuleTranslation(const Module &module) : mlirModule(module) {}
bool convertFunctions();
bool convertOneFunction(const Function &func);
void connectPHINodes(const Function &func);
bool convertBlock(const Block &bb, bool ignoreArguments);
bool convertInstruction(const Instruction &inst, llvm::IRBuilder<> &builder);
llvm::Constant *getLLVMConstant(llvm::Type *llvmType, Attribute attr,
Location loc);
// Original and translated module.
const Module &mlirModule;
std::unique_ptr<llvm::Module> llvmModule;
// Mappings between original and translated values, used for lookups.
llvm::DenseMap<const Function *, llvm::Function *> functionMapping;
llvm::DenseMap<const Value *, llvm::Value *> valueMapping;
llvm::DenseMap<const Block *, llvm::BasicBlock *> blockMapping;
};
} // end anonymous namespace
// Convert an MLIR function type to LLVM IR. Arguments of the function must of
// MLIR LLVM IR dialect types. Use `loc` as a location when reporting errors.
// Return nullptr on errors.
static llvm::FunctionType *convertFunctionType(llvm::LLVMContext &llvmContext,
FunctionType type,
Location loc) {
assert(type && "expected non-null type");
auto context = type.getContext();
if (type.getNumResults() > 1)
return context->emitError(loc,
"LLVM functions can only have 0 or 1 result"),
nullptr;
SmallVector<llvm::Type *, 8> argTypes;
argTypes.reserve(type.getNumInputs());
for (auto t : type.getInputs()) {
auto wrappedLLVMType = t.dyn_cast<LLVM::LLVMType>();
if (!wrappedLLVMType)
return context->emitError(loc, "non-LLVM function argument type"),
nullptr;
argTypes.push_back(wrappedLLVMType.getUnderlyingType());
}
if (type.getNumResults() == 0)
return llvm::FunctionType::get(llvm::Type::getVoidTy(llvmContext), argTypes,
/*isVarArg=*/false);
auto wrappedResultType = type.getResult(0).dyn_cast<LLVM::LLVMType>();
if (!wrappedResultType)
return context->emitError(loc, "non-LLVM function result"), nullptr;
return llvm::FunctionType::get(wrappedResultType.getUnderlyingType(),
argTypes, /*isVarArg=*/false);
}
// Create an LLVM IR constant of `llvmType` from the MLIR attribute `attr`.
// This currently supports integer, floating point, splat and dense element
// attributes and combinations thereof. In case of error, report it to `loc`
// and return nullptr.
llvm::Constant *ModuleTranslation::getLLVMConstant(llvm::Type *llvmType,
Attribute attr,
Location loc) {
if (auto intAttr = attr.dyn_cast<IntegerAttr>())
return llvm::ConstantInt::get(llvmType, intAttr.getValue());
if (auto floatAttr = attr.dyn_cast<FloatAttr>())
return llvm::ConstantFP::get(llvmType, floatAttr.getValue());
if (auto funcAttr = attr.dyn_cast<FunctionAttr>())
return functionMapping.lookup(funcAttr.getValue());
if (auto splatAttr = attr.dyn_cast<SplatElementsAttr>()) {
auto *vectorType = cast<llvm::VectorType>(llvmType);
auto *child = getLLVMConstant(vectorType->getElementType(),
splatAttr.getValue(), loc);
return llvm::ConstantVector::getSplat(vectorType->getNumElements(), child);
}
if (auto denseAttr = attr.dyn_cast<DenseElementsAttr>()) {
auto *vectorType = cast<llvm::VectorType>(llvmType);
SmallVector<llvm::Constant *, 8> constants;
uint64_t numElements = vectorType->getNumElements();
constants.reserve(numElements);
SmallVector<Attribute, 8> nested;
denseAttr.getValues(nested);
for (auto n : nested) {
constants.push_back(
getLLVMConstant(vectorType->getElementType(), n, loc));
if (!constants.back())
return nullptr;
}
return llvm::ConstantVector::get(constants);
}
mlirModule.getContext()->emitError(loc, "unsupported constant value");
return nullptr;
}
// Convert MLIR integer comparison predicate to LLVM IR comparison predicate.
static llvm::CmpInst::Predicate getLLVMCmpPredicate(CmpIPredicate p) {
switch (p) {
case CmpIPredicate::EQ:
return llvm::CmpInst::Predicate::ICMP_EQ;
case CmpIPredicate::NE:
return llvm::CmpInst::Predicate::ICMP_NE;
case CmpIPredicate::SLT:
return llvm::CmpInst::Predicate::ICMP_SLT;
case CmpIPredicate::SLE:
return llvm::CmpInst::Predicate::ICMP_SLE;
case CmpIPredicate::SGT:
return llvm::CmpInst::Predicate::ICMP_SGT;
case CmpIPredicate::SGE:
return llvm::CmpInst::Predicate::ICMP_SGE;
case CmpIPredicate::ULT:
return llvm::CmpInst::Predicate::ICMP_ULT;
case CmpIPredicate::ULE:
return llvm::CmpInst::Predicate::ICMP_ULE;
case CmpIPredicate::UGT:
return llvm::CmpInst::Predicate::ICMP_UGT;
case CmpIPredicate::UGE:
return llvm::CmpInst::Predicate::ICMP_UGE;
default:
llvm_unreachable("incorrect comparison predicate");
}
}
// Given a single MLIR instruction, create the corresponding LLVM IR instruction
// using the `builder`. LLVM IR Builder does not have a generic interface so
// this has to be a long chain of `if`s calling different functions with a
// different number of arguments.
// TODO(zinenko): the conversion is largely mechanical and should be tablegen'ed
bool ModuleTranslation::convertInstruction(const Instruction &inst,
llvm::IRBuilder<> &builder) {
#define CONV_BINARY_OP(CLASS, FUNC) \
if (auto op = inst.dyn_cast<CLASS>()) { \
valueMapping[op->getResult()] = builder.FUNC( \
valueMapping.lookup(op->lhs()), valueMapping.lookup(op->rhs())); \
return false; \
}
CONV_BINARY_OP(LLVM::AddOp, CreateAdd);
CONV_BINARY_OP(LLVM::SubOp, CreateSub);
CONV_BINARY_OP(LLVM::MulOp, CreateMul);
CONV_BINARY_OP(LLVM::SDivOp, CreateSDiv);
CONV_BINARY_OP(LLVM::UDivOp, CreateUDiv);
CONV_BINARY_OP(LLVM::SRemOp, CreateSRem);
CONV_BINARY_OP(LLVM::URemOp, CreateURem);
CONV_BINARY_OP(LLVM::FAddOp, CreateFAdd);
CONV_BINARY_OP(LLVM::FSubOp, CreateFSub);
CONV_BINARY_OP(LLVM::FMulOp, CreateFMul);
CONV_BINARY_OP(LLVM::FDivOp, CreateFDiv);
CONV_BINARY_OP(LLVM::FRemOp, CreateFRem);
#undef CONV_BINARY_OP
if (auto op = inst.dyn_cast<LLVM::ICmpOp>()) {
auto attr = op->getAttrOfType<IntegerAttr>("predicate");
auto predicate = static_cast<CmpIPredicate>(attr.getValue().getSExtValue());
valueMapping[op->getResult()] = builder.CreateICmp(
getLLVMCmpPredicate(predicate), valueMapping.lookup(op->lhs()),
valueMapping.lookup(op->rhs()));
return false;
}
// Pseudo-ops. These do not exist as LLVM operations but produce (constant)
// values.
if (auto op = inst.dyn_cast<LLVM::UndefOp>()) {
auto wrappedType = op->getResult()->getType().dyn_cast<LLVM::LLVMType>();
valueMapping[op->getResult()] =
llvm::UndefValue::get(wrappedType.getUnderlyingType());
return false;
}
if (auto op = inst.dyn_cast<LLVM::ConstantOp>()) {
Attribute attr = op->getAttr("value");
auto type = op->getResult()->getType().cast<LLVM::LLVMType>();
valueMapping[op->getResult()] =
getLLVMConstant(type.getUnderlyingType(), attr, inst.getLoc());
return false;
}
// A helper to look up remapped operands in the value remapping table.
auto lookupValues =
[this](const llvm::iterator_range<Instruction::const_operand_iterator>
&values) {
SmallVector<llvm::Value *, 8> remapped;
remapped.reserve(llvm::size(values));
for (const Value *v : values) {
remapped.push_back(valueMapping.lookup(v));
}
return remapped;
};
// Emit function calls. If the "callee" attribute is present, this is a
// direct function call and we also need to look up the remapped function
// itself. Otherwise, this is an indirect call and the callee is the first
// operand, look it up as a normal value. Return the llvm::Value representing
// the function result, which may be of llvm::VoidTy type.
auto convertCall = [this, lookupValues,
&builder](const Instruction &inst) -> llvm::Value * {
auto operands = lookupValues(inst.getOperands());
ArrayRef<llvm::Value *> operandsRef(operands);
if (auto attr = inst.getAttrOfType<FunctionAttr>("callee")) {
return builder.CreateCall(functionMapping.lookup(attr.getValue()),
operandsRef);
} else {
return builder.CreateCall(operandsRef.front(), operandsRef.drop_front());
}
};
// Emit calls. If the called function has a result, remap the corresponding
// value.
if (auto op = inst.dyn_cast<LLVM::CallOp>()) {
valueMapping[op->getResult()] = convertCall(inst);
return false;
}
if (inst.isa<LLVM::Call0Op>()) {
convertCall(inst);
return false;
}
// Emit branches. We need to look up the remapped blocks and ignore the block
// arguments that were transformed into PHI nodes.
if (auto op = inst.dyn_cast<LLVM::BrOp>()) {
builder.CreateBr(blockMapping[op->getSuccessor(0)]);
return false;
}
if (auto op = inst.dyn_cast<LLVM::CondBrOp>()) {
builder.CreateCondBr(valueMapping.lookup(op->getOperand(0)),
blockMapping[op->getSuccessor(0)],
blockMapping[op->getSuccessor(1)]);
return false;
}
if (auto op = inst.dyn_cast<LLVM::ReturnOp>()) {
if (op->getNumOperands() == 0)
builder.CreateRetVoid();
else
builder.CreateRet(valueMapping.lookup(op->getOperand(0)));
return false;
}
auto extractPosition = [](ArrayAttr attr) {
SmallVector<unsigned, 4> position;
position.reserve(attr.size());
for (Attribute v : attr)
position.push_back(v.cast<IntegerAttr>().getValue().getZExtValue());
return position;
};
if (auto op = inst.dyn_cast<LLVM::ExtractValueOp>()) {
auto attr = op->getAttrOfType<ArrayAttr>("position");
valueMapping[op->getResult()] = builder.CreateExtractValue(
valueMapping.lookup(op->getOperand()), extractPosition(attr));
return false;
}
if (auto op = inst.dyn_cast<LLVM::InsertValueOp>()) {
auto attr = op->getAttrOfType<ArrayAttr>("position");
valueMapping[op->getResult()] = builder.CreateInsertValue(
valueMapping.lookup(op->getOperand(0)),
valueMapping.lookup(op->getOperand(1)), extractPosition(attr));
return false;
}
if (auto op = inst.dyn_cast<LLVM::BitcastOp>()) {
valueMapping[op->getResult()] = builder.CreateBitCast(
valueMapping.lookup(op->getOperand()),
op->getType().cast<LLVM::LLVMType>().getUnderlyingType());
return false;
}
if (auto op = inst.dyn_cast<LLVM::GEPOp>()) {
auto mappedOperands = lookupValues(op->getOperands());
valueMapping[op->getResult()] =
builder.CreateGEP(mappedOperands.front(),
llvm::makeArrayRef(mappedOperands).drop_front());
return false;
}
if (auto op = inst.dyn_cast<LLVM::LoadOp>()) {
valueMapping[op->getResult()] =
builder.CreateLoad(valueMapping.lookup(op->getOperand()));
return false;
}
if (auto op = inst.dyn_cast<LLVM::StoreOp>()) {
builder.CreateStore(valueMapping.lookup(op->getOperand(0)),
valueMapping.lookup(op->getOperand(1)));
return false;
}
if (auto op = inst.dyn_cast<LLVM::SelectOp>()) {
valueMapping[op->getResult()] =
builder.CreateSelect(valueMapping.lookup(op->getOperand(0)),
valueMapping.lookup(op->getOperand(1)),
valueMapping.lookup(op->getOperand(2)));
return false;
}
inst.emitError("unsupported or non-LLVM operation: " +
inst.getName().getStringRef());
return true;
}
// Convert block to LLVM IR. Unless `ignoreArguments` is set, emit PHI nodes
// to define values corresponding to the MLIR block arguments. These nodes
// are not connected to the source basic blocks, which may not exist yet.
bool ModuleTranslation::convertBlock(const Block &bb, bool ignoreArguments) {
llvm::IRBuilder<> builder(blockMapping[&bb]);
// Before traversing instructions, make block arguments available through
// value remapping and PHI nodes, but do not add incoming edges for the PHI
// nodes just yet: those values may be defined by this or following blocks.
// This step is omitted if "ignoreArguments" is set. The arguments of the
// first block have been already made available through the remapping of
// LLVM function arguments.
if (!ignoreArguments) {
auto predecessors = bb.getPredecessors();
unsigned numPredecessors =
std::distance(predecessors.begin(), predecessors.end());
for (const auto *arg : bb.getArguments()) {
auto wrappedType = arg->getType().dyn_cast<LLVM::LLVMType>();
if (!wrappedType) {
arg->getType().getContext()->emitError(
bb.front().getLoc(), "block argument does not have an LLVM type");
return true;
}
llvm::Type *type = wrappedType.getUnderlyingType();
llvm::PHINode *phi = builder.CreatePHI(type, numPredecessors);
valueMapping[arg] = phi;
}
}
// Traverse instructions.
for (const auto &inst : bb) {
if (convertInstruction(inst, builder))
return true;
}
return false;
}
// Get the SSA value passed to the current block from the terminator instruction
// of its predecessor.
static const Value *getPHISourceValue(const Block *current, const Block *pred,
unsigned numArguments, unsigned index) {
auto &terminator = *pred->getTerminator();
if (terminator.isa<LLVM::BrOp>()) {
return terminator.getOperand(index);
}
// For conditional branches, we need to check if the current block is reached
// through the "true" or the "false" branch and take the relevant operands.
auto condBranchOp = terminator.dyn_cast<LLVM::CondBrOp>();
assert(condBranchOp &&
"only branch instructions can be terminators of a block that "
"has successors");
condBranchOp->emitError("NYI: conditional branches with arguments");
return nullptr;
}
void ModuleTranslation::connectPHINodes(const Function &func) {
// Skip the first block, it cannot be branched to and its arguments correspond
// to the arguments of the LLVM function.
for (auto it = std::next(func.begin()), eit = func.end(); it != eit; ++it) {
const Block *bb = &*it;
llvm::BasicBlock *llvmBB = blockMapping.lookup(bb);
auto phis = llvmBB->phis();
auto numArguments = bb->getNumArguments();
assert(numArguments == std::distance(phis.begin(), phis.end()));
for (auto &numberedPhiNode : llvm::enumerate(phis)) {
auto &phiNode = numberedPhiNode.value();
unsigned index = numberedPhiNode.index();
for (const auto *pred : bb->getPredecessors()) {
phiNode.addIncoming(valueMapping.lookup(getPHISourceValue(
bb, pred, numArguments, index)),
blockMapping.lookup(pred));
}
}
}
}
// TODO(mlir-team): implement an iterative version
static void topologicalSortImpl(llvm::SetVector<const Block *> &blocks,
const Block *b) {
blocks.insert(b);
for (const Block *bb : b->getSuccessors()) {
if (blocks.count(bb) == 0)
topologicalSortImpl(blocks, bb);
}
}
// Sort function blocks topologically.
static llvm::SetVector<const Block *> topologicalSort(const Function &f) {
// For each blocks that has not been visited yet (i.e. that has no
// predecessors), add it to the list and traverse its successors in DFS
// preorder.
llvm::SetVector<const Block *> blocks;
for (const Block &b : f.getBlocks()) {
if (blocks.count(&b) == 0)
topologicalSortImpl(blocks, &b);
}
assert(blocks.size() == f.getBlocks().size() && "some blocks are not sorted");
return blocks;
}
bool ModuleTranslation::convertOneFunction(const Function &func) {
// Clear the block and value mappings, they are only relevant within one
// function.
blockMapping.clear();
valueMapping.clear();
llvm::Function *llvmFunc = functionMapping.lookup(&func);
// Add function arguments to the value remapping table.
for (const auto &kvp : llvm::zip(func.getArguments(), llvmFunc->args())) {
valueMapping[std::get<0>(kvp)] = &std::get<1>(kvp);
}
// First, create all blocks so we can jump to them.
llvm::LLVMContext &llvmContext = llvmFunc->getContext();
for (const auto &bb : func) {
auto *llvmBB = llvm::BasicBlock::Create(llvmContext);
llvmBB->insertInto(llvmFunc);
blockMapping[&bb] = llvmBB;
}
// Then, convert blocks one by one in topological order to ensure defs are
// converted before uses.
auto blocks = topologicalSort(func);
for (auto indexedBB : llvm::enumerate(blocks)) {
const auto *bb = indexedBB.value();
if (convertBlock(*bb, /*ignoreArguments=*/indexedBB.index() == 0))
return true;
}
// Finally, after all blocks have been traversed and values mapped, connect
// the PHI nodes to the results of preceding blocks.
connectPHINodes(func);
return false;
}
bool ModuleTranslation::convertFunctions() {
// Declare all functions first because there may be function calls that form a
// call graph with cycles.
for (const Function &function : mlirModule) {
const Function *functionPtr = &function;
llvm::FunctionType *functionType = convertFunctionType(
llvmModule->getContext(), function.getType(), function.getLoc());
if (!functionType)
return true;
llvm::FunctionCallee llvmFuncCst =
llvmModule->getOrInsertFunction(function.getName(), functionType);
assert(isa<llvm::Function>(llvmFuncCst.getCallee()));
functionMapping[functionPtr] =
cast<llvm::Function>(llvmFuncCst.getCallee());
}
// Convert functions.
for (const Function &function : mlirModule) {
// Ignore external functions.
if (function.empty())
continue;
if (convertOneFunction(function))
return true;
}
return false;
}
std::unique_ptr<llvm::Module>
ModuleTranslation::translateModule(const Module &m) {
Dialect *dialect = m.getContext()->getRegisteredDialect("llvm");
assert(dialect && "LLVM dialect must be registered");
auto *llvmDialect = static_cast<LLVM::LLVMDialect *>(dialect);
auto llvmModule = llvm::CloneModule(llvmDialect->getLLVMModule());
if (!llvmModule)
return nullptr;
llvm::LLVMContext &llvmContext = llvmModule->getContext();
llvm::IRBuilder<> builder(llvmContext);
// Inject declarations for `malloc` and `free` functions that can be used in
// memref allocation/deallocation coming from standard ops lowering.
llvmModule->getOrInsertFunction("malloc", builder.getInt8PtrTy(),
builder.getInt64Ty());
llvmModule->getOrInsertFunction("free", builder.getVoidTy(),
builder.getInt8PtrTy());
ModuleTranslation translator(m);
translator.llvmModule = std::move(llvmModule);
if (translator.convertFunctions())
return nullptr;
return std::move(translator.llvmModule);
}
std::unique_ptr<llvm::Module> translateModuleToLLVMIR(const Module &m) {
return ModuleTranslation::translateModule(m);
}
static TranslateFromMLIRRegistration registration(
"mlir-to-llvmir", [](Module *module, llvm::StringRef outputFilename) {
if (!module)
return true;
auto llvmModule = ModuleTranslation::translateModule(*module);
if (!llvmModule)
return true;
auto file = openOutputFile(outputFilename);
if (!file)
return true;
llvmModule->print(file->os(), nullptr);
file->keep();
return false;
});
Reference in New Issue View Git Blame Copy Permalink