[mlir] Remove `Transforms/SideEffectUtils.h` and move the methods into `Interface/SideEffectInterfaces.h`.

[mravishankar]

Summary

The methods in SideEffectUtils.h (and their implementations in
SideEffectUtils.cpp) seem to have similar intent to methods already
existing in SideEffectInterfaces.h. Move the decleration (and
implementation) from SideEffectUtils.h (and SideEffectUtils.cpp)
into SideEffectInterfaces.h (and SideEffectInterface.cpp).

Also drop the SideEffectInterface::hasNoEffect method in favor of
mlir::isMemoryEffectFree which actually recurses into the operation
instead of just relying on the hasRecursiveMemoryEffectTrait
exclusively.

[mravishankar]

Drop use of hasNoEffect and use isMemoryEffectFree.

[rriddle]

mlir/lib/Dialect/GPU/Transforms/AsyncRegionRewriter.cpp

347–354

What is the relation with these changes?

[mravishankar]

mlir/lib/Dialect/GPU/Transforms/AsyncRegionRewriter.cpp

347–354

Good catch. This was something I hit while debugging before the better solution was suggest by @Mogball on discord. Ill revert this.

[mravishankar]

Address comments.

[mravishankar]

Rebase

[sanjoy]

Since hasNoEffect did not walk the op regions and isMemoryEffectFree does, I think with this change we have a couple of redundant checks on the attached regions.

mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp

661

Do we still need the clone->getNumRegions() != 0 bit, now that isMemoryEffectFree recursively checks the regions? Same comment elsewhere.

mlir/lib/Interfaces/SideEffectInterfaces.cpp

160

These comments need to be adjusted -- it should no longer say "it cannot be moved". Same for code comments below.

[mravishankar]

In D137857#3926091, @sanjoy wrote:

Since hasNoEffect did not walk the op regions and isMemoryEffectFree does, I think with this change we have a couple of redundant checks on the attached regions.

I am not sure I follow. It seems like dropping the checks you mentioned increases the scope of analysis past what is intended with this change. I think those need to be follow ups (by folks who understand that code which isnt me) . I hope I can land this change without this ballooning much more.

mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp

661

I think that is outside the scope of this change. That seems like it can have non-trivial changes to the intent of the code here that I dont fully understand. It maybe a follow up for people who are currently working in this area.

mlir/lib/Interfaces/SideEffectInterfaces.cpp

160

This is just a move of the code. So the comment is what was there earlier. Can you suggest what you want here?

[mravishankar]

Rebase.

[sanjoy]

mlir/lib/Interfaces/SideEffectInterfaces.cpp

160

You could just delete the comment probably since saying "If the op has no memory effects then it is memory effect free" is not very useful :)

173

Maybe say "// Check if any operations in the inner regions have memory effects" or equivalent.

[mravishankar]

Maybe fix lit test failure on Windows.

[mravishankar]

Lit test fixes

[mravishankar]

FYI, I landed this even though @sanjoy hasnt accepted it. I had a chat with him offline earlier where he was OK with making some of the more functional/comment changes after the fact.

mlir/include/mlir/Interfaces/SideEffectInterfaceBase.td

let extraClassDeclaration = [{
 
     /// Returns true if this operation has no effects.
     bool hasNoEffect() {
       SmallVector<::mlir::SideEffects::EffectInstance<}] # baseEffect # [{>, 4> effects;
       getEffects(effects);
       return effects.empty();
     }
 
-    /// Returns true if the given operation has no effects for this interface.
-    static bool hasNoEffect(Operation *op) {
-      if (auto interface = dyn_cast<}] # name # [{>(op))
-        return interface.hasNoEffect();
-      return op->hasTrait<::mlir::OpTrait::HasRecursiveMemoryEffects>();
-    }
-
     /// Collect all of the effect instances that operate on the provided value
     /// and place them in 'effects'.
     void getEffectsOnValue(::mlir::Value value,
               llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<
               }] # baseEffect # [{>> & effects) {
       getEffects(effects);
       llvm::erase_if(effects, [&](auto &it) { return it.getValue() != value; });
     }

mlir/include/mlir/Interfaces/SideEffectInterfaces.h

 /// memory that prevent erasing.
 bool isOpTriviallyDead(Operation *op);
 
 /// Return true if the given operation would be dead if unused, and has no side
 /// effects on memory that would prevent erasing. This is equivalent to checking
 /// `isOpTriviallyDead` if `op` was unused.
 bool wouldOpBeTriviallyDead(Operation *op);
 
+/// Returns true if the given operation is free of memory effects.
+///
+/// An operation is free of memory effects if its implementation of
+/// `MemoryEffectOpInterface` indicates that it has no memory effects. For
+/// example, it may implement `NoMemoryEffect` in ODS. Alternatively, if the
+/// operation has the `HasRecursiveMemoryEffects` trait, then it is free of
+/// memory effects if all of its nested operations are free of memory effects.
+///
+/// If the operation has both, then it is free of memory effects if both
+/// conditions are satisfied.
+bool isMemoryEffectFree(Operation *op);
+
+/// Returns true if the given operation is speculatable, i.e. has no undefined
+/// behavior or other side effects.
+///
+/// An operation can indicate that it is speculatable by implementing the
+/// getSpeculatability hook in the ConditionallySpeculatable op interface.
+bool isSpeculatable(Operation *op);
+
 } // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // SideEffect Interfaces
 //===----------------------------------------------------------------------===//
 
 /// Include the definitions of the side effect interfaces.
 #include "mlir/Interfaces/SideEffectInterfaces.h.inc"
 
 #endif // MLIR_INTERFACES_SIDEEFFECTINTERFACES_H

mlir/include/mlir/Transforms/SideEffectUtils.h

-//===- SideEffectUtils.h - Side Effect Utils --------------------*- 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_TRANSFORMS_SIDEFFECTUTILS_H
-#define MLIR_TRANSFORMS_SIDEFFECTUTILS_H
-
-namespace mlir {
-
-class Operation;
-
-/// Returns true if the given operation is free of memory effects.
-///
-/// An operation is free of memory effects if its implementation of
-/// `MemoryEffectOpInterface` indicates that it has no memory effects. For
-/// example, it may implement `NoMemoryEffect` in ODS. Alternatively, if the
-/// operation has the `HasRecursiveMemoryEffects` trait, then it is free of
-/// memory effects if all of its nested operations are free of memory effects.
-///
-/// If the operation has both, then it is free of memory effects if both
-/// conditions are satisfied.
-bool isMemoryEffectFree(Operation *op);
-
-/// Returns true if the given operation is speculatable, i.e. has no undefined
-/// behavior or other side effects.
-///
-/// An operation can indicate that it is speculatable by implementing the
-/// getSpeculatability hook in the ConditionallySpeculatable op interface.
-bool isSpeculatable(Operation *op);
-
-} // end namespace mlir
-
-#endif // MLIR_TRANSFORMS_SIDEFFECTUTILS_H

mlir/lib/Analysis/SliceAnalysis.cpp

 //===- UseDefAnalysis.cpp - Analysis for Transitive UseDef chains ---------===//
 //
 // 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 Analysis functions specific to slicing in Function.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/SliceAnalysis.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Operation.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 
 ///
 /// Implements Analysis functions specific to slicing in Function.
 ///
 
Operation *redRegionOp =
       iterCarriedArgs.front().getOwner()->getParent()->getParentOp();
   if (dependsOnCarriedVals(reducedVal, iterCarriedArgs, redRegionOp))
     return nullptr;
 
   // Traverse the def-use chain starting from the first combiner op until a
   // terminator is found. Gather all the combiner ops along the way in
   // topological order.
   while (!combinerOp->mightHaveTrait<OpTrait::IsTerminator>()) {
-    if (!MemoryEffectOpInterface::hasNoEffect(combinerOp) ||
-        combinerOp->getNumResults() != 1 || !combinerOp->hasOneUse() ||
-        combinerOp->getParentOp() != redRegionOp)
+    if (!isMemoryEffectFree(combinerOp) || combinerOp->getNumResults() != 1 ||
+        !combinerOp->hasOneUse() || combinerOp->getParentOp() != redRegionOp)
       return nullptr;
 
     combinerOps.push_back(combinerOp);
     combinerOp = *combinerOp->getUsers().begin();
   }
 
   // Limit matching to single combiner op until we can properly test reductions
   // involving multiple combiners.

mlir/lib/Conversion/SCFToGPU/CMakeLists.txt

add_mlir_conversion_library(MLIRSCFToGPU
   MLIRArithDialect
   MLIRComplexDialect
   MLIRGPUTransforms
   MLIRIR
   MLIRLinalgDialect
   MLIRMemRefDialect
   MLIRPass
   MLIRSupport
+  MLIRSideEffectInterfaces
   MLIRTransforms
   )

mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp

 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Dialect/GPU/Transforms/ParallelLoopMapper.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "loops-to-gpu"
if (auto nestedParallel = dyn_cast<ParallelOp>(op)) {
       leftNestingScope = true;
       seenSideeffects = false;
     } else {
       // Otherwise we copy it over.
       Operation *clone = rewriter.clone(*op, cloningMap);
       cloningMap.map(op->getResults(), clone->getResults());
       // Check for side effects.
       // TODO: Handle region side effects properly.
-      seenSideeffects |= !MemoryEffectOpInterface::hasNoEffect(clone) ||
-                         clone->getNumRegions() != 0;
+      seenSideeffects |=
+          !isMemoryEffectFree(clone) || clone->getNumRegions() != 0;
       // If we are no longer in the innermost scope, sideeffects are disallowed.
       if (seenSideeffects && leftNestingScope)
         return failure();
     }
   }
 
   // Now that we succeeded creating the launch operation, also update the
   // bounds.

mlir/lib/Dialect/Affine/Analysis/AffineAnalysis.cpp

if (auto readOp = dyn_cast<AffineReadOpInterface>(op)) {
       if (!isLocallyDefined(readOp.getMemRef(), forOp))
         loadAndStoreOps.push_back(op);
     } else if (auto writeOp = dyn_cast<AffineWriteOpInterface>(op)) {
       // Filter out stores the same way as above.
       if (!isLocallyDefined(writeOp.getMemRef(), forOp))
         loadAndStoreOps.push_back(op);
     } else if (!isa<AffineForOp, AffineYieldOp, AffineIfOp>(op) &&
                !hasSingleEffect<MemoryEffects::Allocate>(op) &&
-               !MemoryEffectOpInterface::hasNoEffect(op)) {
+               !isMemoryEffectFree(op)) {
       // Alloc-like ops inside `forOp` are fine (they don't impact parallelism)
       // as long as they don't escape the loop (which has been checked above).
       return WalkResult::interrupt();
     }
 
     return WalkResult::advance();
   });
 

mlir/lib/Dialect/Affine/Analysis/CMakeLists.txt

 add_mlir_dialect_library(MLIRAffineAnalysis
   AffineAnalysis.cpp
   AffineStructures.cpp
   LoopAnalysis.cpp
   NestedMatcher.cpp
   Utils.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Affine
 
   LINK_LIBS PUBLIC
   MLIRAffineDialect
   MLIRAnalysis
   MLIRCallInterfaces
   MLIRControlFlowInterfaces
   MLIRInferTypeOpInterface
+  MLIRSideEffectInterfaces
   MLIRPresburger
   MLIRSCFDialect
   )

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

 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
 #include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
 #include "mlir/Dialect/Bufferization/Transforms/OneShotAnalysis.h"
 #include "mlir/Dialect/Bufferization/Transforms/OneShotModuleBufferize.h"
 #include "mlir/Dialect/Bufferization/Transforms/Transforms.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/IR/Operation.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/Passes.h"
 
 namespace mlir {
 namespace bufferization {
 #define GEN_PASS_DEF_FINALIZINGBUFFERIZE
 #define GEN_PASS_DEF_BUFFERIZATIONBUFFERIZE
for (Operation *op : worklist) {
     if (!hasTensorSemantics(op))
       continue;
     // Continue ops that are not allowed.
     if (!options.isOpAllowed(op))
       continue;
     if (opFilter && !opFilter->isOpAllowed(op))
       continue;
     // Ops without any uses and no side effects will fold away.
-    if (op->getUses().empty() && MemoryEffectOpInterface::hasNoEffect(op))
+    if (op->getUses().empty() && isMemoryEffectFree(op))
       continue;
     // ToTensorOps/ToMemrefOps are allowed in the output.
     if (isa<ToTensorOp, ToMemrefOp>(op))
       continue;
     return op->emitError("op was not bufferized");
   }
 
   return success();

mlir/lib/Dialect/Bufferization/Transforms/CMakeLists.txt

add_mlir_dialect_library(MLIRBufferizationTransforms
   MLIRBufferizationDialect
   MLIRControlFlowInterfaces
   MLIRFuncDialect
   MLIRInferTypeOpInterface
   MLIRIR
   MLIRMemRefDialect
   MLIRPass
   MLIRTensorDialect
+  MLIRSideEffectInterfaces
   MLIRTransforms
   MLIRViewLikeInterface
 )
 

mlir/lib/Dialect/GPU/CMakeLists.txt

add_mlir_dialect_library(MLIRGPUTransforms
   MLIRExecutionEngineUtils
   MLIRGPUOps
   MLIRIR
   MLIRLLVMDialect
   MLIRLLVMToLLVMIRTranslation
   MLIRMemRefDialect
   MLIRPass
   MLIRSCFDialect
+  MLIRSideEffectInterfaces
   MLIRSupport
   MLIRTransformUtils
   )
 
 add_subdirectory(TransformOps)
 
 if(MLIR_ENABLE_CUDA_RUNNER)
   if(NOT MLIR_ENABLE_CUDA_CONVERSIONS)

mlir/lib/Dialect/GPU/Transforms/AsyncRegionRewriter.cpp

 #include "mlir/Dialect/Async/IR/Async.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Dialect/GPU/Transforms/Utils.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/SymbolTable.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 namespace mlir {
 #define GEN_PASS_DEF_GPUASYNCREGIONPASS
 #include "mlir/Dialect/GPU/Transforms/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
 
 namespace {
 class GpuAsyncRegionPass
     : public impl::GpuAsyncRegionPassBase<GpuAsyncRegionPass> {
   struct ThreadTokenCallback;
   struct DeferWaitCallback;
   struct SingleTokenUseCallback;
   void runOnOperation() override;
 };
 } // namespace
 
 static bool isTerminator(Operation *op) {
   return op->mightHaveTrait<OpTrait::IsTerminator>();
 }
-static bool hasSideEffects(Operation *op) {
-  return !MemoryEffectOpInterface::hasNoEffect(op);
-}
+static bool hasSideEffects(Operation *op) { return !isMemoryEffectFree(op); }
 
 // Region walk callback which makes GPU ops implementing the AsyncOpInterface
 // execute asynchronously.
 struct GpuAsyncRegionPass::ThreadTokenCallback {
   ThreadTokenCallback(MLIRContext &context) : builder(&context) {}
 
   WalkResult operator()(Block *block) {
     for (Operation &op : make_early_inc_range(*block)) {
void operator()(async::ExecuteOp executeOp) {
     }
   }
 };
 
 // Replaces synchronous GPU ops in the op's region with asynchronous ones and
 // inserts the necessary synchronization (as gpu.wait ops). Assumes sequential
 // execution semantics and that no GPU ops are asynchronous yet.
 void GpuAsyncRegionPass::runOnOperation() {
-  if (getOperation()->walk(ThreadTokenCallback(getContext())).wasInterrupted())
+  auto operation = getOperation();
+  if (operation->walk(ThreadTokenCallback(getContext())).wasInterrupted())
     return signalPassFailure();
 
   // Collect gpu.wait ops that we can move out of async.execute regions.
-  getOperation().getRegion().walk(DeferWaitCallback());
-  // Makes each !gpu.async.token returned from async.execute op have single use.
-  getOperation().getRegion().walk(SingleTokenUseCallback());
+  if (operation->getNumRegions() != 0) {
+    Region &region = operation.getRegion();
+    if (!region.empty()) {
+      region.walk(DeferWaitCallback());
+      // Makes each !gpu.async.token returned from async.execute op have single
+      // use.
+      region.walk(SingleTokenUseCallback());
+    }
+  }
 }
 
 std::unique_ptr<OperationPass<func::FuncOp>> mlir::createGpuAsyncRegionPass() {
   return std::make_unique<GpuAsyncRegionPass>();
 }

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

LogicalResult GenericAtomicRMWOp::verify() {
   if (body.getNumArguments() != 1)
     return emitOpError("expected single number of entry block arguments");
 
   if (getResult().getType() != body.getArgument(0).getType())
     return emitOpError("expected block argument of the same type result type");
 
   bool hasSideEffects =
       body.walk([&](Operation *nestedOp) {
-            if (MemoryEffectOpInterface::hasNoEffect(nestedOp))
+            if (isMemoryEffectFree(nestedOp))
               return WalkResult::advance();
             nestedOp->emitError(
                 "body of 'memref.generic_atomic_rmw' should contain "
                 "only operations with no side effects");
             return WalkResult::interrupt();
           })
           .wasInterrupted();
   return hasSideEffects ? failure() : success();

mlir/lib/Dialect/SCF/Transforms/CMakeLists.txt

add_mlir_dialect_library(MLIRSCFTransforms
   MLIRBufferizationTransforms
   MLIRDestinationStyleOpInterface
   MLIRDialectUtils
   MLIRIR
   MLIRMemRefDialect
   MLIRPass
   MLIRSCFDialect
   MLIRSCFUtils
+  MLIRSideEffectInterfaces
   MLIRSupport
   MLIRTensorDialect
   MLIRTensorTransforms
   MLIRTilingInterface
   MLIRTransforms
   MLIRTransformUtils
 )

mlir/lib/Dialect/SCF/Transforms/ParallelLoopFusion.cpp

 #include "mlir/Dialect/SCF/Transforms/Passes.h"
 
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/SCF/Transforms/Transforms.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/OpDefinition.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
 
 namespace mlir {
 #define GEN_PASS_DEF_SCFPARALLELLOOPFUSION
 #include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
 using namespace mlir::scf;
for (auto &op : block) {
           ploopChains.back().push_back(ploop);
         } else {
           ploopChains.push_back({ploop});
           noSideEffects = true;
         }
         continue;
       }
       // TODO: Handle region side effects properly.
-      noSideEffects &=
-          MemoryEffectOpInterface::hasNoEffect(&op) && op.getNumRegions() == 0;
+      noSideEffects &= isMemoryEffectFree(&op) && op.getNumRegions() == 0;
     }
     for (ArrayRef<ParallelOp> ploops : ploopChains) {
       for (int i = 0, e = ploops.size(); i + 1 < e; ++i)
         fuseIfLegal(ploops[i], ploops[i + 1], b);
     }
   }
 }
 

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

 add_mlir_dialect_library(MLIRSCFUtils
   AffineCanonicalizationUtils.cpp
   Utils.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SCF
 
   LINK_LIBS PUBLIC
   MLIRAffineDialect
   MLIRAffineAnalysis
   MLIRAnalysis
   MLIRArithDialect
   MLIRDialectUtils
   MLIRFuncDialect
   MLIRIR
   MLIRSCFDialect
+  MLIRSideEffectInterfaces
   MLIRSupport
   MLIRTransforms
   )

mlir/lib/Dialect/SCF/Utils/Utils.cpp

 #include "mlir/Dialect/SCF/Utils/Utils.h"
 #include "mlir/Analysis/SliceAnalysis.h"
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Support/MathExtras.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 
 using namespace mlir;
if (isa<scf::ForOp>(op))
       continue;
     // Skip other ops with regions.
     if (op.getNumRegions() > 0) {
       status = failure();
       continue;
     }
     // Skip if op has side effects.
     // TODO: loads to immutable memory regions are ok.
-    if (!MemoryEffectOpInterface::hasNoEffect(&op)) {
+    if (!isMemoryEffectFree(&op)) {
       status = failure();
       continue;
     }
     toHoist.push_back(&op);
   }
   auto *outerForOp = outer.getOperation();
   for (auto *op : toHoist)
     op->moveBefore(outerForOp);

mlir/lib/Dialect/Vector/Transforms/CMakeLists.txt

add_mlir_dialect_library(MLIRVectorTransforms
   MLIRBufferizationDialect
   MLIRBufferizationTransforms
   MLIRDialectUtils
   MLIRGPUOps
   MLIRIR
   MLIRLinalgDialect
   MLIRMemRefDialect
   MLIRSCFDialect
+  MLIRSideEffectInterfaces
   MLIRTransforms
   MLIRVectorDialect
   MLIRVectorInterfaces
   MLIRVectorUtils
   )

mlir/lib/Dialect/Vector/Transforms/VectorDistribute.cpp

 //===- VectorDistribute.cpp - patterns to do vector distribution ----------===//
 //
 // 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/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/Dialect/Vector/Transforms/VectorDistribution.h"
 #include "mlir/IR/AffineExpr.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Transforms/RegionUtils.h"
-#include "mlir/Transforms/SideEffectUtils.h"
 #include "llvm/ADT/SetVector.h"
 #include <utility>
 
 using namespace mlir;
 using namespace mlir::vector;
 
 /// Currently the distribution map is implicit based on the vector shape. In the
 /// future it will be part of the op.

mlir/lib/Dialect/Vector/Transforms/VectorTransferOpTransforms.cpp

 
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/Dialect/Vector/Transforms/VectorTransforms.h"
 #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Dominance.h"
-#include "mlir/Transforms/SideEffectUtils.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "vector-transfer-opt"
 
 #define DBGS() (llvm::dbgs() << '[' << DEBUG_TYPE << "] ")
 

mlir/lib/Interfaces/SideEffectInterfaces.cpp

 template bool
 mlir::hasEffect<MemoryEffects::Write, MemoryEffects::Free>(Operation *, Value);
 
 bool mlir::wouldOpBeTriviallyDead(Operation *op) {
   if (op->mightHaveTrait<OpTrait::IsTerminator>())
     return false;
   return wouldOpBeTriviallyDeadImpl(op);
 }
+
+bool mlir::isMemoryEffectFree(Operation *op) {
+  if (auto memInterface = dyn_cast<MemoryEffectOpInterface>(op)) {
+    // If the op has side-effects, it cannot be moved.
+    if (!memInterface.hasNoEffect())
+      return false;
+    // If the op does not have recursive side effects, then it can be moved.
+    if (!op->hasTrait<OpTrait::HasRecursiveMemoryEffects>())
+      return true;
+  } else if (!op->hasTrait<OpTrait::HasRecursiveMemoryEffects>()) {
+    // Otherwise, if the op does not implement the memory effect interface and
+    // it does not have recursive side effects, then it cannot be known that the
+    // op is moveable.
+    return false;
+  }
+
+  // Recurse into the regions and ensure that all nested ops can also be moved.
+  for (Region &region : op->getRegions())
+    for (Operation &op : region.getOps())
+      if (!isMemoryEffectFree(&op))
+        return false;
+  return true;
+}
+
+bool mlir::isSpeculatable(Operation *op) {
+  auto conditionallySpeculatable = dyn_cast<ConditionallySpeculatable>(op);
+  if (!conditionallySpeculatable)
+    return false;
+
+  switch (conditionallySpeculatable.getSpeculatability()) {
+  case Speculation::RecursivelySpeculatable:
+    for (Region &region : op->getRegions()) {
+      for (Operation &op : region.getOps())
+        if (!isSpeculatable(&op))
+          return false;
+    }
+    return true;
+
+  case Speculation::Speculatable:
+    return true;
+
+  case Speculation::NotSpeculatable:
+    return false;
+  }
+
+  llvm_unreachable("Unhandled enum in mlir::isSpeculatable!");
+}

mlir/lib/Transforms/CMakeLists.txt

add_mlir_library(MLIRTransforms
   DEPENDS
   MLIRTransformsPassIncGen
 
   LINK_LIBS PUBLIC
   MLIRAnalysis
   MLIRCopyOpInterface
   MLIRLoopLikeInterface
   MLIRPass
+  MLIRSideEffectInterfaces
   MLIRSupport
   MLIRTransformUtils
   )

mlir/lib/Transforms/CSE.cpp

LogicalResult CSE::simplifyOperation(ScopedMapTy &knownValues, Operation *op,
   // Don't simplify operations with nested blocks. We don't currently model
   // equality comparisons correctly among other things. It is also unclear
   // whether we would want to CSE such operations.
   if (op->getNumRegions() != 0)
     return failure();
 
   // Some simple use case of operation with memory side-effect are dealt with
   // here. Operations with no side-effect are done after.
-  if (!MemoryEffectOpInterface::hasNoEffect(op)) {
+  if (!isMemoryEffectFree(op)) {
     auto memEffects = dyn_cast<MemoryEffectOpInterface>(op);
     // TODO: Only basic use case for operations with MemoryEffects::Read can be
     // eleminated now. More work needs to be done for more complicated patterns
     // and other side-effects.
     if (!memEffects || !memEffects.onlyHasEffect<MemoryEffects::Read>())
       return failure();
 
     // Look for an existing definition for the operation.

mlir/lib/Transforms/ControlFlowSink.cpp

 //===----------------------------------------------------------------------===//
 
 #include "mlir/Transforms/Passes.h"
 
 #include "mlir/IR/Dominance.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Transforms/ControlFlowSinkUtils.h"
-#include "mlir/Transforms/SideEffectUtils.h"
 
 namespace mlir {
 #define GEN_PASS_DEF_CONTROLFLOWSINK
 #include "mlir/Transforms/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
 

mlir/lib/Transforms/Inliner.cpp

void CGUseList::eraseNode(CallGraphNode *node) {
   nodeUses.erase(useIt);
   discardableSymNodeUses.erase(node);
 }
 
 bool CGUseList::isDead(CallGraphNode *node) const {
   // If the parent operation isn't a symbol, simply check normal SSA deadness.
   Operation *nodeOp = node->getCallableRegion()->getParentOp();
   if (!isa<SymbolOpInterface>(nodeOp))
-    return MemoryEffectOpInterface::hasNoEffect(nodeOp) && nodeOp->use_empty();
+    return isMemoryEffectFree(nodeOp) && nodeOp->use_empty();
 
   // Otherwise, check the number of symbol uses.
   auto symbolIt = discardableSymNodeUses.find(node);
   return symbolIt != discardableSymNodeUses.end() && symbolIt->second == 0;
 }
 
 bool CGUseList::hasOneUseAndDiscardable(CallGraphNode *node) const {
   // If this isn't a symbol node, check for side-effects and SSA use count.
   Operation *nodeOp = node->getCallableRegion()->getParentOp();
   if (!isa<SymbolOpInterface>(nodeOp))
-    return MemoryEffectOpInterface::hasNoEffect(nodeOp) && nodeOp->hasOneUse();
+    return isMemoryEffectFree(nodeOp) && nodeOp->hasOneUse();
 
   // Otherwise, check the number of symbol uses.
   auto symbolIt = discardableSymNodeUses.find(node);
   return symbolIt != discardableSymNodeUses.end() && symbolIt->second == 1;
 }
 
 void CGUseList::recomputeUses(CallGraphNode *node, CallGraph &cg) {
   Operation *parentOp = node->getCallableRegion()->getParentOp();

mlir/lib/Transforms/LoopInvariantCodeMotion.cpp

 //===- LoopInvariantCodeMotion.cpp - Code to perform loop fusion-----------===//
 //
 // 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 loop invariant code motion.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Transforms/Passes.h"
 
 #include "mlir/Interfaces/LoopLikeInterface.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Transforms/LoopInvariantCodeMotionUtils.h"
-#include "mlir/Transforms/SideEffectUtils.h"
 
 namespace mlir {
 #define GEN_PASS_DEF_LOOPINVARIANTCODEMOTION
 #include "mlir/Transforms/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
 

mlir/lib/Transforms/Utils/CMakeLists.txt

 add_mlir_library(MLIRTransformUtils
   CommutativityUtils.cpp
   ControlFlowSinkUtils.cpp
   DialectConversion.cpp
   FoldUtils.cpp
   GreedyPatternRewriteDriver.cpp
   InliningUtils.cpp
   LoopInvariantCodeMotionUtils.cpp
   RegionUtils.cpp
-  SideEffectUtils.cpp
   TopologicalSortUtils.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Transforms
 
   LINK_LIBS PUBLIC
   MLIRAnalysis
   MLIRLoopLikeInterface
+  MLIRSideEffectInterfaces
   MLIRRewrite
   )

mlir/lib/Transforms/Utils/LoopInvariantCodeMotionUtils.cpp

 //===- LoopInvariantCodeMotionUtils.cpp - LICM Utils ------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the implementation of the core LICM algorithm.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Transforms/LoopInvariantCodeMotionUtils.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Interfaces/LoopLikeInterface.h"
-#include "mlir/Transforms/SideEffectUtils.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "llvm/Support/Debug.h"
 #include <queue>
 
 #define DEBUG_TYPE "licm"
 
 using namespace mlir;
 
 /// Checks whether the given op can be hoisted by checking that

mlir/lib/Transforms/Utils/SideEffectUtils.cpp

-//===- SideEffectUtils.cpp - Side Effect Utils ------------------*- 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
-//
-//===----------------------------------------------------------------------===//
-
-#include "mlir/Transforms/SideEffectUtils.h"
-#include "mlir/IR/Operation.h"
-#include "mlir/Interfaces/SideEffectInterfaces.h"
-
-using namespace mlir;
-
-bool mlir::isMemoryEffectFree(Operation *op) {
-  if (auto memInterface = dyn_cast<MemoryEffectOpInterface>(op)) {
-    // If the op has side-effects, it cannot be moved.
-    if (!memInterface.hasNoEffect())
-      return false;
-    // If the op does not have recursive side effects, then it can be moved.
-    if (!op->hasTrait<OpTrait::HasRecursiveMemoryEffects>())
-      return true;
-  } else if (!op->hasTrait<OpTrait::HasRecursiveMemoryEffects>()) {
-    // Otherwise, if the op does not implement the memory effect interface and
-    // it does not have recursive side effects, then it cannot be known that the
-    // op is moveable.
-    return false;
-  }
-
-  // Recurse into the regions and ensure that all nested ops can also be moved.
-  for (Region &region : op->getRegions())
-    for (Operation &op : region.getOps())
-      if (!isMemoryEffectFree(&op))
-        return false;
-  return true;
-}
-
-bool mlir::isSpeculatable(Operation *op) {
-  auto conditionallySpeculatable = dyn_cast<ConditionallySpeculatable>(op);
-  if (!conditionallySpeculatable)
-    return false;
-
-  switch (conditionallySpeculatable.getSpeculatability()) {
-  case Speculation::RecursivelySpeculatable:
-    for (Region &region : op->getRegions()) {
-      for (Operation &op : region.getOps())
-        if (!isSpeculatable(&op))
-          return false;
-    }
-    return true;
-
-  case Speculation::Speculatable:
-    return true;
-
-  case Speculation::NotSpeculatable:
-    return false;
-  }
-
-  llvm_unreachable("Unhandled enum in mlir::isSpeculatable!");
-}

utils/bazel/llvm-project-overlay/mlir/BUILD.bazel

deps = [
         ":DialectUtils",
         ":FuncDialect",
         ":IR",
         ":MemRefDialect",
         ":Pass",
         ":SCFDialect",
         ":SCFPassIncGen",
         ":SCFUtils",
+        ":SideEffectInterfaces",
         ":Support",
         ":TensorDialect",
         ":TensorTransforms",
         ":TilingInterface",
         ":Transforms",
         "//llvm:Support",
     ],
 )
cc_library(
     hdrs = glob(["include/mlir/Dialect/Affine/Analysis/*.h"]),
     includes = ["include"],
     deps = [
         ":AffineDialect",
         ":Analysis",
         ":ArithDialect",
         ":FuncDialect",
         ":IR",
+        ":SideEffectInterfaces",
         ":Support",
         ":ViewLikeInterface",
         "//llvm:Support",
     ],
 )
 
 cc_library(
     name = "AffineUtils",
deps = [
         ":AffineAnalysis",
         ":AffineDialect",
         ":Analysis",
         ":ArithDialect",
         ":DialectUtils",
         ":FuncDialect",
         ":IR",
         ":SCFDialect",
+        ":SideEffectInterfaces",
         ":Support",
         ":Transforms",
         "//llvm:Support",
     ],
 )
 
 cc_library(
     name = "DataLayoutInterfaces",
deps = [
         ":BufferizationTransforms",
         ":DialectUtils",
         ":FuncDialect",
         ":IR",
         ":LinalgDialect",
         ":MemRefDialect",
         ":Pass",
         ":SCFDialect",
+        ":SideEffectInterfaces",
         ":Support",
         ":TensorDialect",
         ":Transforms",
         ":VectorDialect",
         ":VectorInterfaces",
         ":VectorPassIncGen",
         ":VectorUtils",
         "//llvm:Support",
deps = [
         ":GPUDialect",
         ":GPUPassIncGen",
         ":MemRefDialect",
         ":IR",
         ":Pass",
         ":ROCDLToLLVMIRTranslation",
         ":SCFDialect",
         ":FuncDialect",
+        ":SideEffectInterfaces",
         ":Support",
         ":Transforms",
         ":ToLLVMIRTranslation",
         ":LLVMToLLVMIRTranslation",
         "//llvm:Core",
         "//llvm:MC",
         "//llvm:Support",
         "//llvm:Target",
cc_library(
     includes = ["include"],
     deps = [
         ":Analysis",
         ":ControlFlowInterfaces",
         ":IR",
         ":LoopLikeInterface",
         ":Pass",
         ":Rewrite",
+        ":SideEffectInterfaces",
         ":Support",
         ":TransformUtils",
         ":TransformsPassIncGen",
         "//llvm:Support",
     ],
 )
 
 cc_library(
deps = [
         ":ConversionPassIncGen",
         ":FuncDialect",
         ":GPUDialect",
         ":GPUTransforms",
         ":IR",
         ":MemRefDialect",
         ":Pass",
         ":SCFDialect",
+        ":SideEffectInterfaces",
         ":Support",
         ":TransformUtils",
         ":Transforms",
         "//llvm:Support",
     ],
 )
 
 cc_library(
deps = [
         ":BufferizationDialect",
         ":BufferizationPassIncGen",
         ":ControlFlowInterfaces",
         ":FuncDialect",
         ":IR",
         ":LoopLikeInterface",
         ":MemRefDialect",
         ":Pass",
+        ":SideEffectInterfaces",
         ":TensorDialect",
         ":Transforms",
         ":ViewLikeInterface",
         "//llvm:Support",
     ],
 )
 
 cc_library(