NFC. Clean up memref utils library

[bondhugula]

Summary

NFC. Clean up memref utils library. This library had a single function
that was completely misplaced. MemRefUtils is expected to be (also per
its comment) a library providing analysis/transforms utilities on memref
dialect ops or memref types. However, in reality it had a helper that
was depended upon by the MemRef dialect, i.e., it was a helper for the
dialect ops library and couldn't contain anything that itself depends on
the MemRef dialect. Move the single method to the memref dialect that
will now allow actual utilities depending on the memref dialect to be
placed in it.

Put findDealloc in the memref namespace. This is a pure move.

[bondhugula]

Update missed cmake deps.

[rriddle]

mlir/include/mlir/Dialect/MemRef/IR/MemRef.h

49

Can we drop the llvm:: while we are here?

mlir/include/mlir/Dialect/MemRef/Utils/MemRefUtils.h

19

Can this just be dropped now? It looks like it also gets dropped in the stacked commit.

mlir/lib/Dialect/MemRef/Utils/MemRefUtils.cpp

15

I would drop this comment.

[bondhugula]

Thanks for the review. Addressed.

[mehdi_amini]

mlir/include/mlir/Dialect/MemRef/Utils/MemRefUtils.h

19

Ping on this? The file still exist and this library is empty.

[mehdi_amini]

mlir/include/mlir/Dialect/MemRef/Utils/MemRefUtils.h

19

@bondhugula ping?

[mehdi_amini]

Did it myself in 2c9783c6b97ba419f80a5bf1c0a1ffda36c9db8b

mlir/include/mlir/Dialect/MemRef/IR/MemRef.h

 /// "someop(memref.cast) -> someop". It folds the source of any memref.cast
 /// into the root operation directly.
 LogicalResult foldMemRefCast(Operation *op, Value inner = nullptr);
 
 /// Return an unranked/ranked tensor type for the given unranked/ranked memref
 /// type.
 Type getTensorTypeFromMemRefType(Type type);
 
+/// Finds a single dealloc operation for the given allocated value. If there
+/// are > 1 deallocates for `allocValue`, returns None, else returns the single
+/// deallocate if it exists or nullptr.
+llvm::Optional<Operation *> findDealloc(Value allocValue);
+
 } // namespace memref
 } // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // MemRef Dialect
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/MemRef/IR/MemRefOpsDialect.h.inc"

mlir/include/mlir/Dialect/MemRef/Utils/MemRefUtils.h

 // either by passes, optimization sequences, or in turn by other transformation
 // utilities.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_MEMREF_UTILS_MEMREFUTILS_H
 #define MLIR_DIALECT_MEMREF_UTILS_MEMREFUTILS_H
 
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 
-namespace mlir {
-
-/// Finds a single dealloc operation for the given allocated value. If there
-/// are > 1 deallocates for `allocValue`, returns None, else returns the single
-/// deallocate if it exists or nullptr.
-llvm::Optional<Operation *> findDealloc(Value allocValue);
-} // namespace mlir
-
 #endif // MLIR_DIALECT_MEMREF_UTILS_MEMREFUTILS_H

mlir/lib/Dialect/Bufferization/IR/BufferizationOps.cpp

LogicalResult matchAndRewrite(CloneOp cloneOp,
     }
 
     Value source = cloneOp.input();
 
     // This only finds dealloc operations for the immediate value. It should
     // also consider aliases. That would also make the safety check below
     // redundant.
     llvm::Optional<Operation *> maybeCloneDeallocOp =
-        findDealloc(cloneOp.output());
+        memref::findDealloc(cloneOp.output());
     // Skip if either of them has > 1 deallocate operations.
     if (!maybeCloneDeallocOp.hasValue())
       return failure();
-    llvm::Optional<Operation *> maybeSourceDeallocOp = findDealloc(source);
+    llvm::Optional<Operation *> maybeSourceDeallocOp =
+        memref::findDealloc(source);
     if (!maybeSourceDeallocOp.hasValue())
       return failure();
     Operation *cloneDeallocOp = *maybeCloneDeallocOp;
     Operation *sourceDeallocOp = *maybeSourceDeallocOp;
 
     // If both are deallocated in the same block, their in-block lifetimes
     // might not fully overlap, so we cannot decide which one to drop.
     if (cloneDeallocOp && sourceDeallocOp &&

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

llvm::copy_if(
         });
     // If there is one result only, we will be able to move the allocation and
     // (possibly existing) deallocation ops.
     if (allocateResultEffects.size() != 1)
       return;
     // Get allocation result.
     Value allocValue = allocateResultEffects[0].getValue();
     // Find the associated dealloc value and register the allocation entry.
-    llvm::Optional<Operation *> dealloc = findDealloc(allocValue);
+    llvm::Optional<Operation *> dealloc = memref::findDealloc(allocValue);
     // If the allocation has > 1 dealloc associated with it, skip handling it.
     if (!dealloc.hasValue())
       return;
     allocs.push_back(std::make_tuple(allocValue, *dealloc));
   });
 }
 
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/MemRef/IR/CMakeLists.txt

add_mlir_dialect_library(MLIRMemRef
   LINK_LIBS PUBLIC
   MLIRArithmetic
   MLIRArithmeticUtils
   MLIRControlFlowInterfaces
   MLIRDialect
   MLIRDialectUtils
   MLIRInferTypeOpInterface
   MLIRIR
-  MLIRMemRefUtils
+  MLIRSideEffectInterfaces
   MLIRViewLikeInterface
 )

mlir/lib/Dialect/MemRef/IR/MemRefDialect.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 using namespace mlir::memref;
 
 #include "mlir/Dialect/MemRef/IR/MemRefOpsDialect.cpp.inc"
 
 //===----------------------------------------------------------------------===//

 
 void mlir::memref::MemRefDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/MemRef/IR/MemRefOps.cpp.inc"
       >();
   addInterfaces<MemRefInlinerInterface>();
 }
+
+/// Finds a single dealloc operation for the given allocated value.
+llvm::Optional<Operation *> mlir::memref::findDealloc(Value allocValue) {
+  Operation *dealloc = nullptr;
+  for (Operation *user : allocValue.getUsers()) {
+    auto effectInterface = dyn_cast<MemoryEffectOpInterface>(user);
+    if (!effectInterface)
+      continue;
+    // Try to find a free effect that is applied to one of our values
+    // that will be automatically freed by our pass.
+    SmallVector<MemoryEffects::EffectInstance, 2> effects;
+    effectInterface.getEffectsOnValue(allocValue, effects);
+    const bool isFree =
+        llvm::any_of(effects, [&](MemoryEffects::EffectInstance &it) {
+          return isa<MemoryEffects::Free>(it.getEffect());
+        });
+    if (!isFree)
+      continue;
+    // If we found > 1 dealloc, return None.
+    if (dealloc)
+      return llvm::None;
+    dealloc = user;
+  }
+  return dealloc;
+}

mlir/lib/Dialect/MemRef/Utils/CMakeLists.txt

 add_mlir_dialect_library(MLIRMemRefUtils
   MemRefUtils.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${PROJECT_SOURCE_DIR}/inlude/mlir/Dialect/MemRefDialect
-
-  LINK_LIBS PUBLIC
-  MLIRIR
-  MLIRSideEffectInterfaces
 )
 

mlir/lib/Dialect/MemRef/Utils/MemRefUtils.cpp

 //===- MemRefUtils.cpp - Utilities to support the MemRef dialect ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements utilities for the MemRef dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/MemRef/Utils/MemRefUtils.h"
-#include "mlir/Interfaces/SideEffectInterfaces.h"
 
-using namespace mlir;
-
-/// Finds a single dealloc operation for the given allocated value.
-llvm::Optional<Operation *> mlir::findDealloc(Value allocValue) {
-  Operation *dealloc = nullptr;
-  for (Operation *user : allocValue.getUsers()) {
-    auto effectInterface = dyn_cast<MemoryEffectOpInterface>(user);
-    if (!effectInterface)
-      continue;
-    // Try to find a free effect that is applied to one of our values
-    // that will be automatically freed by our pass.
-    SmallVector<MemoryEffects::EffectInstance, 2> effects;
-    effectInterface.getEffectsOnValue(allocValue, effects);
-    const bool isFree =
-        llvm::any_of(effects, [&](MemoryEffects::EffectInstance &it) {
-          return isa<MemoryEffects::Free>(it.getEffect());
-        });
-    if (!isFree)
-      continue;
-    // If we found > 1 dealloc, return None.
-    if (dealloc)
-      return llvm::None;
-    dealloc = user;
-  }
-  return dealloc;
-}
+// Retaining this empty file for a stacked commit.