[mlir][NFC] Move the interfaces and traits for side effects out of IR/ to Interfaces/

[rriddle]

Summary

Interfaces/ is the designated directory for these types of interfaces, and also removes the need for including them directly in IR/.

Depends On D75867

[rriddle]

Rebase

mlir/examples/toy/Ch2/CMakeLists.txt

add_toy_chapter(toyc-ch2
   )
 include_directories(include/)
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/include/)
 target_link_libraries(toyc-ch2
   PRIVATE
     MLIRAnalysis
     MLIRIR
     MLIRParser
+    MLIRSideEffects
     MLIRTransforms)

mlir/examples/toy/Ch2/include/toy/Dialect.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Function.h"
+#include "mlir/Interfaces/SideEffects.h"
 
 namespace mlir {
 namespace toy {
 
 /// This is the definition of the Toy dialect. A dialect inherits from
 /// mlir::Dialect and registers custom attributes, operations, and types (in its
 /// constructor). It can also override some general behavior exposed via virtual
 /// methods.

mlir/examples/toy/Ch3/CMakeLists.txt

 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/include/)
 target_link_libraries(toyc-ch3
   PRIVATE
     MLIRAnalysis
     MLIRIR
     MLIRParser
     MLIRPass
+    MLIRSideEffects
     MLIRTransforms)
 

mlir/examples/toy/Ch3/include/toy/Dialect.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Function.h"
+#include "mlir/Interfaces/SideEffects.h"
 
 namespace mlir {
 namespace toy {
 
 /// This is the definition of the Toy dialect. A dialect inherits from
 /// mlir::Dialect and registers custom attributes, operations, and types (in its
 /// constructor). It can also override some general behavior exposed via virtual
 /// methods.

mlir/examples/toy/Ch4/CMakeLists.txt

 include_directories(${CMAKE_CURRENT_BINARY_DIR}/include/)
 target_link_libraries(toyc-ch4
   PRIVATE
     MLIRAnalysis
     MLIRCallInterfaces
     MLIRIR
     MLIRParser
     MLIRPass
+    MLIRSideEffects
     MLIRTransforms)
 

mlir/examples/toy/Ch4/include/toy/Dialect.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/StandardTypes.h"
+#include "mlir/Interfaces/SideEffects.h"
 #include "toy/ShapeInferenceInterface.h"
 
 namespace mlir {
 namespace toy {
 
 /// This is the definition of the Toy dialect. A dialect inherits from
 /// mlir::Dialect and registers custom attributes, operations, and types (in its
 /// constructor). It can also override some general behavior exposed via virtual

mlir/examples/toy/Ch5/CMakeLists.txt

 target_link_libraries(toyc-ch5
   PRIVATE
     ${dialect_libs}
     MLIRAnalysis
     MLIRCallInterfaces
     MLIRIR
     MLIRParser
     MLIRPass
+    MLIRSideEffects
     MLIRSupport
     MLIRTransforms)

mlir/examples/toy/Ch5/include/toy/Dialect.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/StandardTypes.h"
+#include "mlir/Interfaces/SideEffects.h"
 #include "toy/ShapeInferenceInterface.h"
 
 namespace mlir {
 namespace toy {
 
 /// This is the definition of the Toy dialect. A dialect inherits from
 /// mlir::Dialect and registers custom attributes, operations, and types (in its
 /// constructor). It can also override some general behavior exposed via virtual

mlir/examples/toy/Ch6/CMakeLists.txt

PRIVATE
     ${conversion_libs}
     MLIRAnalysis
     MLIRCallInterfaces
     MLIRExecutionEngine
     MLIRIR
     MLIRLLVMIR
     MLIRParser
     MLIRPass
+    MLIRSideEffects
     MLIRSupport
     MLIRTargetLLVMIR
     MLIRTransforms
     )

mlir/examples/toy/Ch6/include/toy/Dialect.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/StandardTypes.h"
+#include "mlir/Interfaces/SideEffects.h"
 #include "toy/ShapeInferenceInterface.h"
 
 namespace mlir {
 namespace toy {
 
 /// This is the definition of the Toy dialect. A dialect inherits from
 /// mlir::Dialect and registers custom attributes, operations, and types (in its
 /// constructor). It can also override some general behavior exposed via virtual

mlir/examples/toy/Ch7/CMakeLists.txt

PRIVATE
     ${dialect_libs}
     ${conversion_libs}
     MLIRAnalysis
     MLIRCallInterfaces
     MLIRExecutionEngine
     MLIRIR
     MLIRParser
     MLIRPass
+    MLIRSideEffects
     MLIRTargetLLVMIR
     MLIRTransforms
     )

mlir/examples/toy/Ch7/include/toy/Dialect.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/StandardTypes.h"
+#include "mlir/Interfaces/SideEffects.h"
 #include "toy/ShapeInferenceInterface.h"
 
 namespace mlir {
 namespace toy {
 namespace detail {
 struct StructTypeStorage;
 } // end namespace detail
 

mlir/include/mlir/Dialect/AffineOps/AffineOps.h

 #ifndef MLIR_DIALECT_AFFINEOPS_AFFINEOPS_H
 #define MLIR_DIALECT_AFFINEOPS_AFFINEOPS_H
 
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/StandardTypes.h"
+#include "mlir/Interfaces/SideEffects.h"
 #include "mlir/Transforms/LoopLikeInterface.h"
 
 namespace mlir {
 class AffineBound;
 class AffineDimExpr;
 class AffineValueMap;
 class AffineTerminatorOp;
 class FlatAffineConstraints;

mlir/include/mlir/Dialect/FxpMathOps/FxpMathOps.h

 //===- FxpMathOps.h - Fixed point ops ---------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_FXPMATHOPS_FXPMATHOPS_H_
 #define MLIR_DIALECT_FXPMATHOPS_FXPMATHOPS_H_
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/StandardTypes.h"
+#include "mlir/Interfaces/SideEffects.h"
 
 namespace mlir {
 namespace fxpmath {
 
 /// Defines the 'FxpMathOps' dialect.
 class FxpMathOpsDialect : public Dialect {
 public:
   FxpMathOpsDialect(MLIRContext *context);

mlir/include/mlir/Dialect/GPU/GPUDialect.h

 #ifndef MLIR_DIALECT_GPU_GPUDIALECT_H
 #define MLIR_DIALECT_GPU_GPUDIALECT_H
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/FunctionSupport.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/SymbolTable.h"
+#include "mlir/Interfaces/SideEffects.h"
 
 namespace mlir {
 class FuncOp;
 
 namespace gpu {
 
 /// The dialect containing GPU kernel launching operations and related
 /// facilities.

mlir/include/mlir/Dialect/LLVMIR/LLVMDialect.h

 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/TypeSupport.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
+#include "mlir/Interfaces/SideEffects.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 
 #include "mlir/Dialect/LLVMIR/LLVMOpsEnums.h.inc"
 
 namespace llvm {

mlir/include/mlir/Dialect/LLVMIR/NVVMDialect.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_LLVMIR_NVVMDIALECT_H_
 #define MLIR_DIALECT_LLVMIR_NVVMDIALECT_H_
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
+#include "mlir/Interfaces/SideEffects.h"
+
 namespace mlir {
 namespace NVVM {
 
 ///// Ops /////
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/NVVMOps.h.inc"
 
 class NVVMDialect : public Dialect {

mlir/include/mlir/Dialect/LLVMIR/ROCDLDialect.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_LLVMIR_ROCDLDIALECT_H_
 #define MLIR_DIALECT_LLVMIR_ROCDLDIALECT_H_
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
+#include "mlir/Interfaces/SideEffects.h"
 
 namespace mlir {
 namespace ROCDL {
 
 ///// Ops /////
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/ROCDLOps.h.inc"
 

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.h

 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/IR/Types.h"
+#include "mlir/Interfaces/SideEffects.h"
 #include "mlir/Support/LLVM.h"
 
 namespace mlir {
 namespace linalg {
 
 class ConvOp;
 
 /// Returns the name mangled library call name to disambiguate between different

mlir/include/mlir/Dialect/LoopOps/LoopOps.h

 
 #ifndef MLIR_LOOPOPS_OPS_H_
 #define MLIR_LOOPOPS_OPS_H_
 
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
+#include "mlir/Interfaces/SideEffects.h"
 #include "mlir/Transforms/LoopLikeInterface.h"
 
 namespace mlir {
 namespace loop {
 
 class TerminatorOp;
 
 class LoopOpsDialect : public Dialect {

mlir/include/mlir/Dialect/QuantOps/QuantOps.h

 #define MLIR_DIALECT_QUANTOPS_QUANTOPS_H_
 
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
+#include "mlir/Interfaces/SideEffects.h"
 #include "llvm/Support/MathExtras.h"
 
 namespace mlir {
 namespace quant {
 
 /// Defines the 'Quantization' dialect
 class QuantizationDialect : public Dialect {
 public:

mlir/include/mlir/Dialect/SPIRV/SPIRVOps.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_SPIRVOPS_H_
 #define MLIR_DIALECT_SPIRV_SPIRVOPS_H_
 
 #include "mlir/Dialect/SPIRV/SPIRVTypes.h"
 #include "mlir/IR/Function.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
+#include "mlir/Interfaces/SideEffects.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 
 namespace mlir {
 class OpBuilder;
 
 namespace spirv {
 
 // TableGen'erated operation interfaces for querying versions, extensions, and

mlir/include/mlir/Dialect/Shape/IR/Shape.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_SHAPE_IR_SHAPE_H
 #define MLIR_SHAPE_IR_SHAPE_H
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
+#include "mlir/Interfaces/SideEffects.h"
 
 namespace mlir {
 namespace shape {
 
 /// This dialect contains shape inference related operations and facilities.
 class ShapeDialect : public Dialect {
 public:
   /// Create the dialect in the given `context`.

mlir/include/mlir/Dialect/StandardOps/IR/Ops.h

 #define MLIR_DIALECT_STANDARDOPS_IR_OPS_H
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
+#include "mlir/Interfaces/SideEffects.h"
 
 // Pull in all enum type definitions and utility function declarations.
 #include "mlir/Dialect/StandardOps/IR/OpsEnums.h.inc"
 
 namespace mlir {
 class AffineMap;
 class Builder;
 class FuncOp;

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

 //===----------------------------------------------------------------------===//
 
 #ifndef STANDARD_OPS
 #define STANDARD_OPS
 
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/IR/OpAsmInterface.td"
-include "mlir/IR/SideEffects.td"
+include "mlir/Interfaces/SideEffects.td"
 
 def Std_Dialect : Dialect {
   let name = "std";
   let cppNamespace = "";
 }
 
 // Base class for Standard dialect ops.
 class Std_Op<string mnemonic, list<OpTrait> traits = []> :

mlir/include/mlir/Dialect/VectorOps/VectorOps.h

 
 #ifndef MLIR_DIALECT_VECTOROPS_VECTOROPS_H
 #define MLIR_DIALECT_VECTOROPS_VECTOROPS_H
 
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/StandardTypes.h"
+#include "mlir/Interfaces/SideEffects.h"
 
 namespace mlir {
 class MLIRContext;
 class OwningRewritePatternList;
 namespace vector {
 
 /// Dialect for Ops on higher-dimensional vector types.
 class VectorOpsDialect : public Dialect {

mlir/include/mlir/IR/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS OpAsmInterface.td)
 mlir_tablegen(OpAsmInterface.h.inc -gen-op-interface-decls)
 mlir_tablegen(OpAsmInterface.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(MLIROpAsmInterfacesIncGen)
-
-set(LLVM_TARGET_DEFINITIONS SideEffects.td)
-mlir_tablegen(SideEffectInterfaces.h.inc -gen-op-interface-decls)
-mlir_tablegen(SideEffectInterfaces.cpp.inc -gen-op-interface-defs)
-add_public_tablegen_target(MLIRSideEffectOpInterfacesIncGen)

mlir/include/mlir/IR/OpDefinition.h

static Concept *getInterfaceFor(Operation *op) {
     return abstractOp ? abstractOp->getInterface<ConcreteType>() : nullptr;
   }
 
   /// A pointer to the impl concept object.
   Concept *impl;
 };
 
 //===----------------------------------------------------------------------===//
-// Operation Side-Effect Modeling
-//===----------------------------------------------------------------------===//
-
-// TODO(riverriddle) This should be in its own file in a proper
-// traits/interfaces directory. Move it there when we have one.
-
-namespace SideEffects {
-//===--------------------------------------------------------------------===//
-// Effects
-
-/// This class represents a base class for a specific effect type.
-class Effect {
-public:
-  /// This base class is used for derived effects that are non-parametric.
-  template <typename DerivedEffect, typename BaseEffect = Effect>
-  class Base : public BaseEffect {
-  public:
-    using BaseT = Base<DerivedEffect>;
-
-    /// Return the unique identifier for the base effects class.
-    static ClassID *getEffectID() { return ClassID::getID<DerivedEffect>(); }
-
-    /// 'classof' used to support llvm style cast functionality.
-    static bool classof(const ::mlir::SideEffects::Effect *effect) {
-      return effect->getEffectID() == BaseT::getEffectID();
-    }
-
-    /// Returns a unique instance for the derived effect class.
-    static DerivedEffect *get() {
-      return BaseEffect::template get<DerivedEffect>();
-    }
-    using BaseEffect::get;
-
-  protected:
-    Base() : BaseEffect(BaseT::getEffectID()){};
-  };
-
-  /// Return the unique identifier for the base effects class.
-  ClassID *getEffectID() const { return id; }
-
-  /// Returns a unique instance for the given effect class.
-  template <typename DerivedEffect> static DerivedEffect *get() {
-    static_assert(std::is_base_of<Effect, DerivedEffect>::value,
-                  "expected DerivedEffect to inherit from Effect");
-
-    static DerivedEffect instance;
-    return &instance;
-  }
-
-protected:
-  Effect(ClassID *id) : id(id) {}
-
-private:
-  /// The id of the derived effect class.
-  ClassID *id;
-};
-
-//===--------------------------------------------------------------------===//
-// Resources
-
-/// This class represents a specific resource that an effect applies to. This
-/// class represents an abstract interface for a given resource.
-class Resource {
-public:
-  virtual ~Resource() {}
-
-  /// This base class is used for derived effects that are non-parametric.
-  template <typename DerivedResource, typename BaseResource = Resource>
-  class Base : public BaseResource {
-  public:
-    using BaseT = Base<DerivedResource>;
-
-    /// Returns a unique instance for the given effect class.
-    static DerivedResource *get() {
-      static DerivedResource instance;
-      return &instance;
-    }
-
-    /// Return the unique identifier for the base resource class.
-    static ClassID *getResourceID() {
-      return ClassID::getID<DerivedResource>();
-    }
-
-    /// 'classof' used to support llvm style cast functionality.
-    static bool classof(const Resource *resource) {
-      return resource->getResourceID() == BaseT::getResourceID();
-    }
-
-  protected:
-    Base() : BaseResource(BaseT::getResourceID()){};
-  };
-
-  /// Return the unique identifier for the base resource class.
-  ClassID *getResourceID() const { return id; }
-
-  /// Return a string name of the resource.
-  virtual StringRef getName() = 0;
-
-protected:
-  Resource(ClassID *id) : id(id) {}
-
-private:
-  /// The id of the derived resource class.
-  ClassID *id;
-};
-
-/// A conservative default resource kind.
-struct DefaultResource : public Resource::Base<DefaultResource> {
-  StringRef getName() final { return "<Default>"; }
-};
-
-/// This class represents a specific instance of an effect. It contains the
-/// effect being applied, a resource that corresponds to where the effect is
-/// applied, and an optional value(either operand, result, or region entry
-/// argument) that the effect is applied to.
-template <typename EffectT> class EffectInstance {
-public:
-  EffectInstance(EffectT *effect, Resource *resource = DefaultResource::get())
-      : effect(effect), resource(resource) {}
-  EffectInstance(EffectT *effect, Value value,
-                 Resource *resource = DefaultResource::get())
-      : effect(effect), resource(resource), value(value) {}
-
-  /// Return the effect being applied.
-  EffectT *getEffect() const { return effect; }
-
-  /// Return the value the effect is applied on, or nullptr if there isn't a
-  /// known value being affected.
-  Value getValue() const { return value; }
-
-  /// Return the resource that the effect applies to.
-  Resource *getResource() const { return resource; }
-
-private:
-  /// The specific effect being applied.
-  EffectT *effect;
-
-  /// The resource that the given value resides in.
-  Resource *resource;
-
-  /// The value that the effect applies to. This is optionally null.
-  Value value;
-};
-} // 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
-
-//===----------------------------------------------------------------------===//
-// Operation Memory-Effect Modeling
-//===----------------------------------------------------------------------===//
-
-namespace MemoryEffects {
-/// This class represents the base class used for memory effects.
-struct Effect : public SideEffects::Effect {
-  using SideEffects::Effect::Effect;
-
-  /// A base class for memory effects that provides helper utilities.
-  template <typename DerivedEffect>
-  using Base = SideEffects::Effect::Base<DerivedEffect, Effect>;
-
-  static bool classof(const SideEffects::Effect *effect);
-};
-using EffectInstance = SideEffects::EffectInstance<Effect>;
-
-/// The following effect indicates that the operation allocates from some
-/// resource. An 'allocate' effect implies only allocation of the resource, and
-/// not any visible mutation or dereference.
-struct Allocate : public Effect::Base<Allocate> {};
-
-/// The following effect indicates that the operation frees some resource that
-/// has been allocated. An 'allocate' effect implies only de-allocation of the
-/// resource, and not any visible allocation, mutation or dereference.
-struct Free : public Effect::Base<Free> {};
-
-/// The following effect indicates that the operation reads from some resource.
-/// A 'read' effect implies only dereferencing of the resource, and not any
-/// visible mutation.
-struct Read : public Effect::Base<Read> {};
-
-/// 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/IR/SideEffectInterfaces.h.inc"
-
-//===----------------------------------------------------------------------===//
 // Common Operation Folders/Parsers/Printers
 //===----------------------------------------------------------------------===//
 
 // These functions are out-of-line implementations of the methods in UnaryOp and
 // BinaryOp, which avoids them being template instantiated/duplicated.
 namespace impl {
 ParseResult parseOneResultOneOperandTypeOp(OpAsmParser &parser,
                                            OperationState &result);

mlir/include/mlir/Interfaces/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS CallInterfaces.td)
 mlir_tablegen(CallInterfaces.h.inc -gen-op-interface-decls)
 mlir_tablegen(CallInterfaces.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(MLIRCallInterfacesIncGen)
 
 set(LLVM_TARGET_DEFINITIONS ControlFlowInterfaces.td)
 mlir_tablegen(ControlFlowInterfaces.h.inc -gen-op-interface-decls)
 mlir_tablegen(ControlFlowInterfaces.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(MLIRControlFlowInterfacesIncGen)
 
 set(LLVM_TARGET_DEFINITIONS InferTypeOpInterface.td)
 mlir_tablegen(InferTypeOpInterface.h.inc -gen-op-interface-decls)
 mlir_tablegen(InferTypeOpInterface.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(MLIRInferTypeOpInterfaceIncGen)
+
+set(LLVM_TARGET_DEFINITIONS SideEffects.td)
+mlir_tablegen(SideEffectInterfaces.h.inc -gen-op-interface-decls)
+mlir_tablegen(SideEffectInterfaces.cpp.inc -gen-op-interface-defs)
+add_public_tablegen_target(MLIRSideEffectOpInterfacesIncGen)

mlir/include/mlir/Interfaces/SideEffects.h

+//===- SideEffects.h - SideEffect in MLIR -----------------------*- 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 traits, interfaces, and utilities for defining and
+// querying the side effects of an operation.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_INTERFACES_SIDEEFFECTS_H
+#define MLIR_INTERFACES_SIDEEFFECTS_H
+
+#include "mlir/IR/OpDefinition.h"
+
+namespace mlir {
+namespace SideEffects {
+//===----------------------------------------------------------------------===//
+// Effects
+//===----------------------------------------------------------------------===//
+
+/// This class represents a base class for a specific effect type.
+class Effect {
+public:
+  /// This base class is used for derived effects that are non-parametric.
+  template <typename DerivedEffect, typename BaseEffect = Effect>
+  class Base : public BaseEffect {
+  public:
+    using BaseT = Base<DerivedEffect>;
+
+    /// Return the unique identifier for the base effects class.
+    static ClassID *getEffectID() { return ClassID::getID<DerivedEffect>(); }
+
+    /// 'classof' used to support llvm style cast functionality.
+    static bool classof(const ::mlir::SideEffects::Effect *effect) {
+      return effect->getEffectID() == BaseT::getEffectID();
+    }
+
+    /// Returns a unique instance for the derived effect class.
+    static DerivedEffect *get() {
+      return BaseEffect::template get<DerivedEffect>();
+    }
+    using BaseEffect::get;
+
+  protected:
+    Base() : BaseEffect(BaseT::getEffectID()){};
+  };
+
+  /// Return the unique identifier for the base effects class.
+  ClassID *getEffectID() const { return id; }
+
+  /// Returns a unique instance for the given effect class.
+  template <typename DerivedEffect> static DerivedEffect *get() {
+    static_assert(std::is_base_of<Effect, DerivedEffect>::value,
+                  "expected DerivedEffect to inherit from Effect");
+
+    static DerivedEffect instance;
+    return &instance;
+  }
+
+protected:
+  Effect(ClassID *id) : id(id) {}
+
+private:
+  /// The id of the derived effect class.
+  ClassID *id;
+};
+
+//===----------------------------------------------------------------------===//
+// Resources
+//===----------------------------------------------------------------------===//
+
+/// This class represents a specific resource that an effect applies to. This
+/// class represents an abstract interface for a given resource.
+class Resource {
+public:
+  virtual ~Resource() {}
+
+  /// This base class is used for derived effects that are non-parametric.
+  template <typename DerivedResource, typename BaseResource = Resource>
+  class Base : public BaseResource {
+  public:
+    using BaseT = Base<DerivedResource>;
+
+    /// Returns a unique instance for the given effect class.
+    static DerivedResource *get() {
+      static DerivedResource instance;
+      return &instance;
+    }
+
+    /// Return the unique identifier for the base resource class.
+    static ClassID *getResourceID() {
+      return ClassID::getID<DerivedResource>();
+    }
+
+    /// 'classof' used to support llvm style cast functionality.
+    static bool classof(const Resource *resource) {
+      return resource->getResourceID() == BaseT::getResourceID();
+    }
+
+  protected:
+    Base() : BaseResource(BaseT::getResourceID()){};
+  };
+
+  /// Return the unique identifier for the base resource class.
+  ClassID *getResourceID() const { return id; }
+
+  /// Return a string name of the resource.
+  virtual StringRef getName() = 0;
+
+protected:
+  Resource(ClassID *id) : id(id) {}
+
+private:
+  /// The id of the derived resource class.
+  ClassID *id;
+};
+
+/// A conservative default resource kind.
+struct DefaultResource : public Resource::Base<DefaultResource> {
+  StringRef getName() final { return "<Default>"; }
+};
+
+/// This class represents a specific instance of an effect. It contains the
+/// effect being applied, a resource that corresponds to where the effect is
+/// applied, and an optional value(either operand, result, or region entry
+/// argument) that the effect is applied to.
+template <typename EffectT> class EffectInstance {
+public:
+  EffectInstance(EffectT *effect, Resource *resource = DefaultResource::get())
+      : effect(effect), resource(resource) {}
+  EffectInstance(EffectT *effect, Value value,
+                 Resource *resource = DefaultResource::get())
+      : effect(effect), resource(resource), value(value) {}
+
+  /// Return the effect being applied.
+  EffectT *getEffect() const { return effect; }
+
+  /// Return the value the effect is applied on, or nullptr if there isn't a
+  /// known value being affected.
+  Value getValue() const { return value; }
+
+  /// Return the resource that the effect applies to.
+  Resource *getResource() const { return resource; }
+
+private:
+  /// The specific effect being applied.
+  EffectT *effect;
+
+  /// The resource that the given value resides in.
+  Resource *resource;
+
+  /// The value that the effect applies to. This is optionally null.
+  Value value;
+};
+} // 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
+
+//===----------------------------------------------------------------------===//
+// Operation Memory-Effect Modeling
+//===----------------------------------------------------------------------===//
+
+namespace MemoryEffects {
+/// This class represents the base class used for memory effects.
+struct Effect : public SideEffects::Effect {
+  using SideEffects::Effect::Effect;
+
+  /// A base class for memory effects that provides helper utilities.
+  template <typename DerivedEffect>
+  using Base = SideEffects::Effect::Base<DerivedEffect, Effect>;
+
+  static bool classof(const SideEffects::Effect *effect);
+};
+using EffectInstance = SideEffects::EffectInstance<Effect>;
+
+/// The following effect indicates that the operation allocates from some
+/// resource. An 'allocate' effect implies only allocation of the resource, and
+/// not any visible mutation or dereference.
+struct Allocate : public Effect::Base<Allocate> {};
+
+/// The following effect indicates that the operation frees some resource that
+/// has been allocated. An 'allocate' effect implies only de-allocation of the
+/// resource, and not any visible allocation, mutation or dereference.
+struct Free : public Effect::Base<Free> {};
+
+/// The following effect indicates that the operation reads from some resource.
+/// A 'read' effect implies only dereferencing of the resource, and not any
+/// visible mutation.
+struct Read : public Effect::Base<Read> {};
+
+/// 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"
+
+} // end namespace mlir
+
+#endif // MLIR_INTERFACES_SIDEEFFECTS_H

mlir/include/mlir/Interfaces/SideEffects.td

 //===-- SideEffects.td - Side Effect Interfaces ------------*- tablegen -*-===//
 //
 // 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 a set of interfaces that can be used to define information
 // about what effects are applied by an operation.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_IR_SIDEEFFECTS
-#define MLIR_IR_SIDEEFFECTS
+#ifndef MLIR_INTERFACES_SIDEEFFECTS
+#define MLIR_INTERFACES_SIDEEFFECTS
 
 include "mlir/IR/OpBase.td"
 
 //===----------------------------------------------------------------------===//
 // EffectOpInterface
 //===----------------------------------------------------------------------===//
 
 // A base interface used to query information about the side effects applied to

 
 // 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.
 class MemWrite<string resourceName>
   : MemoryEffect<"MemoryEffects::Write", resourceName>;
 def MemWrite : MemWrite<"">;
 
-#endif // MLIR_IR_SIDEEFFECTS
+#endif // MLIR_INTERFACES_SIDEEFFECTS

mlir/lib/Dialect/AffineOps/CMakeLists.txt

 add_mlir_dialect_library(MLIRAffineOps
   AffineOps.cpp
   AffineValueMap.cpp
   EDSC/Builders.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/AffineOps
 
   DEPENDS
   MLIRAffineOpsIncGen
   MLIRLoopLikeInterfaceIncGen
   )
 target_link_libraries(MLIRAffineOps
   PUBLIC
   MLIREDSC
   MLIRIR
+  MLIRSideEffects
   MLIRStandardOps
   )

mlir/lib/Dialect/FxpMathOps/CMakeLists.txt

 add_mlir_dialect_library(MLIRFxpMathOps
   IR/FxpMathOps.cpp
   Transforms/LowerUniformRealMath.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/FxpMathOps
 
   DEPENDS
   MLIRFxpMathOpsIncGen
   )
 
 target_link_libraries(MLIRFxpMathOps
   PUBLIC
   MLIRQuantOps
   MLIRIR
   MLIRPass
+  MLIRSideEffects
   MLIRSupport
   MLIRStandardOps
   )

mlir/lib/Dialect/GPU/CMakeLists.txt

add_mlir_dialect_library(MLIRGPU
   )
 target_link_libraries(MLIRGPU
   PUBLIC
   MLIREDSC
   MLIRIR
   MLIRLLVMIR
   MLIRLoopOps
   MLIRPass
+  MLIRSideEffects
   MLIRStandardOps
   MLIRSupport
   MLIRTransformUtils
   LLVMSupport
   )

mlir/lib/Dialect/LLVMIR/CMakeLists.txt

target_link_libraries(MLIRLLVMIR
   LLVMAsmParser
   LLVMCore
   LLVMSupport
   LLVMFrontendOpenMP
   MLIRCallInterfaces
   MLIRControlFlowInterfaces
   MLIROpenMP
   MLIRIR
+  MLIRSideEffects
   MLIRSupport
   )
 
 add_mlir_dialect_library(MLIRNVVMIR
   IR/NVVMDialect.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/LLVMIR
 
   DEPENDS
   MLIRNVVMOpsIncGen
   MLIRNVVMConversionsIncGen
   )
 target_link_libraries(MLIRNVVMIR
   PUBLIC
   LLVMAsmParser
   MLIRIR
   MLIRLLVMIR
+  MLIRSideEffects
   LLVMSupport
   LLVMCore
   )
 
 add_mlir_dialect_library(MLIRROCDLIR
   IR/ROCDLDialect.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/LLVMIR
 
   DEPENDS
   MLIRROCDLOpsIncGen
   MLIRROCDLConversionsIncGen
   )
 target_link_libraries(MLIRROCDLIR
   PUBLIC
   LLVMAsmParser
   LLVMCore
   LLVMSupport
   MLIRIR
+  MLIRSideEffects
   )

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

 add_dependencies(MLIRLinalgOps
   MLIRLinalgOpsIncGen
   MLIRLinalgStructuredOpsIncGen
   MLIRLinalgStructuredOpsInterfaceIncGen
   )
 target_link_libraries(MLIRLinalgOps
   PUBLIC
   MLIRIR
+  MLIRSideEffects
   MLIRStandardOps
   )

mlir/lib/Dialect/LoopOps/CMakeLists.txt

 file(GLOB globbed *.c *.cpp)
 add_mlir_dialect_library(MLIRLoopOps
   ${globbed}
   EDSC/Builders.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/LoopOps
 
   DEPENDS
   MLIRLoopLikeInterfaceIncGen
   MLIRLoopOpsIncGen
   )
 target_link_libraries(MLIRLoopOps
   PUBLIC
   MLIREDSC
   MLIRIR
+  MLIRSideEffects
   MLIRStandardOps
   LLVMSupport
   )
 
 add_subdirectory(Transforms)

mlir/lib/Dialect/QuantOps/CMakeLists.txt

add_mlir_dialect_library(MLIRQuantOps
 
   DEPENDS
   MLIRQuantOpsIncGen
   )
 target_link_libraries(MLIRQuantOps
   PUBLIC
   MLIRIR
   MLIRPass
+  MLIRSideEffects
   MLIRSupport
   MLIRStandardOps
   MLIRTransformUtils
   )

mlir/lib/Dialect/SPIRV/CMakeLists.txt

add_mlir_dialect_library(MLIRSPIRV
   MLIRSPIRVOpUtilsGen
   MLIRSPIRVTargetAndABIIncGen
   )
 target_link_libraries(MLIRSPIRV
   PUBLIC
   MLIRControlFlowInterfaces
   MLIRIR
   MLIRParser
+  MLIRSideEffects
   MLIRSupport
   MLIRTransforms
   )
 
 add_subdirectory(Serialization)
 add_subdirectory(Transforms)

mlir/lib/Dialect/Shape/CMakeLists.txt

 file(GLOB globbed *.c *.cpp)
 add_mlir_dialect_library(MLIRShape
   ${globbed}
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Shape
   )
 add_dependencies(MLIRShape MLIRShapeOpsIncGen LLVMSupport)
 target_link_libraries(MLIRShape
   PUBLIC
+  MLIRSideEffects
   LLVMSupport)

mlir/lib/Dialect/StandardOps/CMakeLists.txt

add_mlir_dialect_library(MLIRStandardOps
   MLIRStandardOpsIncGen
   )
 target_link_libraries(MLIRStandardOps
   PUBLIC
   MLIRCallInterfaces
   MLIRControlFlowInterfaces
   MLIREDSC
   MLIRIR
+  MLIRSideEffects
   LLVMSupport
   )

mlir/lib/Dialect/VectorOps/CMakeLists.txt

 target_link_libraries(MLIRVectorOps
   PUBLIC
   MLIREDSC
   MLIRIR
   MLIRStandardOps
   MLIRAffineOps
   MLIRLoopOps
   MLIRLoopAnalysis
+  MLIRSideEffects
   )

mlir/lib/IR/CMakeLists.txt

 file(GLOB globbed *.c *.cpp)
 add_mlir_library(MLIRIR
   ${globbed}
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/IR
 
   DEPENDS
   MLIRCallInterfacesIncGen
-  MLIRSideEffectOpInterfacesIncGen
   MLIROpAsmInterfacesIncGen
   )
 target_link_libraries(MLIRIR
   PUBLIC
   MLIRSupport
   LLVMSupport
   )

mlir/lib/IR/Operation.cpp

 }
 
 LogicalResult OpTrait::impl::verifyResultSizeAttr(Operation *op,
                                                   StringRef attrName) {
   return verifyValueSizeAttr(op, attrName, /*isOperand=*/false);
 }
 
 //===----------------------------------------------------------------------===//
-// SideEffect Interfaces
-
-/// Include the definitions of the side effect interfaces.
-#include "mlir/IR/SideEffectInterfaces.cpp.inc"
-
-bool MemoryEffects::Effect::classof(const SideEffects::Effect *effect) {
-  return isa<Allocate>(effect) || isa<Free>(effect) || isa<Read>(effect) ||
-         isa<Write>(effect);
-}
-
-//===----------------------------------------------------------------------===//
 // BinaryOp implementation
 //===----------------------------------------------------------------------===//
 
 // These functions are out-of-line implementations of the methods in BinaryOp,
 // which avoids them being template instantiated/duplicated.
 
 void impl::buildBinaryOp(Builder *builder, OperationState &result, Value lhs,
                          Value rhs) {

mlir/lib/Interfaces/CMakeLists.txt

 set(LLVM_OPTIONAL_SOURCES
   CallInterfaces.cpp
   ControlFlowInterfaces.cpp
   InferTypeOpInterface.cpp
+  SideEffects.cpp
   )
 
 add_llvm_library(MLIRCallInterfaces
   CallInterfaces.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Interfaces
   )
add_llvm_library(MLIRInferTypeOpInterface
   )
 add_dependencies(MLIRInferTypeOpInterface
   MLIRInferTypeOpInterfaceIncGen
   )
 target_link_libraries(MLIRInferTypeOpInterface
   PUBLIC
   MLIRIR
   )
+
+add_llvm_library(MLIRSideEffects
+  SideEffects.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Interfaces
+  )
+add_dependencies(MLIRSideEffects
+  MLIRSideEffectOpInterfacesIncGen
+  )
+target_link_libraries(MLIRSideEffects
+  PUBLIC
+  MLIRIR
+  )

mlir/lib/Interfaces/SideEffects.cpp

+//===- SideEffects.cpp - SideEffects in MLIR ------------------------------===//
+//
+// 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/Interfaces/SideEffects.h"
+
+using namespace mlir;
+
+//===----------------------------------------------------------------------===//
+// SideEffect Interfaces
+//===----------------------------------------------------------------------===//
+
+/// Include the definitions of the side effect interfaces.
+#include "mlir/Interfaces/SideEffectInterfaces.cpp.inc"
+
+//===----------------------------------------------------------------------===//
+// MemoryEffects
+//===----------------------------------------------------------------------===//
+
+bool MemoryEffects::Effect::classof(const SideEffects::Effect *effect) {
+  return isa<Allocate>(effect) || isa<Free>(effect) || isa<Read>(effect) ||
+         isa<Write>(effect);
+}

mlir/test/lib/TestDialect/TestDialect.h

 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
+#include "mlir/Interfaces/SideEffects.h"
 
 #include "TestOpEnums.h.inc"
 
 namespace mlir {
 
 class TestDialect : public Dialect {
 public:
   /// Create the dialect in the given `context`.

mlir/test/lib/TestDialect/TestOps.td

 //===-- TestOps.td - Test dialect operation definitions ----*- tablegen -*-===//
 //
 // 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 TEST_OPS
 #define TEST_OPS
 
 include "mlir/IR/OpBase.td"
 include "mlir/IR/OpAsmInterface.td"
-include "mlir/IR/SideEffects.td"
+include "mlir/Interfaces/SideEffects.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 
 def TEST_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "";
 }

mlir/test/mlir-tblgen/op-side-effects.td

 // RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
 
-include "mlir/IR/SideEffects.td"
+include "mlir/Interfaces/SideEffects.td"
 
 def TEST_Dialect : Dialect {
   let name = "test";
 }
 class TEST_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<TEST_Dialect, mnemonic, traits>;
 
 def SideEffectOpA : TEST_Op<"side_effect_op_a"> {