diff --git a/mlir/include/mlir/Dialect/Tensor/TransformOps/TensorTransformOps.td b/mlir/include/mlir/Dialect/Tensor/TransformOps/TensorTransformOps.td
--- a/mlir/include/mlir/Dialect/Tensor/TransformOps/TensorTransformOps.td
+++ b/mlir/include/mlir/Dialect/Tensor/TransformOps/TensorTransformOps.td
@@ -31,11 +31,14 @@
     "apply_patterns.tensor.fold_tensor_empty",
     [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
-    Indicates that reassociative reshapes (tensor.collapse_shape /
-    tensor.expand_shape) should be folded with inverse rank expansions / rank
-    reductions (via tensor.insert_slice / tensor.extract_slice).
+    Indicates that tensor.extract_slice and reassociative reshapes should be
+    folded into tensor.empty.
+
+    If `fold_single_use_only` is set to "true", only tensor.empty that have a
+    single use are folded.
   }];
 
+  let arguments = (ins DefaultValuedAttr<BoolAttr, "false">:$fold_single_use_only);
   let assemblyFormat = "attr-dict";
 }
 def ApplyFoldIntoPackAndUnpackPatternsOp : Op<Transform_Dialect,
diff --git a/mlir/include/mlir/Dialect/Tensor/Transforms/Transforms.h b/mlir/include/mlir/Dialect/Tensor/Transforms/Transforms.h
--- a/mlir/include/mlir/Dialect/Tensor/Transforms/Transforms.h
+++ b/mlir/include/mlir/Dialect/Tensor/Transforms/Transforms.h
@@ -56,7 +56,11 @@
 
 /// Populates `patterns` with patterns that fold tensor.empty with
 /// tensor.[extract_slice|expand_shape|collapse_shape].
-void populateFoldTensorEmptyPatterns(RewritePatternSet &patterns);
+///
+/// If `singleUseOnly` is set to "true", only tensor.empty ops with a single
+/// use are folded.
+void populateFoldTensorEmptyPatterns(RewritePatternSet &patterns,
+                                     bool foldSingleUseOnly = false);
 
 /// Populates `patterns` with patterns that fold operations like `tensor.pad`
 /// and `tensor.extract_slice` into `tensor.pack` and `tensor.unpack` operations
diff --git a/mlir/lib/Dialect/Tensor/TransformOps/TensorTransformOps.cpp b/mlir/lib/Dialect/Tensor/TransformOps/TensorTransformOps.cpp
--- a/mlir/lib/Dialect/Tensor/TransformOps/TensorTransformOps.cpp
+++ b/mlir/lib/Dialect/Tensor/TransformOps/TensorTransformOps.cpp
@@ -90,7 +90,7 @@
 
 void transform::ApplyFoldTensorEmptyPatternsOp::populatePatterns(
     RewritePatternSet &patterns) {
-  tensor::populateFoldTensorEmptyPatterns(patterns);
+  tensor::populateFoldTensorEmptyPatterns(patterns, getFoldSingleUseOnly());
 }
 
 void transform::ApplyFoldIntoPackAndUnpackPatternsOp::populatePatterns(
diff --git a/mlir/lib/Dialect/Tensor/Transforms/EmptyOpPatterns.cpp b/mlir/lib/Dialect/Tensor/Transforms/EmptyOpPatterns.cpp
--- a/mlir/lib/Dialect/Tensor/Transforms/EmptyOpPatterns.cpp
+++ b/mlir/lib/Dialect/Tensor/Transforms/EmptyOpPatterns.cpp
@@ -18,17 +18,30 @@
 
 template <typename ReshapeOp>
 struct FoldEmptyTensorWithReshapeOp : public OpRewritePattern<ReshapeOp> {
-  using OpRewritePattern<ReshapeOp>::OpRewritePattern;
+  FoldEmptyTensorWithReshapeOp(MLIRContext *ctx, PatternBenefit benefit = 1,
+                               bool foldSingleUseOnly = false)
+      : OpRewritePattern<ReshapeOp>(ctx, benefit),
+        foldSingleUseOnly(foldSingleUseOnly) {}
 
   LogicalResult matchAndRewrite(ReshapeOp reshapeOp,
                                 PatternRewriter &rewriter) const override {
-    if (!reshapeOp.getSrc().template getDefiningOp<EmptyOp>())
+    // Check for tensor.empty source.
+    auto emptyOp = reshapeOp.getSrc().template getDefiningOp<EmptyOp>();
+    if (!emptyOp)
       return failure();
+
+    // Check for single use.
+    if (foldSingleUseOnly && !llvm::hasSingleElement(emptyOp->getUses()))
+      return failure();
+
+    // Reify result shape.
     Location loc = reshapeOp.getLoc();
     ReifiedRankedShapedTypeDims resultShapes;
     if (failed(reifyResultShapes(rewriter, reshapeOp, resultShapes)) ||
         !llvm::hasSingleElement(resultShapes))
       return failure();
+
+    // Create new tensor.empty op.
     // TODO: Do not drop tensor type encoding.
     Value emptyTensor = rewriter.create<EmptyOp>(
         loc, resultShapes[0], reshapeOp.getResultType().getElementType());
@@ -40,21 +53,34 @@
     }
     return success();
   }
+
+private:
+  bool foldSingleUseOnly = false;
 };
 
-/// `tensor.empty` does not define any tensor contents, so a slice of a
-/// `tensor.empty` can be canonicalized to a smaller `tensor.empty`.
+/// tensor.empty does not define any tensor contents, so a slice of a
+/// tensor.empty can be folded to a smaller tensor.empty.
 struct FoldEmptyTensorWithExtractSliceOp
     : public OpRewritePattern<ExtractSliceOp> {
-  using OpRewritePattern<ExtractSliceOp>::OpRewritePattern;
+  FoldEmptyTensorWithExtractSliceOp(MLIRContext *ctx,
+                                    PatternBenefit benefit = 1,
+                                    bool foldSingleUseOnly = false)
+      : OpRewritePattern<ExtractSliceOp>(ctx, benefit),
+        foldSingleUseOnly(foldSingleUseOnly) {}
 
   LogicalResult matchAndRewrite(ExtractSliceOp sliceOp,
                                 PatternRewriter &rewriter) const override {
-    if (!sliceOp.getSource().getDefiningOp<EmptyOp>())
+    // Check for tensor.empty source.
+    auto emptyOp = sliceOp.getSource().template getDefiningOp<EmptyOp>();
+    if (!emptyOp)
+      return failure();
+
+    // Check for single use.
+    if (foldSingleUseOnly && !llvm::hasSingleElement(emptyOp->getUses()))
       return failure();
 
-    // ExtractSliceOp may be rank-reducing; its dynamic sizes must be
-    // preserved as well as its result type.
+    // Create new tensor.empty op. tensor.extract_slice may be rank-reducing;
+    // its dynamic sizes must be preserved as well as its result type.
     auto tensorType = RankedTensorType::get(sliceOp.getType().getShape(),
                                             sliceOp.getType().getElementType(),
                                             sliceOp.getType().getEncoding());
@@ -62,14 +88,17 @@
                                          sliceOp.getSizes());
     return success();
   }
+
+private:
+  bool foldSingleUseOnly = false;
 };
 
 } // namespace
 
-void mlir::tensor::populateFoldTensorEmptyPatterns(
-    RewritePatternSet &patterns) {
+void mlir::tensor::populateFoldTensorEmptyPatterns(RewritePatternSet &patterns,
+                                                   bool foldSingleUseOnly) {
   patterns.add<FoldEmptyTensorWithExtractSliceOp,
                FoldEmptyTensorWithReshapeOp<tensor::ExpandShapeOp>,
                FoldEmptyTensorWithReshapeOp<tensor::CollapseShapeOp>>(
-      patterns.getContext());
+      patterns.getContext(), foldSingleUseOnly);
 }