forked from OSchip/llvm-project
Add transformation of the NVVM dialect to an LLVM module. Only handles
the generation of intrinsics out of NVVM index ops for now. -- PiperOrigin-RevId: 245933152
This commit is contained in:
Stephan Herhut
Mehdi Amini
parent
041e961802
commit
5d7231d812
|
|
@ -0,0 +1,98 @@
|
||||||
|
//===- ModuleTranslation.h - MLIR to LLVM 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 the translation between an MLIR LLVM dialect module and
|
||||||
|
// the corresponding LLVMIR module. It only handles core LLVM IR operations.
|
||||||
|
//
|
||||||
|
//===----------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
#ifndef MLIR_TARGET_LLVMIR_MODULETRANSLATION_H
|
||||||
|
#define MLIR_TARGET_LLVMIR_MODULETRANSLATION_H
|
||||||
|
|
||||||
|
#include "mlir/IR/Block.h"
|
||||||
|
#include "mlir/IR/Function.h"
|
||||||
|
#include "mlir/IR/Value.h"
|
||||||
|
|
||||||
|
#include "llvm/IR/BasicBlock.h"
|
||||||
|
#include "llvm/IR/Function.h"
|
||||||
|
#include "llvm/IR/IRBuilder.h"
|
||||||
|
#include "llvm/IR/Value.h"
|
||||||
|
|
||||||
|
namespace mlir {
|
||||||
|
class Attribute;
|
||||||
|
class Location;
|
||||||
|
class Module;
|
||||||
|
class Operation;
|
||||||
|
|
||||||
|
namespace LLVM {
|
||||||
|
|
||||||
|
// 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 operations
|
||||||
|
// needs to look up block and function mappings.
|
||||||
|
class ModuleTranslation {
|
||||||
|
public:
|
||||||
|
template <typename T = ModuleTranslation>
|
||||||
|
static std::unique_ptr<llvm::Module> translateModule(Module &m) {
|
||||||
|
auto llvmModule = prepareLLVMModule(m);
|
||||||
|
|
||||||
|
T translator(m);
|
||||||
|
translator.llvmModule = std::move(llvmModule);
|
||||||
|
if (translator.convertFunctions())
|
||||||
|
return nullptr;
|
||||||
|
|
||||||
|
return std::move(translator.llvmModule);
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
// 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.
|
||||||
|
explicit ModuleTranslation(Module &module) : mlirModule(module) {}
|
||||||
|
virtual ~ModuleTranslation() {}
|
||||||
|
|
||||||
|
virtual bool convertOperation(Operation &op, llvm::IRBuilder<> &builder);
|
||||||
|
static std::unique_ptr<llvm::Module> prepareLLVMModule(Module &m);
|
||||||
|
|
||||||
|
private:
|
||||||
|
|
||||||
|
bool convertFunctions();
|
||||||
|
bool convertOneFunction(Function &func);
|
||||||
|
void connectPHINodes(Function &func);
|
||||||
|
bool convertBlock(Block &bb, bool ignoreArguments);
|
||||||
|
|
||||||
|
template <typename Range>
|
||||||
|
SmallVector<llvm::Value *, 8> lookupValues(Range &&values);
|
||||||
|
|
||||||
|
llvm::Constant *getLLVMConstant(llvm::Type *llvmType, Attribute attr,
|
||||||
|
Location loc);
|
||||||
|
|
||||||
|
// Original and translated module.
|
||||||
|
Module &mlirModule;
|
||||||
|
std::unique_ptr<llvm::Module> llvmModule;
|
||||||
|
|
||||||
|
// Mappings between original and translated values, used for lookups.
|
||||||
|
llvm::DenseMap<Function *, llvm::Function *> functionMapping;
|
||||||
|
llvm::DenseMap<Value *, llvm::Value *> valueMapping;
|
||||||
|
llvm::DenseMap<Block *, llvm::BasicBlock *> blockMapping;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace LLVM
|
||||||
|
} // namespace mlir
|
||||||
|
|
||||||
|
#endif // MLIR_TARGET_LLVMIR_MODULETRANSLATION_H
|
||||||
|
|
@ -0,0 +1,45 @@
|
||||||
|
//===- NVVMIR.h - MLIR to LLVM + NVVM 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 declares the entry point for the MLIR to LLVM + NVVM IR conversion.
|
||||||
|
//
|
||||||
|
//===----------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
#ifndef MLIR_TARGET_NVVMIR_H
|
||||||
|
#define MLIR_TARGET_NVVMIR_H
|
||||||
|
|
||||||
|
#include <memory>
|
||||||
|
|
||||||
|
// Forward-declare LLVM classses.
|
||||||
|
namespace llvm {
|
||||||
|
class Module;
|
||||||
|
} // namespace llvm
|
||||||
|
|
||||||
|
namespace mlir {
|
||||||
|
|
||||||
|
class Module;
|
||||||
|
|
||||||
|
/// Convert the given MLIR module into NVVM IR. This conversion requires the
|
||||||
|
/// registration of the LLVM IR dialect and will extract the LLVM context
|
||||||
|
/// from the registered LLVM IR dialect. In case of error, report it
|
||||||
|
/// to the error handler registered with the MLIR context, if any (obtained from
|
||||||
|
/// the MLIR module), and return `nullptr`.
|
||||||
|
std::unique_ptr<llvm::Module> translateModuleToNVVMIR(Module &m);
|
||||||
|
|
||||||
|
} // namespace mlir
|
||||||
|
|
||||||
|
#endif // MLIR_TARGET_NVVMIR_H
|
||||||
|
|
@ -1 +1,25 @@
|
||||||
add_subdirectory(LLVMIR)
|
add_llvm_library(MLIRTargetLLVMIRModuleTranslation
|
||||||
|
LLVMIR/ModuleTranslation.cpp
|
||||||
|
|
||||||
|
ADDITIONAL_HEADER_DIRS
|
||||||
|
${MLIR_MAIN_INCLUDE_DIR}/mlir/Target/LLVMIR
|
||||||
|
DEPENDS
|
||||||
|
intrinsics_gen
|
||||||
|
)
|
||||||
|
target_link_libraries(MLIRTargetLLVMIRModuleTranslation MLIRLLVMIR LLVMCore LLVMSupport LLVMTransformUtils MLIRTranslation)
|
||||||
|
add_llvm_library(MLIRTargetLLVMIR
|
||||||
|
LLVMIR/ConvertToLLVMIR.cpp
|
||||||
|
|
||||||
|
ADDITIONAL_HEADER_DIRS
|
||||||
|
${MLIR_MAIN_INCLUDE_DIR}/mlir/Target/LLVMIR
|
||||||
|
)
|
||||||
|
target_link_libraries(MLIRTargetLLVMIR MLIRTargetLLVMIRModuleTranslation)
|
||||||
|
add_llvm_library(MLIRTargetNVVMIR
|
||||||
|
LLVMIR/ConvertToNVVMIR.cpp
|
||||||
|
|
||||||
|
ADDITIONAL_HEADER_DIRS
|
||||||
|
${MLIR_MAIN_INCLUDE_DIR}/mlir/Target/LLVMIR
|
||||||
|
DEPENDS
|
||||||
|
intrinsics_gen
|
||||||
|
)
|
||||||
|
target_link_libraries(MLIRTargetNVVMIR MLIRNVVMIR MLIRTargetLLVMIRModuleTranslation)
|
||||||
|
|
|
||||||
|
|
@ -1,9 +0,0 @@
|
||||||
add_llvm_library(MLIRTargetLLVMIR
|
|
||||||
ConvertToLLVMIR.cpp
|
|
||||||
|
|
||||||
ADDITIONAL_HEADER_DIRS
|
|
||||||
${MLIR_MAIN_INCLUDE_DIR}/mlir/Target/LLVMIR
|
|
||||||
DEPENDS
|
|
||||||
intrinsics_gen
|
|
||||||
)
|
|
||||||
target_link_libraries(MLIRTargetLLVMIR MLIRLLVMIR MLIRTranslation LLVMCore LLVMSupport LLVMTransformUtils)
|
|
||||||
|
|
@ -19,461 +19,20 @@
|
||||||
//
|
//
|
||||||
//===----------------------------------------------------------------------===//
|
//===----------------------------------------------------------------------===//
|
||||||
|
|
||||||
#include "mlir/IR/Attributes.h"
|
|
||||||
#include "mlir/IR/Module.h"
|
|
||||||
#include "mlir/LLVMIR/LLVMDialect.h"
|
|
||||||
#include "mlir/StandardOps/Ops.h"
|
|
||||||
#include "mlir/Support/FileUtilities.h"
|
|
||||||
#include "mlir/Support/LLVM.h"
|
|
||||||
#include "mlir/Target/LLVMIR.h"
|
#include "mlir/Target/LLVMIR.h"
|
||||||
|
|
||||||
|
#include "mlir/Support/FileUtilities.h"
|
||||||
|
#include "mlir/Target/LLVMIR/ModuleTranslation.h"
|
||||||
#include "mlir/Translation.h"
|
#include "mlir/Translation.h"
|
||||||
|
|
||||||
#include "llvm/ADT/SetVector.h"
|
#include "llvm/ADT/StringRef.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/IR/Module.h"
|
||||||
#include "llvm/Support/ToolOutputFile.h"
|
#include "llvm/Support/ToolOutputFile.h"
|
||||||
#include "llvm/Transforms/Utils/Cloning.h"
|
|
||||||
|
|
||||||
using namespace mlir;
|
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 operations
|
|
||||||
// needs to look up block and function mappings.
|
|
||||||
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(Module &m);
|
|
||||||
|
|
||||||
private:
|
|
||||||
explicit ModuleTranslation(Module &module) : mlirModule(module) {}
|
|
||||||
|
|
||||||
bool convertFunctions();
|
|
||||||
bool convertOneFunction(Function &func);
|
|
||||||
void connectPHINodes(Function &func);
|
|
||||||
bool convertBlock(Block &bb, bool ignoreArguments);
|
|
||||||
bool convertOperation(Operation &op, llvm::IRBuilder<> &builder);
|
|
||||||
|
|
||||||
template <typename Range>
|
|
||||||
SmallVector<llvm::Value *, 8> lookupValues(Range &&values);
|
|
||||||
|
|
||||||
llvm::Constant *getLLVMConstant(llvm::Type *llvmType, Attribute attr,
|
|
||||||
Location loc);
|
|
||||||
|
|
||||||
// Original and translated module.
|
|
||||||
Module &mlirModule;
|
|
||||||
std::unique_ptr<llvm::Module> llvmModule;
|
|
||||||
|
|
||||||
// Mappings between original and translated values, used for lookups.
|
|
||||||
llvm::DenseMap<Function *, llvm::Function *> functionMapping;
|
|
||||||
llvm::DenseMap<Value *, llvm::Value *> valueMapping;
|
|
||||||
llvm::DenseMap<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,
|
|
||||||
bool isVarArgs) {
|
|
||||||
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,
|
|
||||||
isVarArgs);
|
|
||||||
|
|
||||||
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, isVarArgs);
|
|
||||||
}
|
|
||||||
|
|
||||||
// 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");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// A helper to look up remapped operands in the value remapping table.
|
|
||||||
template <typename Range>
|
|
||||||
SmallVector<llvm::Value *, 8> ModuleTranslation::lookupValues(Range &&values) {
|
|
||||||
SmallVector<llvm::Value *, 8> remapped;
|
|
||||||
remapped.reserve(llvm::size(values));
|
|
||||||
for (Value *v : values) {
|
|
||||||
remapped.push_back(valueMapping.lookup(v));
|
|
||||||
}
|
|
||||||
return remapped;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Given a single MLIR operation, create the corresponding LLVM IR operation
|
|
||||||
// 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.
|
|
||||||
bool ModuleTranslation::convertOperation(Operation &opInst,
|
|
||||||
llvm::IRBuilder<> &builder) {
|
|
||||||
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;
|
|
||||||
};
|
|
||||||
|
|
||||||
#include "mlir/LLVMIR/LLVMConversions.inc"
|
|
||||||
|
|
||||||
// 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, &builder](Operation &op) -> llvm::Value * {
|
|
||||||
auto operands = lookupValues(op.getOperands());
|
|
||||||
ArrayRef<llvm::Value *> operandsRef(operands);
|
|
||||||
if (auto attr = op.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. Note that LLVM IR dialect CallOp has either 0 or 1 result.
|
|
||||||
if (opInst.isa<LLVM::CallOp>()) {
|
|
||||||
llvm::Value *result = convertCall(opInst);
|
|
||||||
if (opInst.getNumResults() != 0) {
|
|
||||||
valueMapping[opInst.getResult(0)] = result;
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
// Check that LLVM call returns void for 0-result functions.
|
|
||||||
return !result->getType()->isVoidTy();
|
|
||||||
}
|
|
||||||
|
|
||||||
// Emit branches. We need to look up the remapped blocks and ignore the block
|
|
||||||
// arguments that were transformed into PHI nodes.
|
|
||||||
if (auto brOp = opInst.dyn_cast<LLVM::BrOp>()) {
|
|
||||||
builder.CreateBr(blockMapping[brOp.getSuccessor(0)]);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
if (auto condbrOp = opInst.dyn_cast<LLVM::CondBrOp>()) {
|
|
||||||
builder.CreateCondBr(valueMapping.lookup(condbrOp.getOperand(0)),
|
|
||||||
blockMapping[condbrOp.getSuccessor(0)],
|
|
||||||
blockMapping[condbrOp.getSuccessor(1)]);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
opInst.emitError("unsupported or non-LLVM operation: " +
|
|
||||||
opInst.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(Block &bb, bool ignoreArguments) {
|
|
||||||
llvm::IRBuilder<> builder(blockMapping[&bb]);
|
|
||||||
|
|
||||||
// Before traversing operations, 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 (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 operations.
|
|
||||||
for (auto &op : bb) {
|
|
||||||
if (convertOperation(op, builder))
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get the SSA value passed to the current block from the terminator operation
|
|
||||||
// of its predecessor.
|
|
||||||
static Value *getPHISourceValue(Block *current, 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 operations can be terminators of a block that "
|
|
||||||
"has successors");
|
|
||||||
assert((condBranchOp.getSuccessor(0) != condBranchOp.getSuccessor(1)) &&
|
|
||||||
"successors with arguments in LLVM conditional branches must be "
|
|
||||||
"different blocks");
|
|
||||||
|
|
||||||
return condBranchOp.getSuccessor(0) == current
|
|
||||||
? terminator.getSuccessorOperand(0, index)
|
|
||||||
: terminator.getSuccessorOperand(1, index);
|
|
||||||
}
|
|
||||||
|
|
||||||
void ModuleTranslation::connectPHINodes(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) {
|
|
||||||
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 (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<Block *> &blocks, Block *b) {
|
|
||||||
blocks.insert(b);
|
|
||||||
for (Block *bb : b->getSuccessors()) {
|
|
||||||
if (blocks.count(bb) == 0)
|
|
||||||
topologicalSortImpl(blocks, bb);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Sort function blocks topologically.
|
|
||||||
static llvm::SetVector<Block *> topologicalSort(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<Block *> blocks;
|
|
||||||
for (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(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.
|
|
||||||
// If there was noalias info then we decorate each argument accordingly.
|
|
||||||
unsigned int argIdx = 0;
|
|
||||||
for (const auto &kvp : llvm::zip(func.getArguments(), llvmFunc->args())) {
|
|
||||||
llvm::Argument &llvmArg = std::get<1>(kvp);
|
|
||||||
BlockArgument *mlirArg = std::get<0>(kvp);
|
|
||||||
|
|
||||||
if (auto attr = func.getArgAttrOfType<BoolAttr>(argIdx, "llvm.noalias")) {
|
|
||||||
// NB: Attribute already verified to be boolean, so check if we can indeed
|
|
||||||
// attach the attribute to this argument, based on its type.
|
|
||||||
auto argTy = mlirArg->getType().dyn_cast<LLVM::LLVMType>();
|
|
||||||
if (!argTy.getUnderlyingType()->isPointerTy())
|
|
||||||
return argTy.getContext()->emitError(
|
|
||||||
func.getLoc(),
|
|
||||||
"llvm.noalias attribute attached to LLVM non-pointer argument");
|
|
||||||
if (attr.getValue())
|
|
||||||
llvmArg.addAttr(llvm::Attribute::AttrKind::NoAlias);
|
|
||||||
}
|
|
||||||
valueMapping[mlirArg] = &llvmArg;
|
|
||||||
argIdx++;
|
|
||||||
}
|
|
||||||
|
|
||||||
// First, create all blocks so we can jump to them.
|
|
||||||
llvm::LLVMContext &llvmContext = llvmFunc->getContext();
|
|
||||||
for (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)) {
|
|
||||||
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 (Function &function : mlirModule) {
|
|
||||||
Function *functionPtr = &function;
|
|
||||||
mlir::BoolAttr isVarArgsAttr =
|
|
||||||
function.getAttrOfType<BoolAttr>("std.varargs");
|
|
||||||
bool isVarArgs = isVarArgsAttr && isVarArgsAttr.getValue();
|
|
||||||
llvm::FunctionType *functionType =
|
|
||||||
convertFunctionType(llvmModule->getContext(), function.getType(),
|
|
||||||
function.getLoc(), isVarArgs);
|
|
||||||
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 (Function &function : mlirModule) {
|
|
||||||
// Ignore external functions.
|
|
||||||
if (function.isExternal())
|
|
||||||
continue;
|
|
||||||
|
|
||||||
if (convertOneFunction(function))
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::unique_ptr<llvm::Module> ModuleTranslation::translateModule(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> mlir::translateModuleToLLVMIR(Module &m) {
|
std::unique_ptr<llvm::Module> mlir::translateModuleToLLVMIR(Module &m) {
|
||||||
return ModuleTranslation::translateModule(m);
|
return LLVM::ModuleTranslation::translateModule<>(m);
|
||||||
}
|
}
|
||||||
|
|
||||||
static TranslateFromMLIRRegistration registration(
|
static TranslateFromMLIRRegistration registration(
|
||||||
|
|
@ -481,7 +40,7 @@ static TranslateFromMLIRRegistration registration(
|
||||||
if (!module)
|
if (!module)
|
||||||
return true;
|
return true;
|
||||||
|
|
||||||
auto llvmModule = ModuleTranslation::translateModule(*module);
|
auto llvmModule = LLVM::ModuleTranslation::translateModule<>(*module);
|
||||||
if (!llvmModule)
|
if (!llvmModule)
|
||||||
return true;
|
return true;
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,84 @@
|
||||||
|
//===- ConvertToNVVMIR.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 + NVVM dialects and
|
||||||
|
// LLVM IR with NVVM intrinsics and metadata.
|
||||||
|
//
|
||||||
|
//===----------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
#include "mlir/Target/NVVMIR.h"
|
||||||
|
|
||||||
|
#include "mlir/LLVMIR/NVVMDialect.h"
|
||||||
|
#include "mlir/Support/FileUtilities.h"
|
||||||
|
#include "mlir/Target/LLVMIR/ModuleTranslation.h"
|
||||||
|
#include "mlir/Translation.h"
|
||||||
|
|
||||||
|
#include "llvm/ADT/StringRef.h"
|
||||||
|
#include "llvm/IR/Module.h"
|
||||||
|
#include "llvm/Support/ToolOutputFile.h"
|
||||||
|
|
||||||
|
using namespace mlir;
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
static void createIntrinsicCall(llvm::IRBuilder<> &builder,
|
||||||
|
llvm::Intrinsic::ID intrinsic) {
|
||||||
|
llvm::Module *module = builder.GetInsertBlock()->getModule();
|
||||||
|
llvm::Function *fn = llvm::Intrinsic::getDeclaration(module, intrinsic, {});
|
||||||
|
builder.CreateCall(fn);
|
||||||
|
}
|
||||||
|
|
||||||
|
class ModuleTranslation : public LLVM::ModuleTranslation {
|
||||||
|
|
||||||
|
public:
|
||||||
|
explicit ModuleTranslation(Module &module)
|
||||||
|
: LLVM::ModuleTranslation(module) {}
|
||||||
|
~ModuleTranslation() override {}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
bool convertOperation(Operation &opInst,
|
||||||
|
llvm::IRBuilder<> &builder) override {
|
||||||
|
|
||||||
|
#include "mlir/LLVMIR/NVVMConversions.inc"
|
||||||
|
|
||||||
|
return LLVM::ModuleTranslation::convertOperation(opInst, builder);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
std::unique_ptr<llvm::Module> mlir::translateModuleToNVVMIR(Module &m) {
|
||||||
|
ModuleTranslation translation(m);
|
||||||
|
return LLVM::ModuleTranslation::translateModule<ModuleTranslation>(m);
|
||||||
|
}
|
||||||
|
|
||||||
|
static TranslateFromMLIRRegistration registration(
|
||||||
|
"mlir-to-nvvmir", [](Module *module, llvm::StringRef outputFilename) {
|
||||||
|
if (!module)
|
||||||
|
return true;
|
||||||
|
|
||||||
|
auto llvmModule =
|
||||||
|
LLVM::ModuleTranslation::translateModule<ModuleTranslation>(*module);
|
||||||
|
if (!llvmModule)
|
||||||
|
return true;
|
||||||
|
|
||||||
|
auto file = openOutputFile(outputFilename);
|
||||||
|
if (!file)
|
||||||
|
return true;
|
||||||
|
|
||||||
|
llvmModule->print(file->os(), nullptr);
|
||||||
|
file->keep();
|
||||||
|
return false;
|
||||||
|
});
|
||||||
|
|
@ -0,0 +1,432 @@
|
||||||
|
//===- ModuleTranslation.cpp - MLIR to LLVM 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 the translation between an MLIR LLVM dialect module and
|
||||||
|
// the corresponding LLVMIR module. It only handles core LLVM IR operations.
|
||||||
|
//
|
||||||
|
//===----------------------------------------------------------------------===//
|
||||||
|
|
||||||
|
#include "mlir/Target/LLVMIR/ModuleTranslation.h"
|
||||||
|
|
||||||
|
#include "mlir/IR/Attributes.h"
|
||||||
|
#include "mlir/IR/Module.h"
|
||||||
|
#include "mlir/LLVMIR/LLVMDialect.h"
|
||||||
|
#include "mlir/StandardOps/Ops.h"
|
||||||
|
#include "mlir/Support/LLVM.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/Transforms/Utils/Cloning.h"
|
||||||
|
|
||||||
|
namespace mlir {
|
||||||
|
namespace LLVM {
|
||||||
|
|
||||||
|
// 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,
|
||||||
|
bool isVarArgs) {
|
||||||
|
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,
|
||||||
|
isVarArgs);
|
||||||
|
|
||||||
|
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, isVarArgs);
|
||||||
|
}
|
||||||
|
|
||||||
|
// 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");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// A helper to look up remapped operands in the value remapping table.
|
||||||
|
template <typename Range>
|
||||||
|
SmallVector<llvm::Value *, 8> ModuleTranslation::lookupValues(Range &&values) {
|
||||||
|
SmallVector<llvm::Value *, 8> remapped;
|
||||||
|
remapped.reserve(llvm::size(values));
|
||||||
|
for (Value *v : values) {
|
||||||
|
remapped.push_back(valueMapping.lookup(v));
|
||||||
|
}
|
||||||
|
return remapped;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Given a single MLIR operation, create the corresponding LLVM IR operation
|
||||||
|
// 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.
|
||||||
|
bool ModuleTranslation::convertOperation(Operation &opInst,
|
||||||
|
llvm::IRBuilder<> &builder) {
|
||||||
|
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;
|
||||||
|
};
|
||||||
|
|
||||||
|
#include "mlir/LLVMIR/LLVMConversions.inc"
|
||||||
|
|
||||||
|
// 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, &builder](Operation &op) -> llvm::Value * {
|
||||||
|
auto operands = lookupValues(op.getOperands());
|
||||||
|
ArrayRef<llvm::Value *> operandsRef(operands);
|
||||||
|
if (auto attr = op.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. Note that LLVM IR dialect CallOp has either 0 or 1 result.
|
||||||
|
if (opInst.isa<LLVM::CallOp>()) {
|
||||||
|
llvm::Value *result = convertCall(opInst);
|
||||||
|
if (opInst.getNumResults() != 0) {
|
||||||
|
valueMapping[opInst.getResult(0)] = result;
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
// Check that LLVM call returns void for 0-result functions.
|
||||||
|
return !result->getType()->isVoidTy();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Emit branches. We need to look up the remapped blocks and ignore the block
|
||||||
|
// arguments that were transformed into PHI nodes.
|
||||||
|
if (auto brOp = opInst.dyn_cast<LLVM::BrOp>()) {
|
||||||
|
builder.CreateBr(blockMapping[brOp.getSuccessor(0)]);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if (auto condbrOp = opInst.dyn_cast<LLVM::CondBrOp>()) {
|
||||||
|
builder.CreateCondBr(valueMapping.lookup(condbrOp.getOperand(0)),
|
||||||
|
blockMapping[condbrOp.getSuccessor(0)],
|
||||||
|
blockMapping[condbrOp.getSuccessor(1)]);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
opInst.emitError("unsupported or non-LLVM operation: " +
|
||||||
|
opInst.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(Block &bb, bool ignoreArguments) {
|
||||||
|
llvm::IRBuilder<> builder(blockMapping[&bb]);
|
||||||
|
|
||||||
|
// Before traversing operations, 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 (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 operations.
|
||||||
|
for (auto &op : bb) {
|
||||||
|
if (convertOperation(op, builder))
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the SSA value passed to the current block from the terminator operation
|
||||||
|
// of its predecessor.
|
||||||
|
static Value *getPHISourceValue(Block *current, 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 operations can be terminators of a block that "
|
||||||
|
"has successors");
|
||||||
|
assert((condBranchOp.getSuccessor(0) != condBranchOp.getSuccessor(1)) &&
|
||||||
|
"successors with arguments in LLVM conditional branches must be "
|
||||||
|
"different blocks");
|
||||||
|
|
||||||
|
return condBranchOp.getSuccessor(0) == current
|
||||||
|
? terminator.getSuccessorOperand(0, index)
|
||||||
|
: terminator.getSuccessorOperand(1, index);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ModuleTranslation::connectPHINodes(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) {
|
||||||
|
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 (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<Block *> &blocks, Block *b) {
|
||||||
|
blocks.insert(b);
|
||||||
|
for (Block *bb : b->getSuccessors()) {
|
||||||
|
if (blocks.count(bb) == 0)
|
||||||
|
topologicalSortImpl(blocks, bb);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Sort function blocks topologically.
|
||||||
|
static llvm::SetVector<Block *> topologicalSort(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<Block *> blocks;
|
||||||
|
for (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(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.
|
||||||
|
// If there was noalias info then we decorate each argument accordingly.
|
||||||
|
unsigned int argIdx = 0;
|
||||||
|
for (const auto &kvp : llvm::zip(func.getArguments(), llvmFunc->args())) {
|
||||||
|
llvm::Argument &llvmArg = std::get<1>(kvp);
|
||||||
|
BlockArgument *mlirArg = std::get<0>(kvp);
|
||||||
|
|
||||||
|
if (auto attr = func.getArgAttrOfType<BoolAttr>(argIdx, "llvm.noalias")) {
|
||||||
|
// NB: Attribute already verified to be boolean, so check if we can indeed
|
||||||
|
// attach the attribute to this argument, based on its type.
|
||||||
|
auto argTy = mlirArg->getType().dyn_cast<LLVM::LLVMType>();
|
||||||
|
if (!argTy.getUnderlyingType()->isPointerTy())
|
||||||
|
return argTy.getContext()->emitError(
|
||||||
|
func.getLoc(),
|
||||||
|
"llvm.noalias attribute attached to LLVM non-pointer argument");
|
||||||
|
if (attr.getValue())
|
||||||
|
llvmArg.addAttr(llvm::Attribute::AttrKind::NoAlias);
|
||||||
|
}
|
||||||
|
valueMapping[mlirArg] = &llvmArg;
|
||||||
|
argIdx++;
|
||||||
|
}
|
||||||
|
|
||||||
|
// First, create all blocks so we can jump to them.
|
||||||
|
llvm::LLVMContext &llvmContext = llvmFunc->getContext();
|
||||||
|
for (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)) {
|
||||||
|
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 (Function &function : mlirModule) {
|
||||||
|
Function *functionPtr = &function;
|
||||||
|
mlir::BoolAttr isVarArgsAttr =
|
||||||
|
function.getAttrOfType<BoolAttr>("std.varargs");
|
||||||
|
bool isVarArgs = isVarArgsAttr && isVarArgsAttr.getValue();
|
||||||
|
llvm::FunctionType *functionType =
|
||||||
|
convertFunctionType(llvmModule->getContext(), function.getType(),
|
||||||
|
function.getLoc(), isVarArgs);
|
||||||
|
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 (Function &function : mlirModule) {
|
||||||
|
// Ignore external functions.
|
||||||
|
if (function.isExternal())
|
||||||
|
continue;
|
||||||
|
|
||||||
|
if (convertOneFunction(function))
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::unique_ptr<llvm::Module> ModuleTranslation::prepareLLVMModule(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());
|
||||||
|
|
||||||
|
return llvmModule;
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace LLVM
|
||||||
|
} // namespace mlir
|
||||||
|
|
@ -0,0 +1,29 @@
|
||||||
|
// RUN: mlir-translate -mlir-to-nvvmir %s | FileCheck %s
|
||||||
|
|
||||||
|
func @nvvm_special_regs() -> !llvm.i32 {
|
||||||
|
// CHECK: %1 = call i32 @llvm.nvvm.read.ptx.sreg.tid.x()
|
||||||
|
%1 = nvvm.read.ptx.sreg.tid.x : !llvm.i32
|
||||||
|
// CHECK: %2 = call i32 @llvm.nvvm.read.ptx.sreg.tid.y()
|
||||||
|
%2 = nvvm.read.ptx.sreg.tid.y : !llvm.i32
|
||||||
|
// CHECK: %3 = call i32 @llvm.nvvm.read.ptx.sreg.tid.z()
|
||||||
|
%3 = nvvm.read.ptx.sreg.tid.z : !llvm.i32
|
||||||
|
// CHECK: %4 = call i32 @llvm.nvvm.read.ptx.sreg.ntid.x()
|
||||||
|
%4 = nvvm.read.ptx.sreg.ntid.x : !llvm.i32
|
||||||
|
// CHECK: %5 = call i32 @llvm.nvvm.read.ptx.sreg.ntid.y()
|
||||||
|
%5 = nvvm.read.ptx.sreg.ntid.y : !llvm.i32
|
||||||
|
// CHECK: %6 = call i32 @llvm.nvvm.read.ptx.sreg.ntid.z()
|
||||||
|
%6 = nvvm.read.ptx.sreg.ntid.z : !llvm.i32
|
||||||
|
// CHECK: %7 = call i32 @llvm.nvvm.read.ptx.sreg.ctaid.x()
|
||||||
|
%7 = nvvm.read.ptx.sreg.ctaid.x : !llvm.i32
|
||||||
|
// CHECK: %8 = call i32 @llvm.nvvm.read.ptx.sreg.ctaid.y()
|
||||||
|
%8 = nvvm.read.ptx.sreg.ctaid.y : !llvm.i32
|
||||||
|
// CHECK: %9 = call i32 @llvm.nvvm.read.ptx.sreg.ctaid.z()
|
||||||
|
%9 = nvvm.read.ptx.sreg.ctaid.z : !llvm.i32
|
||||||
|
// CHECK: %10 = call i32 @llvm.nvvm.read.ptx.sreg.nctaid.x()
|
||||||
|
%10 = nvvm.read.ptx.sreg.nctaid.x : !llvm.i32
|
||||||
|
// CHECK: %11 = call i32 @llvm.nvvm.read.ptx.sreg.nctaid.y()
|
||||||
|
%11 = nvvm.read.ptx.sreg.nctaid.y : !llvm.i32
|
||||||
|
// CHECK: %12 = call i32 @llvm.nvvm.read.ptx.sreg.nctaid.z()
|
||||||
|
%12 = nvvm.read.ptx.sreg.nctaid.z : !llvm.i32
|
||||||
|
llvm.return %1 : !llvm.i32
|
||||||
|
}
|
||||||
|
|
@ -5,6 +5,7 @@ set(LIBS
|
||||||
MLIRExecutionEngine
|
MLIRExecutionEngine
|
||||||
MLIRIR
|
MLIRIR
|
||||||
MLIRParser
|
MLIRParser
|
||||||
|
MLIRTargetLLVMIR
|
||||||
MLIRTransforms
|
MLIRTransforms
|
||||||
MLIRSupport
|
MLIRSupport
|
||||||
LLVMCore
|
LLVMCore
|
||||||
|
|
|
||||||
|
|
@ -6,6 +6,7 @@ set(LIBS
|
||||||
MLIRPass
|
MLIRPass
|
||||||
MLIRStandardOps
|
MLIRStandardOps
|
||||||
MLIRTargetLLVMIR
|
MLIRTargetLLVMIR
|
||||||
|
MLIRTargetNVVMIR
|
||||||
MLIRTransforms
|
MLIRTransforms
|
||||||
MLIRTranslation
|
MLIRTranslation
|
||||||
MLIRSupport
|
MLIRSupport
|
||||||
|
|
|
||||||
|
|
@ -73,7 +73,7 @@ using TranslateFunction =
|
||||||
std::function<bool(StringRef, StringRef, MLIRContext *)>;
|
std::function<bool(StringRef, StringRef, MLIRContext *)>;
|
||||||
|
|
||||||
// Storage for the translation function wrappers that survive the parser.
|
// Storage for the translation function wrappers that survive the parser.
|
||||||
static llvm::SmallVector<TranslateFunction, 8> wrapperStorage;
|
static llvm::SmallVector<TranslateFunction, 16> wrapperStorage;
|
||||||
|
|
||||||
// Custom parser for TranslateFunction.
|
// Custom parser for TranslateFunction.
|
||||||
// Wraps TranslateToMLIRFunctions and TranslateFromMLIRFunctions into
|
// Wraps TranslateToMLIRFunctions and TranslateFromMLIRFunctions into
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue