#include <string>
namespace mlir {
+class LowerToLLVMOptions;
+class ModuleOp;
+template <typename T>
+class OperationPass;
class Pass;
-#define GEN_PASS_DECL_CONVERTFUNCTOLLVMPASS
+#define GEN_PASS_DECL_CONVERTFUNCTOLLVM
#include "mlir/Conversion/Passes.h.inc"
+/// Creates a pass to convert the Func dialect into the LLVMIR dialect.
+std::unique_ptr<OperationPass<ModuleOp>> createConvertFuncToLLVMPass();
+std::unique_ptr<OperationPass<ModuleOp>>
+createConvertFuncToLLVMPass(const LowerToLLVMOptions &options);
+
} // namespace mlir
#endif // MLIR_CONVERSION_FUNCTOLLVM_CONVERTFUNCTOLLVMPASS_H_
// FuncToLLVM
//===----------------------------------------------------------------------===//
-def ConvertFuncToLLVMPass : Pass<"convert-func-to-llvm", "ModuleOp"> {
+def ConvertFuncToLLVM : Pass<"convert-func-to-llvm", "ModuleOp"> {
let summary = "Convert from the Func dialect to the LLVM dialect";
let description = [{
Convert Func dialect operations into the LLVM IR dialect operations.
returns are updated accordingly. Block argument types are updated to use
LLVM IR types.
}];
+ let constructor = "mlir::createConvertFuncToLLVMPass()";
let dependentDialects = ["LLVM::LLVMDialect"];
let options = [
Option<"useBarePtrCallConv", "use-bare-ptr-memref-call-conv", "bool",
#include <functional>
namespace mlir {
-#define GEN_PASS_DEF_CONVERTFUNCTOLLVMPASS
+#define GEN_PASS_DEF_CONVERTFUNCTOLLVM
#include "mlir/Conversion/Passes.h.inc"
} // namespace mlir
namespace {
/// A pass converting Func operations into the LLVM IR dialect.
struct ConvertFuncToLLVMPass
- : public impl::ConvertFuncToLLVMPassBase<ConvertFuncToLLVMPass> {
- using Base::Base;
+ : public impl::ConvertFuncToLLVMBase<ConvertFuncToLLVMPass> {
+ ConvertFuncToLLVMPass() = default;
+ ConvertFuncToLLVMPass(bool useBarePtrCallConv, unsigned indexBitwidth,
+ bool useAlignedAlloc,
+ const llvm::DataLayout &dataLayout) {
+ this->useBarePtrCallConv = useBarePtrCallConv;
+ this->indexBitwidth = indexBitwidth;
+ this->dataLayout = dataLayout.getStringRepresentation();
+ }
/// Run the dialect converter on the module.
void runOnOperation() override {
}
};
} // namespace
+
+std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertFuncToLLVMPass() {
+ return std::make_unique<ConvertFuncToLLVMPass>();
+}
+
+std::unique_ptr<OperationPass<ModuleOp>>
+mlir::createConvertFuncToLLVMPass(const LowerToLLVMOptions &options) {
+ auto allocLowering = options.allocLowering;
+ // There is no way to provide additional patterns for pass, so
+ // AllocLowering::None will always fail.
+ assert(allocLowering != LowerToLLVMOptions::AllocLowering::None &&
+ "ConvertFuncToLLVMPass doesn't support AllocLowering::None");
+ bool useAlignedAlloc =
+ (allocLowering == LowerToLLVMOptions::AllocLowering::AlignedAlloc);
+ return std::make_unique<ConvertFuncToLLVMPass>(
+ options.useBarePtrCallConv, options.getIndexBitwidth(), useAlignedAlloc,
+ options.dataLayout);
+}
MlirPassManager pm = mlirPassManagerCreate(ctx);
MlirOpPassManager opm = mlirPassManagerGetNestedUnder(
pm, mlirStringRefCreateFromCString("func.func"));
- mlirPassManagerAddOwnedPass(pm, mlirCreateConversionConvertFuncToLLVMPass());
+ mlirPassManagerAddOwnedPass(pm, mlirCreateConversionConvertFuncToLLVM());
mlirOpPassManagerAddOwnedPass(
opm, mlirCreateConversionArithToLLVMConversionPass());
MlirLogicalResult status = mlirPassManagerRun(pm, module);