[mlir] StandardToLLVM: option to disable AllocOp lowering

[bondhugula]

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h

47

User must provide his -> Users must provide their

[bondhugula]

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

4147

Can you please add an assertion message?

[Hardcode84]

review comments

[Hardcode84]

rebase, rerun tests

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h

 class LowerToLLVMOptions {
 public:
   explicit LowerToLLVMOptions(MLIRContext *ctx);
   explicit LowerToLLVMOptions(MLIRContext *ctx, DataLayout dl);
 
   bool useBarePtrCallConv = false;
   bool emitCWrappers = false;
 
+  enum class AllocLowering {
+    /// Use malloc for for heap allocations.
+    Malloc,
+
     /// Use aligned_alloc for heap allocations.
-  bool useAlignedAlloc = false;
+    AlignedAlloc,
+
+    /// Do not lower heap allocations. Users must provide their own patterns for
+    /// AllocOp and DeallocOp lowering.
+    None
+  };
+
+  AllocLowering allocLowering = AllocLowering::Malloc;
 
   /// The data layout of the module to produce. This must be consistent with the
   /// data layout used in the upper levels of the lowering pipeline.
   // TODO: this should be replaced by MLIR data layout when one exists.
   llvm::DataLayout dataLayout = llvm::DataLayout("");
 
   /// Set the index bitwidth to the given value.
   void overrideIndexBitwidth(unsigned bitwidth) {

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

void mlir::populateStdToLLVMNonMemoryConversionPatterns(
   // clang-format on
 }
 
 void mlir::populateStdToLLVMMemoryConversionPatterns(
     LLVMTypeConverter &converter, RewritePatternSet &patterns) {
   // clang-format off
   patterns.add<
       AssumeAlignmentOpLowering,
-      DeallocOpLowering,
       DimOpLowering,
       GlobalMemrefOpLowering,
       GetGlobalMemrefOpLowering,
       LoadOpLowering,
       MemRefCastOpLowering,
       MemRefReinterpretCastOpLowering,
       MemRefReshapeOpLowering,
       RankOpLowering,
       StoreOpLowering,
       SubViewOpLowering,
       TransposeOpLowering,
       ViewOpLowering>(converter);
   // clang-format on
-  if (converter.getOptions().useAlignedAlloc)
-    patterns.add<AlignedAllocOpLowering>(converter);
-  else
-    patterns.add<AllocOpLowering>(converter);
+  auto allocLowering = converter.getOptions().allocLowering;
+  if (allocLowering == LowerToLLVMOptions::AllocLowering::AlignedAlloc)
+    patterns.add<AlignedAllocOpLowering, DeallocOpLowering>(converter);
+  else if (allocLowering == LowerToLLVMOptions::AllocLowering::Malloc)
+    patterns.add<AllocOpLowering, DeallocOpLowering>(converter);
 }
 
 void mlir::populateStdToLLVMFuncOpConversionPattern(
     LLVMTypeConverter &converter, RewritePatternSet &patterns) {
   if (converter.getOptions().useBarePtrCallConv)
     patterns.add<BarePtrFuncOpConversion>(converter);
   else
     patterns.add<FuncOpConversion>(converter);
void runOnOperation() override {
 
     ModuleOp m = getOperation();
 
     LowerToLLVMOptions options(&getContext(), DataLayout(m));
     options.useBarePtrCallConv = useBarePtrCallConv;
     options.emitCWrappers = emitCWrappers;
     if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout)
       options.overrideIndexBitwidth(indexBitwidth);
-    options.useAlignedAlloc = useAlignedAlloc;
+    options.allocLowering =
+        (useAlignedAlloc ? LowerToLLVMOptions::AllocLowering::AlignedAlloc
+                         : LowerToLLVMOptions::AllocLowering::Malloc);
     options.dataLayout = llvm::DataLayout(this->dataLayout);
     LLVMTypeConverter typeConverter(&getContext(), options);
 
     RewritePatternSet patterns(&getContext());
     populateStdToLLVMConversionPatterns(typeConverter, patterns);
 
     LLVMConversionTarget target(getContext());
     if (failed(applyPartialConversion(m, target, std::move(patterns))))

 }
 
 std::unique_ptr<OperationPass<ModuleOp>> mlir::createLowerToLLVMPass() {
   return std::make_unique<LLVMLoweringPass>();
 }
 
 std::unique_ptr<OperationPass<ModuleOp>>
 mlir::createLowerToLLVMPass(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 &&
+         "LLVMLoweringPass doesn't support AllocLowering::None");
+  bool useAlignedAlloc =
+      (allocLowering == LowerToLLVMOptions::AllocLowering::AlignedAlloc);
   return std::make_unique<LLVMLoweringPass>(
       options.useBarePtrCallConv, options.emitCWrappers,
-      options.getIndexBitwidth(), options.useAlignedAlloc, options.dataLayout);
+      options.getIndexBitwidth(), useAlignedAlloc, options.dataLayout);
 }
 
 mlir::LowerToLLVMOptions::LowerToLLVMOptions(MLIRContext *ctx)
     : LowerToLLVMOptions(ctx, DataLayout()) {}
 
 mlir::LowerToLLVMOptions::LowerToLLVMOptions(MLIRContext *ctx,
                                              mlir::DataLayout dl) {
   indexBitwidth = dl.getTypeSizeInBits(IndexType::get(ctx));
 }