[mlir][OneShotModuleBufferize] Add a new flag: no-analysis-func-filter

[mamrami]

Summary

OneShotModuleBufferize fails if the input IR cannot be analyzed.
One can set CopyBeforeWrite=true in order to skip analysis.
In that case, a buffer copy is inserted on every write.
This leads to many copies, also in FuncOps that could be analyzed.

This change aims to copy buffers only when it is a must.
When running OneShotModuleBufferize with CopyBeforeWrite=false,
FuncOps whose names are specified in noAnalysisFuncFilter will not be
analyzed. Ops in these FuncOps will not be analyzed as well.
They will be bufferized with CopyBeforeWrite=true,
while the other ops will be bufferized with CopyBeforeWrite=false.

[mamrami]

edit title

[springerm]

Instead of collecting FuncOps that could not be bufferized, can we pass a list of excluded FuncOps to the bufferization? Does that work in your flow?

We already have some infrastructure for that: BufferizationOptions::isOpAllowed. It returns false for ops that are excluded from the bufferization. I think it currently has no effect for FuncOps. Then you can bufferize with One-Shot Bufferize first, excluding all FuncOps of which you know that they cannot be bufferized. Then run the bufferization with copyBeforeWrite = true on all excluded FuncOps.

I think only small changes to mlir::bufferization::bufferizeModuleOp, mlir::bufferization::analyzeModuleOp and mlir::bufferization::insertTensorCopies should be needed.

mlir/lib/Dialect/Bufferization/Transforms/OneShotAnalysis.cpp

1007

Ideally, no changes are needed to this file.

mlir/lib/Dialect/Bufferization/Transforms/OneShotModuleBufferize.cpp

384

Put a check here:

if (!state.getOptions().isOpAllowed(funcOp)) continue;

[mamrami]

Addressing code review

[mamrami]

Then you can bufferize with One-Shot Bufferize first, excluding all FuncOps of which you know that they cannot be bufferized. Then run the bufferization with copyBeforeWrite = true on all excluded FuncOps.

There are cases where a function is called by another function, so bufferizing the caller is impossible when the callee is excluded.
Now the bufferization happens once on the entire IR so I don't have this problem.

mlir/include/mlir/Dialect/Bufferization/Transforms/OneShotModuleBufferize.h

 //===- OneShotModuleBufferize.h - Bufferization across Func. Boundaries ---===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_ONESHOTMODULEBUFFERIZE_H
 #define MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_ONESHOTMODULEBUFFERIZE_H
 
+#include "llvm/ADT/SmallSet.h"
 namespace mlir {
 
 struct LogicalResult;
 class ModuleOp;
+namespace func {
+class FuncOp;
+}
 
 namespace bufferization {
 struct BufferizationStatistics;
 class OneShotAnalysisState;
 struct OneShotBufferizationOptions;
 
 /// Analyze `moduleOp` and its nested ops. Bufferization decisions are stored in
-/// `state`.
-LogicalResult analyzeModuleOp(ModuleOp moduleOp, OneShotAnalysisState &state,
-                              BufferizationStatistics *statistics = nullptr);
+/// `state`. If the analysis of a FuncOp fails, it is inserted to
+/// `notAnalyzedFuncOps`.
+LogicalResult
+analyzeModuleOp(ModuleOp moduleOp, OneShotAnalysisState &state,
+                BufferizationStatistics *statistics = nullptr,
+                llvm::SmallSet<func::FuncOp, 8> *notAnalyzedFuncOps = nullptr);
 
 /// Bufferize `op` and its nested ops that implement `BufferizableOpInterface`.
 ///
 /// Note: This function does not run One-Shot Analysis. No buffer copies are
-/// inserted unless `options.copyBeforeWrite` is set, in which case buffers are
-/// copied before every write.
-LogicalResult bufferizeModuleOp(ModuleOp moduleOp,
-                                const OneShotBufferizationOptions &options,
-                                BufferizationStatistics *statistics = nullptr);
+/// inserted except two cases:
+/// - `options.copyBeforeWrite` is set, in which case buffers are copied before
+///   every write.
+/// - `options.copyBeforeWrite` is not set and `notAnalyzedFuncOps` contains
+///   FuncOps. These FuncOps were not analyzed. Buffer copies will be inserted
+///   only to these FuncOps.
+LogicalResult
+bufferizeModuleOp(ModuleOp moduleOp, const OneShotBufferizationOptions &options,
+                  llvm::SmallSet<func::FuncOp, 8> &notAnalyzedFuncOps,
 
 /// Remove bufferization attributes on every FuncOp arguments in the ModuleOp.
 void removeBufferizationAttributesInModule(ModuleOp moduleOp);
 
 /// Run One-Shot Module Bufferization on the given module. Performs a simple
 /// function call analysis to determine which function arguments are
 /// inplaceable. Then analyzes and bufferizes FuncOps one-by-one with One-Shot
 /// Bufferize.

mlir/include/mlir/Dialect/Bufferization/Transforms/Transforms.h

 //===- Transforms.h - Bufferization and related transforms ------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_TRANSFORMS_H
 #define MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_TRANSFORMS_H
 
 #include "mlir/Dialect/Bufferization/Transforms/OneShotAnalysis.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/Operation.h"
+#include "llvm/ADT/SmallSet.h"
 
 namespace mlir {
 namespace bufferization {
 class AnalysisState;
 struct BufferizationStatistics;
 struct OneShotBufferizationOptions;
 
 /// A function that matches anchor OpOperands for tensor::EmptyOp elimination.

 /// Try to eliminate tensor::EmptyOps inside `op` that are anchored on an
 /// InsertSliceOp, i.e., if it is eventually inserted into another tensor
 /// (and some other conditions are met).
 LogicalResult insertSliceAnchoredEmptyTensorEliminationStep(
     RewriterBase &rewriter, Operation *op, bufferization::AnalysisState &state);
 
 /// Resolve RaW and other conflicts by inserting bufferization.alloc_tensor ops.
 /// After applying this transform, the IR can be bufferized without inserting
-/// additional buffer allocations.
-LogicalResult insertTensorCopies(Operation *op,
-                                 const OneShotBufferizationOptions &options,
-                                 BufferizationStatistics *statistics = nullptr);
+/// additional buffer allocations. `notAnalyzedFuncOps` holds the FuncOps that
+/// could not be analyzed.
+LogicalResult insertTensorCopies(
+    Operation *op, const OneShotBufferizationOptions &options,
+    BufferizationStatistics *statistics = nullptr,
+    llvm::SmallSet<func::FuncOp, 8> *notAnalyzedFuncOps = nullptr);
 
 /// Resolve RaW and other conflicts by inserting bufferization.alloc_tensor ops.
 /// After applying this transform, the IR can be bufferized without inserting
 /// additional buffer allocations.
 LogicalResult insertTensorCopies(Operation *op, const AnalysisState &state);
 
 /// Populate patterns to lower tensor.empty ops to bufferization.alloc_tensor
 /// ops.
 void populateEmptyTensorToAllocTensorPattern(RewritePatternSet &patterns);
 
 } // namespace bufferization
 } // namespace mlir
 
 #endif // MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_TRANSFORMS_H

mlir/lib/Dialect/Bufferization/Transforms/OneShotAnalysis.cpp

op->walk<WalkOrder::PostOrder>([&](Operation *op) {
     if (none_of(op->getResultTypes(), isaTensor))
       return;
     ops.push_back(op);
   });
 
   equivalenceAnalysis(ops, aliasInfo, state);
 }
 
-/// Assert that the current bufferization decisions are consistent.
+/// Return success if the current bufferization decisions are consistent.
 static LogicalResult
 checkAliasInfoConsistency(Operation *op, const DominanceInfo &domInfo,
                           AnalysisState &state,
                           const BufferizationAliasInfo &aliasInfo) {
   const BufferizationOptions &options = state.getOptions();
 
   WalkResult walkResult = op->walk([&](BufferizableOpInterface op) {
     // Skip ops that are not in the filter.
     if (!options.isOpAllowed(op.getOperation()))
       return WalkResult::advance();
 
-    // Input IR may not contain any ToMemrefOps. These are not supported because
-    // the analysis cannot follow the data flow through memrefs.
+    // ToMemrefOps are not supported because the analysis cannot follow the data
+    // flow through memrefs.
     if (isa<ToMemrefOp>(op.getOperation())) {
+      if (options.testAnalysisOnly || !options.bufferizeFunctionBoundaries)
         op->emitError("to_memref ops not supported during One-Shot Analysis");
       return WalkResult::interrupt();
     }
 
     for (OpOperand &opOperand : op->getOpOperands()) {
       if (opOperand.get().getType().isa<TensorType>()) {
         if (wouldCreateReadAfterWriteInterference(
                 opOperand, domInfo, state, aliasInfo,
                 /*checkConsistencyOnly=*/true)) {
           // This error can happen if certain "mustBufferizeInPlace" interface
           // methods are implemented incorrectly, such that the IR already has
           // a RaW conflict before making any bufferization decisions.
+          if (options.testAnalysisOnly || !options.bufferizeFunctionBoundaries)
             op->emitError("input IR has RaW conflict");
           return WalkResult::interrupt();
         }
       }
     }
 
     return WalkResult::advance();
   });
 

mlir/lib/Dialect/Bufferization/Transforms/OneShotModuleBufferize.cpp

for (OpOperand &operand : returnOp->getOpOperands()) {
     }
   }
 
   auto newFuncType = FunctionType::get(
       funcOp.getContext(), funcOp.getFunctionType().getInputs(), resultTypes);
   funcOp.setType(newFuncType);
 }
 
-LogicalResult
-mlir::bufferization::analyzeModuleOp(ModuleOp moduleOp,
-                                     OneShotAnalysisState &state,
-                                     BufferizationStatistics *statistics) {
+LogicalResult mlir::bufferization::analyzeModuleOp(
+    ModuleOp moduleOp, OneShotAnalysisState &state,
+    BufferizationStatistics *statistics,
+    llvm::SmallSet<func::FuncOp, 8> *notAnalyzedFuncOps) {
   assert(state.getOptions().bufferizeFunctionBoundaries &&
          "expected that function boundary bufferization is activated");
   FuncAnalysisState &funcState = getOrCreateFuncAnalysisState(state);
   BufferizationAliasInfo &aliasInfo = state.getAliasInfo();
 
   // A list of functions in the order in which they are analyzed + bufferized.
   SmallVector<func::FuncOp> orderedFuncOps;
 
   // A mapping of FuncOps to their callers.
   FuncCallerMap callerMap;
 
   if (failed(getFuncOpsOrderedByCalls(moduleOp, orderedFuncOps, callerMap)))
     return failure();
 
   // Analyze ops.
   for (func::FuncOp funcOp : orderedFuncOps) {
     // Now analyzing function.
     funcState.startFunctionAnalysis(funcOp);
 
     // Gather equivalence info for CallOps.
     equivalenceAnalysis(funcOp, aliasInfo, state, funcState);
 
-    // Analyze funcOp.
-    if (failed(analyzeOp(funcOp, state, statistics)))
-      return failure();
+    // Analyze funcOp. If failed, mark it as not analyzed.
+    if (failed(analyzeOp(funcOp, state, statistics))) {
+      funcState.analyzedFuncOps[funcOp] = FuncOpAnalysisState::NotAnalyzed;
+      notAnalyzedFuncOps->insert(funcOp);
+      continue;
+    }
 
     // Run some extra function analyses.
     if (failed(aliasingFuncOpBBArgsAnalysis(funcOp, state, funcState)) ||
         failed(funcOpBbArgReadWriteAnalysis(funcOp, state, funcState)))
       return failure();
 
     // Mark op as fully analyzed.
     funcState.analyzedFuncOps[funcOp] = FuncOpAnalysisState::Analyzed;
   }
 
+  if (notAnalyzedFuncOps && !notAnalyzedFuncOps->empty())
+    return failure();
   return success();
 }
 
 void mlir::bufferization::removeBufferizationAttributesInModule(
     ModuleOp moduleOp) {
   moduleOp.walk([&](func::FuncOp op) {
     for (BlockArgument bbArg : op.getArguments())
       removeBufferizationAttributes(bbArg);
   });
 }
 
 LogicalResult mlir::bufferization::bufferizeModuleOp(
     ModuleOp moduleOp, const OneShotBufferizationOptions &options,
+    llvm::SmallSet<func::FuncOp, 8> &notAnalyzedFuncOps,
     BufferizationStatistics *statistics) {
   assert(options.bufferizeFunctionBoundaries &&
          "expected that function boundary bufferization is activated");
   IRRewriter rewriter(moduleOp.getContext());
 
   // A list of functions in the order in which they are analyzed + bufferized.
   SmallVector<func::FuncOp> orderedFuncOps;
 
   // A mapping of FuncOps to their callers.
   FuncCallerMap callerMap;
 
   if (failed(getFuncOpsOrderedByCalls(moduleOp, orderedFuncOps, callerMap)))
     return failure();
 
   // Bufferize functions.
   for (func::FuncOp funcOp : orderedFuncOps) {
     // Note: It would be good to apply cleanups here but we cannot as aliasInfo
     // would be invalidated.
-    if (failed(bufferizeOp(funcOp, options, options.copyBeforeWrite,
+    // if options.copyBeforeWrite is not set, notAnalyzedFuncOps keeps track of
+    // FuncOps that were not analyzed. Buffer copies will be inserted to these
+    // FuncOps.
+    bool copyBeforeWrite =
+        options.copyBeforeWrite || notAnalyzedFuncOps.contains(funcOp);
+    if (failed(bufferizeOp(funcOp, options, copyBeforeWrite,
                            /*opFilter=*/nullptr, statistics)))
       return failure();
     // Change buffer return types to more precise layout maps.
     if (options.functionBoundaryTypeConversion ==
         LayoutMapOption::InferLayoutMap)
       foldMemRefCasts(funcOp);
   }
 
   // Post-pass cleanup of function argument attributes.
   removeBufferizationAttributesInModule(moduleOp);
 
   return success();
 }
 
 LogicalResult mlir::bufferization::runOneShotModuleBufferize(
     ModuleOp moduleOp, const OneShotBufferizationOptions &options,
     BufferizationStatistics *statistics) {
   assert(options.bufferizeFunctionBoundaries &&
          "expected that function boundary bufferization is activated");
   assert(!(options.copyBeforeWrite && options.testAnalysisOnly) &&
          "invalid combination of bufferization flags");
+  llvm::SmallSet<func::FuncOp, 8> notAnalyzedFuncOps;
+
   if (!options.copyBeforeWrite) {
-    if (failed(insertTensorCopies(moduleOp, options, statistics)))
+    if (failed(insertTensorCopies(moduleOp, options, statistics,
+                                  &notAnalyzedFuncOps)))
       return failure();
   }
   if (options.testAnalysisOnly)
-    return success();
-  if (failed(bufferizeModuleOp(moduleOp, options, statistics)))
+    return success(notAnalyzedFuncOps.empty());
+  if (failed(
+          bufferizeModuleOp(moduleOp, options, notAnalyzedFuncOps, statistics)))
     return failure();
   return success();
 }

mlir/lib/Dialect/Bufferization/Transforms/TensorCopyInsertion.cpp

op->walk([&](BufferizableOpInterface bufferizableOp) {
     }
 
     return WalkResult::advance();
   });
 }
 
 LogicalResult mlir::bufferization::insertTensorCopies(
     Operation *op, const OneShotBufferizationOptions &options,
-    BufferizationStatistics *statistics) {
+    BufferizationStatistics *statistics,
+    llvm::SmallSet<func::FuncOp, 8> *notAnalyzedFuncOps) {
   // Preprocessing: Resolve currently unsupported bufferization cases.
   resolveUsesInRepetitiveRegions(op, options);
 
   OneShotAnalysisState state(op, options);
   // Run normal One-Shot Bufferize analysis or One-Shot Module Bufferize
   // analysis depending on whether function boundary bufferization is enabled or
   // not.
   if (options.bufferizeFunctionBoundaries) {
-    if (failed(analyzeModuleOp(cast<ModuleOp>(op), state, statistics)))
+    ModuleOp module = cast<ModuleOp>(op);
+    if (failed(
+            analyzeModuleOp(module, state, statistics, notAnalyzedFuncOps))) {
+      if (options.testAnalysisOnly)
+        return failure();
+      // If some of the FuncOps were not analyzed, run insertTensorCopies() only
+      // on the analyzed ones. Otherwise, it will run on the entire module.
+      if (!notAnalyzedFuncOps->empty()) {
+        for (auto funcOp : module.getOps<func::FuncOp>())
+          if (!notAnalyzedFuncOps->contains(funcOp) &&
+              failed(insertTensorCopies(funcOp, state)))
             return failure();
+        return success();
+      }
+    }
   } else {
     if (failed(analyzeOp(op, state, statistics)))
       return failure();
   }
 
   if (options.testAnalysisOnly)
     return success();
 

mlir/test/Dialect/Bufferization/Transforms/one-shot-bufferize-invalid.mlir

+// RUN: mlir-opt %s -allow-unregistered-dialect -one-shot-bufferize -split-input-file -verify-diagnostics
+
+func.func @to_memref_op_is_writing(
+    %t1: tensor<?xf32> {bufferization.writable = true}, %idx1: index,
+    %idx2: index, %idx3: index, %v1: vector<5xf32>) -> (vector<5xf32>, vector<5xf32>) {
+  // This is a RaW conflict because to_memref is an inplace write and %t1 is
+  // read further down. This will likely have to change with partial
+  // bufferization.
+
+  // expected-error @+1 {{to_memref ops not supported during One-Shot Analysis}}
+  %0 = bufferization.to_memref %t1 : memref<?xf32>
+
+  // Read from both.
+  %cst = arith.constant 0.0 : f32
+  %r1 = vector.transfer_read %t1[%idx3], %cst : tensor<?xf32>, vector<5xf32>
+  %r2 = vector.transfer_read %0[%idx3], %cst : memref<?xf32>, vector<5xf32>
+
+  return %r1, %r2 : vector<5xf32>, vector<5xf32>
+}
+

mlir/test/Dialect/Bufferization/Transforms/one-shot-module-bufferize-analysis-invalid.mlir

+// RUN: mlir-opt %s -allow-unregistered-dialect -one-shot-bufferize="bufferize-function-boundaries=1 test-analysis-only=1" -split-input-file -verify-diagnostics
+
+func.func @to_memref_op_is_writing(
+    %t1: tensor<?xf32> {bufferization.writable = true}, %idx1: index,
+    %idx2: index, %idx3: index, %v1: vector<5xf32>) -> (vector<5xf32>, vector<5xf32>) {
+  // This is a RaW conflict because to_memref is an inplace write and %t1 is
+  // read further down. This will likely have to change with partial
+  // bufferization.
+
+  // expected-error @+1 {{to_memref ops not supported during One-Shot Analysis}}
+  %0 = bufferization.to_memref %t1 : memref<?xf32>
+
+  // Read from both.
+  %cst = arith.constant 0.0 : f32
+  %r1 = vector.transfer_read %t1[%idx3], %cst : tensor<?xf32>, vector<5xf32>
+  %r2 = vector.transfer_read %0[%idx3], %cst : memref<?xf32>, vector<5xf32>
+
+  return %r1, %r2 : vector<5xf32>, vector<5xf32>
+}

mlir/test/Dialect/Bufferization/Transforms/one-shot-module-bufferize-force-copy-before-write.mlir

+// RUN: mlir-opt %s -one-shot-bufferize="bufferize-function-boundaries=1" -drop-equivalent-buffer-results --split-input-file | FileCheck %s
+
+// ToMemref ops do not pass analysis step. CopyBeforeWrite will be true for the
+// FuncOp containing ToMemref, but not for the other FuncOps.
+
+module {
+  // CHECK-LABEL:   func.func @foo(
+  // CHECK-SAME:                   %[[arg0:.*]]: memref<?xf32, strided<[?], offset: ?>>) {
+  func.func @foo(%arg0: tensor<?xf32>) -> tensor<?xf32> {
+  // CHECK-NEXT:      %[[c0:.*]] = arith.constant 0 : index
+    %cst = arith.constant 1.000000e+00 : f32
+
+  // CHECK-NEXT:      %[[c1:.*]] = arith.constant 1.000000e+00 : f32
+    %c0 = arith.constant 0 : index
+
+  // CHECK-NEXT:      memref.store %[[c1]], %[[arg0]]{{\[}}%[[c0]]] : memref<?xf32, strided<[?], offset: ?>>
+    %inserted = tensor.insert %cst into %arg0[%c0] : tensor<?xf32>
+
+    return %inserted : tensor<?xf32>
+  }
+
+  // CHECK-LABEL:   func.func @contains_to_memref_op(
+  // CHECK-SAME:                                     %[[arg0:.*]]: memref<?xf32, strided<[?], offset: ?>>,
+  // CHECK-SAME:                                     %[[arg1:.*]]: index) -> vector<5xf32> {
+  func.func @contains_to_memref_op(%arg0: tensor<?xf32> {bufferization.writable = true}, %arg1: index) -> vector<5xf32> {
+
+    %0 = bufferization.to_memref %arg0 : memref<?xf32>
+
+    // CHECK:           %[[c0:.*]] = arith.constant 0 : index
+    %cst = arith.constant 0.000000e+00 : f32
+
+    // CHECK:           %[[dim:.*]] = memref.dim %[[arg0]], %[[c0]] : memref<?xf32, strided<[?], offset: ?>>
+    // CHECK:           %[[alloc:.*]] = memref.alloc(%[[dim]]) : memref<?xf32>
+    // CHECK:           memref.copy %[[arg0]], %[[alloc]] : memref<?xf32, strided<[?], offset: ?>> to memref<?xf32>
+    // CHECK:           vector.transfer_read
+    %1 = vector.transfer_read %0[%arg1], %cst : memref<?xf32>, vector<5xf32>
+    return %1 : vector<5xf32>
+  }
+}

mlir/test/Dialect/Bufferization/Transforms/one-shot-module-bufferize-invalid.mlir

func.func @scf_yield(%b : i1, %A : tensor<4xf32>, %B : tensor<4xf32>) -> tensor<4xf32>
   // expected-error @+1 {{operand #0 may return/yield a new buffer allocation}}
   return %r: tensor<4xf32>
 }
 
 // -----
 
 func.func @unknown_op(%A : tensor<4xf32>) -> tensor<4xf32>
 {
-  // expected-error: @+1 {{op was not bufferized}}
+  // expected-error @+1 {{op was not bufferized}}
   %r = "marklar"(%A) : (tensor<4xf32>) -> (tensor<4xf32>)
   // expected-error @+1 {{operand #0 may return/yield a new buffer allocation}}
   return %r: tensor<4xf32>
 }
 
 // -----
 
 func.func @mini_test_case1() -> tensor<10x20xf32> {
func.func @main() -> tensor<4xi32> {
   }
 
   // expected-error @+1 {{operand #0 may return/yield a new buffer allocation}}
   return %r: tensor<4xi32>
 }
 
 // -----
 
-func.func @to_memref_op_is_writing(
-    %t1: tensor<?xf32> {bufferization.writable = true}, %idx1: index,
-    %idx2: index, %idx3: index, %v1: vector<5xf32>) -> (vector<5xf32>, vector<5xf32>) {
-  // This is a RaW conflict because to_memref is an inplace write and %t1 is
-  // read further down. This will likely have to change with partial
-  // bufferization.
-
-  // expected-error @+1 {{to_memref ops not supported during One-Shot Analysis}}
-  %0 = bufferization.to_memref %t1 : memref<?xf32>
-
-  // Read from both.
-  %cst = arith.constant 0.0 : f32
-  %r1 = vector.transfer_read %t1[%idx3], %cst : tensor<?xf32>, vector<5xf32>
-  %r2 = vector.transfer_read %0[%idx3], %cst : memref<?xf32>, vector<5xf32>
-
-  return %r1, %r2 : vector<5xf32>, vector<5xf32>
-}
-
-// -----
-
 // expected-error @+2 {{failed to bufferize op}}
 // expected-error @+1 {{cannot bufferize bodiless function that returns a tensor}}
 func.func private @foo(%t : tensor<?xf32>) -> (f32, tensor<?xf32>, f32)
 
 func.func @call_to_unknown_tensor_returning_func(%t : tensor<?xf32>) {
   call @foo(%t) : (tensor<?xf32>) -> (f32, tensor<?xf32>, f32)
   return
 }