[mlir][SideEffects] Replace HasNoSideEffect with the memory effect interfaces.

[rriddle]

Summary

HasNoSideEffect can now be implemented using the MemoryEffectInterface, removing the need to check multiple things for the same information. This also removes an easy foot-gun for users as 'Operation::hasNoSideEffect' would ignore operations that dynamically, or recursively, have no side effects. This also leads to an immediate improvement in some of the existing users, such as DCE, now that they have access to more information.

Depends On D76020

[mehdi_amini]

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

152

I see this pattern frequently, could it be a static helper on MemoryEffectOpInterface?

bool MemoryEffectOpInterface::hasNoEffect(Operation *);

[rriddle]

Resolve comments

[rriddle]

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

152

Funnily enough, I had that at the beginning but lost it somewhere. Added back.

mlir/docs/Traits.md

 foo.region_op {
   foo.yield %result : i32
 }
 ```
 
 This trait is an important structural property of the IR, and enables operations
 to have [passes](WritingAPass.md) scheduled under them.
 
-### NoSideEffect
-
-*   `OpTrait::HasNoSideEffect` -- `NoSideEffect`
-
-This trait signifies that the operation is pure and has no visible side effects.
-
 ### Single Block with Implicit Terminator
 
 *   `OpTrait::SingleBlockImplicitTerminator<typename TerminatorOpType>` :
     `SingleBlockImplicitTerminator<string op>`
 
 This trait provides APIs and verifiers for operations with regions that have a
 single block that must terminate with `TerminatorOpType`.
 

mlir/docs/Tutorials/Toy/Ch-2.md

 customize its behavior. These traits may provide additional accessors,
 verification, etc.
 
 ```c++
 class ConstantOp : public mlir::Op<ConstantOp,
                      /// The ConstantOp takes no inputs.
                      mlir::OpTrait::ZeroOperands,
                      /// The ConstantOp returns a single result.
-                     mlir::OpTrait::OneResult,
-                     /// The ConstantOp is pure and has no visible side-effects.
-                     mlir::OpTrait::HasNoSideEffect> {
+                     mlir::OpTrait::OneResult> {
 
  public:
   /// Inherit the constructors from the base Op class.
   using Op::Op;
 
   /// Provide the unique name for this operation. MLIR will use this to register
   /// the operation and uniquely identify it throughout the system.
   static llvm::StringRef getOperationName() { return "toy.constant"; }

 ```
 
 With all of the preliminary pieces defined, we can begin to define the constant
 operation.
 
 We define a toy operation by inheriting from our base 'Toy_Op' class above. Here
 we provide the mnemonic and a list of traits for the operation. The
 [mnemonic](../../OpDefinitions.md#operation-name) here matches the one given in
-`ConstantOp::getOperationName` without the dialect prefix; `toy.`. The constant
-operation here is also marked as 'NoSideEffect'. This is an ODS trait, and
-matches one-to-one with the trait we providing when defining `ConstantOp`:
-`mlir::OpTrait::HasNoSideEffect`. Missing here from our C++ definition are the
-`ZeroOperands` and `OneResult` traits; these will be automatically inferred
-based upon the `arguments` and `results` fields we define later.
+`ConstantOp::getOperationName` without the dialect prefix; `toy.`. Missing here
+from our C++ definition are the `ZeroOperands` and `OneResult` traits; these
+will be automatically inferred based upon the `arguments` and `results` fields
+we define later.
 
 ```tablegen
-def ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
+def ConstantOp : Toy_Op<"constant"> {
 }
 ```
 
 At this point you probably might want to know what the C++ code generated by
 TableGen looks like. Simply run the `mlir-tblgen` command with the
 `gen-op-decls` or the `gen-op-defs` action like so:
 
 ```shell

 With the shell of the operation defined, we can now provide the
 [inputs](../../OpDefinitions.md#operation-arguments) and
 [outputs](../../OpDefinitions.md#operation-results) to our operation. The
 inputs, or arguments, to an operation may be attributes or types for SSA operand
 values. The results correspond to a set of types for the values produced by the
 operation:
 
 ```tablegen
-def ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
+def ConstantOp : Toy_Op<"constant"> {
   // The constant operation takes an attribute as the only input.
   // `F64ElementsAttr` corresponds to a 64-bit floating-point ElementsAttr.
   let arguments = (ins F64ElementsAttr:$value);
 
   // The constant operation returns a single value of TensorType.
   // F64Tensor corresponds to a 64-bit floating-point TensorType.
   let results = (outs F64Tensor);
 }
 ```
 
 By providing a name to the arguments or results, e.g. `$value`, ODS will
 automatically generate a matching accessor: `DenseElementsAttr
 ConstantOp::value()`.
 
 #### Adding Documentation
 
 The next step after defining the operation is to document it. Operations may
 provide
 [`summary` and `description`](../../OpDefinitions.md#operation-documentation)
 fields to describe the semantics of the operation. This information is useful
 for users of the dialect and can even be used to auto-generate Markdown
 documents.
 
 ```tablegen
-def ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
+def ConstantOp : Toy_Op<"constant"> {
   // Provide a summary and description for this operation. This can be used to
   // auto-generate documentation of the operations within our dialect.
   let summary = "constant operation";
   let description = [{
     Constant operation turns a literal into an SSA value. The data is attached
     to the operation as an attribute. For example:
 
       %0 = "toy.constant"()

 input attribute `value`. In many cases, additional verification is not even
 necessary for ODS operations. To add additional verification logic, an operation
 can override the [`verifier`](../../OpDefinitions.md#custom-verifier-code)
 field. The `verifier` field allows for defining a C++ code blob that will be run
 as part of `ConstantOp::verify`. This blob can assume that all of the other
 invariants of the operation have already been verified:
 
 ```tablegen
-def ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
+def ConstantOp : Toy_Op<"constant"> {
   // Provide a summary and description for this operation. This can be used to
   // auto-generate documentation of the operations within our dialect.
   let summary = "constant operation";
   let description = [{
     Constant operation turns a literal into an SSA value. The data is attached
     to the operation as an attribute. For example:
 
       %0 = "toy.constant"()

 methods. ODS can generate some simple build methods automatically, and in this
 case it will generate our first build method for us. For the rest, we define the
 [`builders`](../../OpDefinitions.md#custom-builder-methods) field. This field
 takes a list of `OpBuilder` objects that take a string corresponding to a list
 of C++ parameters, as well as an optional code block that can be used to specify
 the implementation inline.
 
 ```tablegen
-def ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
+def ConstantOp : Toy_Op<"constant"> {
   ...
 
   // Add custom build methods for the constant operation. These methods populate
   // the `state` that MLIR uses to create operations, i.e. these are used when
   // using `builder.create<ConstantOp>(...)`.
   let builders = [
     // Build a constant with a given constant tensor value.
     OpBuilder<"Builder *builder, OperationState &result, "

mlir/include/mlir/IR/Operation.h

public:
 
   /// Returns whether the operation is commutative.
   bool isCommutative() {
     if (auto *absOp = getAbstractOperation())
       return absOp->hasProperty(OperationProperty::Commutative);
     return false;
   }
 
-  /// Returns whether the operation has side-effects.
-  bool hasNoSideEffect() {
-    if (auto *absOp = getAbstractOperation())
-      return absOp->hasProperty(OperationProperty::NoSideEffect);
-    return false;
-  }
-
   /// Represents the status of whether an operation is a terminator. We
   /// represent an 'unknown' status because we want to support unregistered
   /// terminators.
   enum class TerminatorStatus { Terminator, NonTerminator, Unknown };
 
   /// Returns the status of whether this operation is a terminator or not.
   TerminatorStatus getTerminatorStatus() {
     if (auto *absOp = getAbstractOperation()) {

mlir/include/mlir/IR/OperationSupport.h

 enum class OperationProperty {
   /// This bit is set for an operation if it is a commutative
   /// operation: that is an operator where order of operands does not
   /// change the result of the operation.  For example, in a binary
   /// commutative operation, "a op b" and "b op a" produce the same
   /// results.
   Commutative = 0x1,
 
-  /// This bit is set for operations that have no side effects: that means that
-  /// they do not read or write memory, or access any hidden state.
-  NoSideEffect = 0x2,
-
   /// This bit is set for an operation if it is a terminator: that means
   /// an operation at the end of a block.
-  Terminator = 0x4,
+  Terminator = 0x2,
 
   /// This bit is set for operations that are completely isolated from above.
   /// This is used for operations whose regions are explicit capture only, i.e.
   /// they are never allowed to implicitly reference values defined above the
   /// parent operation.
-  IsolatedFromAbove = 0x8,
+  IsolatedFromAbove = 0x4,
 };
 
 /// This is a "type erased" representation of a registered operation.  This
 /// should only be used by things like the AsmPrinter and other things that need
 /// to be parameterized by generic operation hooks.  Most user code should use
 /// the concrete operation types.
 class AbstractOperation {
 public:

mlir/include/mlir/Interfaces/SideEffects.h

 };
 } // namespace SideEffects
 
 //===----------------------------------------------------------------------===//
 // SideEffect Traits
 //===----------------------------------------------------------------------===//
 
 namespace OpTrait {
-/// This trait indicates that an operation never has side effects.
-template <typename ConcreteType>
-class HasNoSideEffect : public TraitBase<ConcreteType, HasNoSideEffect> {
-public:
-  static AbstractOperation::OperationProperties getTraitProperties() {
-    return static_cast<AbstractOperation::OperationProperties>(
-        OperationProperty::NoSideEffect);
-  }
-};
 /// This trait indicates that the side effects of an operation includes the
 /// effects of operations nested within its regions. If the operation has no
 /// derived effects interfaces, the operation itself can be assumed to have no
 /// side effects.
 template <typename ConcreteType>
 class HasRecursiveSideEffects
     : public TraitBase<ConcreteType, HasRecursiveSideEffects> {};
 } // namespace OpTrait

 /// The following effect indicates that the operation writes to some resource. A
 /// 'write' effect implies only mutating a resource, and not any visible
 /// dereference or read.
 struct Write : public Effect::Base<Write> {};
 } // namespace MemoryEffects
 
 //===----------------------------------------------------------------------===//
 // SideEffect Interfaces
+//===----------------------------------------------------------------------===//
 
 /// Include the definitions of the side effect interfaces.
 #include "mlir/Interfaces/SideEffectInterfaces.h.inc"
 
+//===----------------------------------------------------------------------===//
+// SideEffect Utilities
+//===----------------------------------------------------------------------===//
+
+/// Return true if the given operation is unused, and has no side effects on
+/// 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);
+
 } // end namespace mlir
 
 #endif // MLIR_INTERFACES_SIDEEFFECTS_H

mlir/include/mlir/Interfaces/SideEffects.td

let extraClassDeclaration = [{
     }
 
     /// Returns if this operation has no effects.
     bool hasNoEffect() {
       SmallVector<SideEffects::EffectInstance<}] # baseEffect # [{>, 4> effects;
       getEffects(effects);
       return effects.empty();
     }
+
+    /// Returns 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<OpTrait::HasRecursiveSideEffects>();
+    }
   }];
 
   // The base effect name of this interface.
   string baseEffectName = baseEffect;
 }
 
 // This class is the general base side effect class. This is used by derived
 // effect interfaces to define their effects.
 class SideEffect<EffectOpInterfaceBase interface, string effectName,
                  string resourceName> : OpVariableDecorator {
-  /// The parent interface that the effect belongs to.
-  string interfaceTrait = interface.trait;
-
   /// The name of the base effects class.
-  string baseEffect = interface.baseEffectName;
+  string baseEffectName = interface.baseEffectName;
 
   /// The derived effect that is being applied.
   string effect = effectName;
 
   /// The resource that the effect is being applied to.
   string resource = resourceName;
 }
 
 // This class is the base used for specifying effects applied to an operation.
 class SideEffectsTraitBase<EffectOpInterfaceBase parentInterface,
                            list<SideEffect> staticEffects>
     : OpInterfaceTrait<""> {
   /// The name of the interface trait to use.
   let trait = parentInterface.trait;
 
+  /// The name of the base effects class.
+  string baseEffectName = parentInterface.baseEffectName;
+
   /// The derived effects being applied.
   list<SideEffect> effects = staticEffects;
 }
 
 //===----------------------------------------------------------------------===//
 // MemoryEffects
 //===----------------------------------------------------------------------===//
 
class MemWrite<string resourceName>
   : MemoryEffect<"MemoryEffects::Write", resourceName>;
 def MemWrite : MemWrite<"">;
 
 //===----------------------------------------------------------------------===//
 // Effect Traits
 //===----------------------------------------------------------------------===//
 
 // Op has no side effect.
-def NoSideEffect : NativeOpTrait<"HasNoSideEffect">;
+def NoSideEffect : MemoryEffects<[]>;
 // Op has recursively computed side effects.
 def RecursiveSideEffects : NativeOpTrait<"HasRecursiveSideEffects">;
 
 #endif // MLIR_INTERFACES_SIDEEFFECTS

mlir/include/mlir/TableGen/SideEffects.h

 // This class represents a specific instance of an effect that is being
 // exhibited.
 class SideEffect : public Operator::VariableDecorator {
 public:
   // Return the name of the C++ effect.
   StringRef getName() const;
 
   // Return the name of the base C++ effect.
-  StringRef getBaseName() const;
-
-  // Return the name of the parent interface trait.
-  StringRef getInterfaceTrait() const;
+  StringRef getBaseEffectName() const;
 
   // Return the name of the resource class.
   StringRef getResource() const;
 
   static bool classof(const Operator::VariableDecorator *var);
 };
 
 // This class represents an instance of a side effect interface applied to an
 // operation. This is a wrapper around an OpInterfaceTrait that also includes
 // the effects that are applied.
 class SideEffectTrait : public InterfaceOpTrait {
 public:
   // Return the effects that are attached to the side effect interface.
   Operator::var_decorator_range getEffects() const;
 
+  // Return the name of the base C++ effect.
+  StringRef getBaseEffectName() const;
+
   static bool classof(const OpTrait *t);
 };
 
 } // end namespace tblgen
 } // end namespace mlir
 
 #endif // MLIR_TABLEGEN_SIDEEFFECTS_H_

mlir/include/mlir/Transforms/FoldUtils.h

create(OpBuilder &builder, Location location, Args &&... args) {
     SmallVector<Value, 0> unused;
     (void)tryToFold(op.getOperation(), unused);
 
     // Folding cannot remove a zero-result operation, so for convenience we
     // continue to return it.
     return op;
   }
 
+  /// Clear out any constants cached inside of the folder.
+  void clear();
+
 private:
   /// This map keeps track of uniqued constants by dialect, attribute, and type.
   /// A constant operation materializes an attribute with a type. Dialects may
   /// generate different constants with the same input attribute and type, so we
   /// also need to track per-dialect.
   using ConstantMap =
       DenseMap<std::tuple<Dialect *, Attribute, Type>, Operation *>;
 

mlir/lib/Analysis/Utils.cpp

if (auto innerFor = dyn_cast<AffineForOp>(op))
         sequentialLoops->insert(innerFor.getInductionVar());
   });
 }
 
 /// Returns true if 'forOp' is parallel.
 bool mlir::isLoopParallel(AffineForOp forOp) {
   // Collect all load and store ops in loop nest rooted at 'forOp'.
   SmallVector<Operation *, 8> loadAndStoreOpInsts;
-  auto walkResult = forOp.walk([&](Operation *opInst) {
+  auto walkResult = forOp.walk([&](Operation *opInst) -> WalkResult {
     if (isa<AffineLoadOp>(opInst) || isa<AffineStoreOp>(opInst))
       loadAndStoreOpInsts.push_back(opInst);
     else if (!isa<AffineForOp>(opInst) && !isa<AffineTerminatorOp>(opInst) &&
-             !isa<AffineIfOp>(opInst) && !opInst->hasNoSideEffect())
+             !isa<AffineIfOp>(opInst) &&
+             !MemoryEffectOpInterface::hasNoEffect(opInst))
       return WalkResult::interrupt();
 
     return WalkResult::advance();
   });
 
   // Stop early if the loop has unknown ops with side effects.
   if (walkResult.wasInterrupted())
     return false;

mlir/lib/Conversion/LoopsToGPU/LoopsToGPU.cpp

if (auto nestedParallel = dyn_cast<ParallelOp>(op)) {
       rewriter.setInsertionPointAfter(parent);
       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.
-      seenSideeffects |= !clone->hasNoSideEffect();
+      // TODO: Handle region side effects properly.
+      seenSideeffects |= !MemoryEffectOpInterface::hasNoEffect(clone) ||
+                         clone->getNumRegions() != 0;
       // If we are no longer in the innermost scope, sideeffects are disallowed.
       if (seenSideeffects && leftNestingScope)
         return matchFailure();
     }
   }
 
   // Now that we succeeded creating the launch operation, also update the
   // bounds.

mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp

if (!op.hasBufferSemantics())
       return;
     auto opLoopsPair =
         tileLinalgOpImpl<LoopTy>(b, op, tileSizes, /*permutation=*/{}, &folder);
     // If tiling occurred successfully, erase old op.
     if (opLoopsPair)
       op.erase();
   });
   f.walk([](LinalgOp op) {
-    if (!op.getOperation()->hasNoSideEffect())
-      return;
-    if (op.getOperation()->use_empty())
+    if (isOpTriviallyDead(op))
       op.erase();
   });
 }
 
 namespace {
 
 template <typename LoopTy>
 struct LinalgTilingPass : public FunctionPass<LinalgTilingPass<LoopTy>> {

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

static void fuseIfLegal(ParallelOp firstPloop, ParallelOp secondPloop,
   for (auto &op : firstPloop.getBody()->without_terminator())
     b.clone(op, firstToSecondPloopIndices);
   firstPloop.erase();
 }
 
 void mlir::loop::naivelyFuseParallelOps(Region &region) {
   OpBuilder b(region);
   // Consider every single block and attempt to fuse adjacent loops.
-  for (auto &block : region.getBlocks()) {
+  for (auto &block : region) {
     SmallVector<SmallVector<ParallelOp, 8>, 1> ploopChains{{}};
     // Not using `walk()` to traverse only top-level parallel loops and also
     // make sure that there are no side-effecting ops between the parallel
     // loops.
     bool noSideEffects = true;
-    for (auto &op : block.getOperations()) {
+    for (auto &op : block) {
       if (auto ploop = dyn_cast<ParallelOp>(op)) {
         if (noSideEffects) {
           ploopChains.back().push_back(ploop);
         } else {
           ploopChains.push_back({ploop});
           noSideEffects = true;
         }
         continue;
       }
-      noSideEffects &= op.hasNoSideEffect();
+      // TODO: Handle region side effects properly.
+      noSideEffects &=
+          MemoryEffectOpInterface::hasNoEffect(&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/Interfaces/SideEffects.cpp

 //===----------------------------------------------------------------------===//
 // MemoryEffects
 //===----------------------------------------------------------------------===//
 
 bool MemoryEffects::Effect::classof(const SideEffects::Effect *effect) {
   return isa<Allocate>(effect) || isa<Free>(effect) || isa<Read>(effect) ||
          isa<Write>(effect);
 }
+
+//===----------------------------------------------------------------------===//
+// SideEffect Utilities
+//===----------------------------------------------------------------------===//
+
+bool mlir::isOpTriviallyDead(Operation *op) {
+  return op->use_empty() && wouldOpBeTriviallyDead(op);
+}
+
+/// Internal implementation of `mlir::wouldOpBeTriviallyDead` that also
+/// considers terminator operations as dead if they have no side effects. This
+/// allows for marking region operations as trivially dead without always being
+/// conservative of terminators.
+static bool wouldOpBeTriviallyDeadImpl(Operation *rootOp) {
+  // The set of operations to consider when checking for side effects.
+  SmallVector<Operation *, 1> effectingOps(1, rootOp);
+  while (!effectingOps.empty()) {
+    Operation *op = effectingOps.pop_back_val();
+
+    // If the operation has recursive effects, push all of the nested operations
+    // on to the stack to consider.
+    bool hasRecursiveEffects = op->hasTrait<OpTrait::HasRecursiveSideEffects>();
+    if (hasRecursiveEffects) {
+      for (Region &region : op->getRegions()) {
+        for (auto &block : region) {
+          for (auto &nestedOp : block)
+            effectingOps.push_back(&nestedOp);
+        }
+      }
+    }
+
+    // If the op has memory effects, try to characterize them to see if the op
+    // is trivially dead here.
+    if (auto effectInterface = dyn_cast<MemoryEffectOpInterface>(op)) {
+      // Check to see if this op either has no effects, or only allocates/reads
+      // memory.
+      SmallVector<MemoryEffects::EffectInstance, 1> effects;
+      effectInterface.getEffects(effects);
+      if (!llvm::all_of(effects, [](const auto &it) {
+            return isa<MemoryEffects::Read>(it.getEffect()) ||
+                   isa<MemoryEffects::Allocate>(it.getEffect());
+          })) {
+        return false;
+      }
+      continue;
+
+      // Otherwise, if the op has recursive side effects we can treat the
+      // operation itself as having no effects.
+    } else if (hasRecursiveEffects) {
+      continue;
+    }
+
+    // If there were no effect interfaces, we treat this op as conservatively
+    // having effects.
+    return false;
+  }
+
+  // If we get here, none of the operations had effects that prevented marking
+  // 'op' as dead.
+  return true;
+}
+
+bool mlir::wouldOpBeTriviallyDead(Operation *op) {
+  if (!op->isKnownNonTerminator())
+    return false;
+  return wouldOpBeTriviallyDeadImpl(op);
+}

mlir/lib/TableGen/SideEffects.cpp

 //===----------------------------------------------------------------------===//
 // SideEffect
 //===----------------------------------------------------------------------===//
 
 StringRef SideEffect::getName() const {
   return def->getValueAsString("effect");
 }
 
-StringRef SideEffect::getBaseName() const {
-  return def->getValueAsString("baseEffect");
-}
-
-StringRef SideEffect::getInterfaceTrait() const {
-  return def->getValueAsString("interfaceTrait");
+StringRef SideEffect::getBaseEffectName() const {
+  return def->getValueAsString("baseEffectName");
 }
 
 StringRef SideEffect::getResource() const {
   auto value = def->getValueAsString("resource");
   return value.empty() ? "::mlir::SideEffects::DefaultResource" : value;
 }
 
 bool SideEffect::classof(const Operator::VariableDecorator *var) {
   return var->getDef().isSubClassOf("SideEffect");
 }
 
 //===----------------------------------------------------------------------===//
 // SideEffectsTrait
 //===----------------------------------------------------------------------===//
 
 Operator::var_decorator_range SideEffectTrait::getEffects() const {
   auto *listInit = dyn_cast<llvm::ListInit>(def->getValueInit("effects"));
   return {listInit->begin(), listInit->end()};
 }
 
+StringRef SideEffectTrait::getBaseEffectName() const {
+  return def->getValueAsString("baseEffectName");
+}
+
 bool SideEffectTrait::classof(const OpTrait *t) {
   return t->getDef().isSubClassOf("SideEffectsTraitBase");
 }

mlir/lib/Transforms/CSE.cpp

 } // end anonymous namespace
 
 /// Attempt to eliminate a redundant operation.
 LogicalResult CSE::simplifyOperation(ScopedMapTy &knownValues, Operation *op) {
   // Don't simplify terminator operations.
   if (op->isKnownTerminator())
     return failure();
 
+  // If the operation is already trivially dead just add it to the erase list.
+  if (isOpTriviallyDead(op)) {
+    opsToErase.push_back(op);
+    ++numDCE;
+    return success();
+  }
+
   // 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();
 
   // TODO(riverriddle) We currently only eliminate non side-effecting
   // operations.
-  if (!op->hasNoSideEffect())
+  if (!MemoryEffectOpInterface::hasNoEffect(op))
     return failure();
 
-  // If the operation is already trivially dead just add it to the erase list.
-  if (op->use_empty()) {
-    opsToErase.push_back(op);
-    ++numDCE;
-    return success();
-  }
-
   // Look for an existing definition for the operation.
   if (auto *existing = knownValues.lookup(op)) {
     // If we find one then replace all uses of the current operation with the
     // existing one and mark it for deletion.
     op->replaceAllUsesWith(existing);
     opsToErase.push_back(op);
 
     // If the existing operation has an unknown location and the current

mlir/lib/Transforms/LoopInvariantCodeMotion.cpp

static bool canBeHoisted(Operation *op,
   if (!llvm::all_of(op->getOperands(), definedOutside))
     return false;
   // Check whether this op is side-effect free. If we already know that there
   // can be no side-effects because the surrounding op has claimed so, we can
   // (and have to) skip this step.
   if (auto memInterface = dyn_cast<MemoryEffectOpInterface>(op)) {
     if (!memInterface.hasNoEffect())
       return false;
-  } else if (!op->hasNoSideEffect() &&
-             !op->hasTrait<OpTrait::HasRecursiveSideEffects>()) {
-    return false;
-  }
-
     // If the operation doesn't have side effects and it doesn't recursively
     // have side effects, it can always be hoisted.
     if (!op->hasTrait<OpTrait::HasRecursiveSideEffects>())
       return true;
 
+    // Otherwise, if the operation doesn't provide the memory effect interface
+    // and it doesn't have recursive side effects we treat it conservatively as
+    // side-effecting.
+  } else if (!op->hasTrait<OpTrait::HasRecursiveSideEffects>()) {
+    return false;
+  }
+
   // Recurse into the regions for this op and check whether the contained ops
   // can be hoisted.
   for (auto &region : op->getRegions()) {
     for (auto &block : region.getBlocks()) {
       for (auto &innerOp : block.without_terminator())
         if (!canBeHoisted(&innerOp, definedOutside))
           return false;
     }

mlir/lib/Transforms/Utils/FoldUtils.cpp

void OperationFolder::notifyRemoval(Operation *op) {
 
   // Erase all of the references to this operation.
   auto type = op->getResult(0).getType();
   for (auto *dialect : it->second)
     uniquedConstants.erase(std::make_tuple(dialect, constValue, type));
   referencedDialects.erase(it);
 }
 
+/// Clear out any constants cached inside of the folder.
+void OperationFolder::clear() {
+  foldScopes.clear();
+  referencedDialects.clear();
+}
+
 /// Tries to perform folding on the given `op`. If successful, populates
 /// `results` with the results of the folding.
 LogicalResult OperationFolder::tryToFold(
     Operation *op, SmallVectorImpl<Value> &results,
     function_ref<void(Operation *)> processGeneratedConstants) {
   SmallVector<Attribute, 8> operandConstants;
   SmallVector<OpFoldResult, 8> foldResults;
 

mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp

 //===- GreedyPatternRewriteDriver.cpp - A greedy rewriter -----------------===//
 //
 // 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 mlir::applyPatternsGreedily.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/StandardOps/IR/Ops.h"
-#include "mlir/IR/Builders.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/Interfaces/SideEffects.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
do {
     while (!worklist.empty()) {
       auto *op = popFromWorklist();
 
       // Nulls get added to the worklist when operations are removed, ignore
       // them.
       if (op == nullptr)
         continue;
 
-      // If the operation has no side effects, and no users, then it is
-      // trivially dead - remove it.
-      if (op->isKnownNonTerminator() && op->hasNoSideEffect() &&
-          op->use_empty()) {
-        // Be careful to update bookkeeping.
+      // If the operation is trivially dead - remove it.
+      if (isOpTriviallyDead(op)) {
         notifyOperationRemoved(op);
         op->erase();
         continue;
       }
 
       // Collects all the operands and result uses of the given `op` into work
       // list. Also remove `op` and nested ops from worklist.
       originalOperands.assign(op->operand_begin(), op->operand_end());
while (!worklist.empty()) {
 
       // Try to match one of the patterns. The rewriter is automatically
       // notified of any necessary changes, so there is nothing else to do here.
       changed |= matcher.matchAndRewrite(op, *this);
     }
 
     // After applying patterns, make sure that the CFG of each of the regions is
     // kept up to date.
-    changed |= succeeded(simplifyRegions(regions));
+    if (succeeded(simplifyRegions(regions))) {
+      folder.clear();
+      changed = true;
+    }
   } while (changed && ++i < maxIterations);
   // Whether the rewrite converges, i.e. wasn't changed in the last iteration.
   return !changed;
 }
 
 /// Rewrite the regions of the specified operation, which must be isolated from
 /// above, by repeatedly applying the highest benefit patterns in a greedy
 /// work-list driven manner. Return true if no more patterns can be matched in

mlir/lib/Transforms/Utils/LoopUtils.cpp

if (op.getNumRegions() > 0)
       continue;
     // Skip other ops with regions.
     if (op.getNumRegions() > 0) {
       status = failure();
       continue;
     }
     // Skip if op has side effects.
     // TODO(ntv): loads to immutable memory regions are ok.
-    if (!op.hasNoSideEffect()) {
+    if (!MemoryEffectOpInterface::hasNoEffect(&op)) {
       status = failure();
       continue;
     }
     toHoist.push_back(&op);
   }
   auto *outerForOp = outer.getOperation();
   for (auto *op : toHoist)
     op->moveBefore(outerForOp);

mlir/lib/Transforms/Utils/RegionUtils.cpp

 //===- RegionUtils.cpp - Region-related transformation utilities ----------===//
 //
 // 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/RegionUtils.h"
 #include "mlir/IR/Block.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/RegionGraphTraits.h"
 #include "mlir/IR/Value.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
+#include "mlir/Interfaces/SideEffects.h"
 
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SmallSet.h"
 
 using namespace mlir;
 
 void mlir::replaceAllUsesInRegionWith(Value orig, Value replacement,
if (provedLive)
     liveMap.setProvedLive(value);
 }
 
 static bool isOpIntrinsicallyLive(Operation *op) {
   // This pass doesn't modify the CFG, so terminators are never deleted.
   if (!op->isKnownNonTerminator())
     return true;
   // If the op has a side effect, we treat it as live.
-  if (!op->hasNoSideEffect())
-    return true;
-  return false;
+  // TODO: Properly handle region side effects.
+  return !MemoryEffectOpInterface::hasNoEffect(op) || op->getNumRegions() != 0;
 }
 
 static void propagateLiveness(Region &region, LiveMap &liveMap);
 
 static void propagateTerminatorLiveness(Operation *op, LiveMap &liveMap) {
   // Terminators are always live.
   liveMap.setProvedLive(op);
 

mlir/test/Transforms/canonicalize.mlir

affine.for %arg4 = 0 to %ub {
       %sv = subview %0[%c0, %c0][%s,%arg4][%c1,%c1] : memref<?x?xf32> to memref<?x?xf32, #map1>
       %l = dim %v, 1 : memref<?x?xf32, #map1>
       %u = dim %sv, 0 : memref<?x?xf32, #map1>
       affine.for %arg5 = %l to %u {
         "foo"() : () -> ()
       }
     }
   }
-  // CHECK-NEXT: %c0 = constant 0 : index
-  // CHECK-NEXT: %c1 = constant 1 : index
   // CHECK-NEXT: affine.for %arg7 = 0 to %arg2 {
   // CHECK-NEXT:   affine.for %arg8 = 0 to %arg0 {
   // CHECK-NEXT:     affine.for %arg9 = %arg0 to %arg0 {
   // CHECK-NEXT:       "foo"() : () -> ()
   // CHECK-NEXT:     }
   // CHECK-NEXT:   }
   // CHECK-NEXT: }
 
   %A = view %BUF[%c0][%M, %K] : memref<?xi8> to memref<?x?xf32, offset: ?, strides: [?, 1]>
   %B = view %BUF[%c0][%K, %N] : memref<?xi8> to memref<?x?xf32, offset: ?, strides: [?, 1]>
   %C = view %BUF[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32, offset: ?, strides: [?, 1]>
 
   %M_ = dim %A, 0 : memref<?x?xf32, offset: ?, strides: [?, 1]>
   %K_ = dim %A, 1 : memref<?x?xf32, offset: ?, strides: [?, 1]>
   %N_ = dim %C, 1 : memref<?x?xf32, offset: ?, strides: [?, 1]>
   loop.for %i = %c0 to %M_ step %c1 {
     loop.for %j = %c0 to %N_ step %c1 {
       loop.for %k = %c0 to %K_ step %c1 {
       }
     }
   }
-  // CHECK: loop.for %{{.*}} = %c0 to %[[M]] step %c1 {
-  // CHECK:   loop.for %arg8 = %c0 to %[[N]] step %c1 {
-  // CHECK:     loop.for %arg9 = %c0 to %[[K]] step %c1 {
+  // CHECK-NEXT: return
   return
 }
 
 // CHECK-LABEL: func @merge_constants
 func @merge_constants() -> (index, index) {
   // CHECK-NEXT: %c42 = constant 42 : index
   %0 = constant 42 : index
   %1 = constant 42 : index

mlir/test/mlir-tblgen/op-decl.td

 // RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck --dump-input-on-failure %s
 
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/SideEffects.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "NS";
 }
 class NS_Op<string mnemonic, list<OpTrait> traits> :
     Op<Test_Dialect, mnemonic, traits>;
 
-// NoSideEffect trait is included twice to ensure it gets uniqued during
+// IsolatedFromAbove trait is included twice to ensure it gets uniqued during
 // emission.
-def NS_AOp : NS_Op<"a_op", [NoSideEffect, NoSideEffect]> {
+def NS_AOp : NS_Op<"a_op", [IsolatedFromAbove, IsolatedFromAbove]> {
   let arguments = (ins
     I32:$a,
     Variadic<F32>:$b,
 
     I32Attr:$attr1,
     OptionalAttr<F32Attr>:$attr2
   );
 

 // CHECK:   AOpOperandAdaptor(ArrayRef<Value> values);
 // CHECK:   ArrayRef<Value> getODSOperands(unsigned index);
 // CHECK:   Value a();
 // CHECK:   ArrayRef<Value> b();
 // CHECK: private:
 // CHECK:   ArrayRef<Value> tblgen_operands;
 // CHECK: };
 
-// CHECK: class AOp : public Op<AOp, OpTrait::AtLeastNResults<1>::Impl, OpTrait::ZeroSuccessor, OpTrait::AtLeastNOperands<1>::Impl, OpTrait::HasNoSideEffect
+// CHECK: class AOp : public Op<AOp, OpTrait::AtLeastNResults<1>::Impl, OpTrait::ZeroSuccessor, OpTrait::AtLeastNOperands<1>::Impl, OpTrait::IsIsolatedFromAbove
+// CHECK-NOT: OpTrait::IsIsolatedFromAbove
 // CHECK: public:
 // CHECK:   using Op::Op;
 // CHECK:   using OperandAdaptor = AOpOperandAdaptor;
 // CHECK:   static StringRef getOperationName();
 // CHECK:   Operation::operand_range getODSOperands(unsigned index);
 // CHECK:   Value a();
 // CHECK:   Operation::operand_range b();
 // CHECK:   Operation::result_range getODSResults(unsigned index);

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

struct EffectLocation {
     unsigned kind : 2;
   };
 
   StringMap<SmallVector<EffectLocation, 1>> interfaceEffects;
   auto resolveDecorators = [&](Operator::var_decorator_range decorators,
                                unsigned index, unsigned kind) {
     for (auto decorator : decorators)
       if (SideEffect *effect = dyn_cast<SideEffect>(&decorator))
-        interfaceEffects[effect->getInterfaceTrait()].push_back(
+        interfaceEffects[effect->getBaseEffectName()].push_back(
             EffectLocation{*effect, index, kind});
   };
 
   // Collect effects that were specified via:
   /// Traits.
-  for (const auto &trait : op.getTraits())
-    if (const auto *opTrait = dyn_cast<tblgen::SideEffectTrait>(&trait))
-      resolveDecorators(opTrait->getEffects(), /*index=*/0, EffectKind::Static);
+  for (const auto &trait : op.getTraits()) {
+    const auto *opTrait = dyn_cast<tblgen::SideEffectTrait>(&trait);
+    if (!opTrait)
+      continue;
+    auto &effects = interfaceEffects[opTrait->getBaseEffectName()];
+    for (auto decorator : opTrait->getEffects())
+      effects.push_back(EffectLocation{cast<SideEffect>(decorator),
+                                       /*index=*/0, EffectKind::Static});
+  }
   /// Operands.
   for (unsigned i = 0, operandIt = 0, e = op.getNumArgs(); i != e; ++i) {
     if (op.getArg(i).is<NamedTypeConstraint *>()) {
       resolveDecorators(op.getArgDecorators(i), operandIt, EffectKind::Operand);
       ++operandIt;
     }
   }
   /// Results.
   for (unsigned i = 0, e = op.getNumResults(); i != e; ++i)
     resolveDecorators(op.getResultDecorators(i), i, EffectKind::Result);
 
   for (auto &it : interfaceEffects) {
-    StringRef baseEffect = it.second.front().effect.getBaseName();
     auto effectsParam =
         llvm::formatv(
             "SmallVectorImpl<SideEffects::EffectInstance<{0}>> &effects",
-            baseEffect)
+            it.first())
             .str();
 
     // Generate the 'getEffects' method.
     auto &getEffects = opClass.newMethod("void", "getEffects", effectsParam);
     auto &body = getEffects.body();
 
     // Add effect instances for each of the locations marked on the operation.
     for (auto &location : it.second) {