[mlir][SideEffects][NFC] Move the .td definitions for NoSideEffect/RecursiveSideEffect to SideEffects.td

[rriddle]

Summary

This matches the location of these traits within the source files.

Depends On D75888

mlir/examples/toy/Ch2/include/toy/Ops.td

 //===- Ops.td - Toy 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the operations of the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_OPS
 #define TOY_OPS
 
 include "mlir/IR/OpBase.td"
+include "mlir/Interfaces/SideEffects.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
   let cppNamespace = "toy";
 }
 

mlir/examples/toy/Ch3/include/toy/Ops.td

 //===- Ops.td - Toy 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the operations of the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_OPS
 #define TOY_OPS
 
-include "mlir/IR/OpBase.td"
+include "mlir/Interfaces/SideEffects.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
   let cppNamespace = "toy";
 }
 

mlir/examples/toy/Ch4/include/toy/Ops.td

 //===- Ops.td - Toy 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the operations of the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_OPS
 #define TOY_OPS
 
 include "mlir/Interfaces/CallInterfaces.td"
+include "mlir/Interfaces/SideEffects.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
   let cppNamespace = "toy";
 }

mlir/examples/toy/Ch5/include/toy/Ops.td

 //===- Ops.td - Toy 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the operations of the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_OPS
 #define TOY_OPS
 
 include "mlir/Interfaces/CallInterfaces.td"
+include "mlir/Interfaces/SideEffects.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
   let cppNamespace = "toy";
 }

mlir/examples/toy/Ch6/include/toy/Ops.td

 //===- Ops.td - Toy 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the operations of the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_OPS
 #define TOY_OPS
 
 include "mlir/Interfaces/CallInterfaces.td"
+include "mlir/Interfaces/SideEffects.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
   let cppNamespace = "toy";
 }

mlir/examples/toy/Ch7/include/toy/Ops.td

 //===- Ops.td - Toy 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the operations of the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_OPS
 #define TOY_OPS
 
 include "mlir/Interfaces/CallInterfaces.td"
+include "mlir/Interfaces/SideEffects.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
   let cppNamespace = "toy";
 }

mlir/include/mlir/Dialect/AffineOps/AffineOps.td

 //===- AffineOps.td - Affine 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines MLIR affine operations.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef AFFINE_OPS
 #define AFFINE_OPS
 
 include "mlir/Dialect/AffineOps/AffineOpsBase.td"
-include "mlir/IR/OpBase.td"
+include "mlir/Interfaces/SideEffects.td"
 include "mlir/Transforms/LoopLikeInterface.td"
 
 def Affine_Dialect : Dialect {
   let name = "affine";
   let cppNamespace = "";
 }
 
 // Base class for Affine dialect ops.

mlir/include/mlir/Dialect/FxpMathOps/FxpMathOps.td

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef DIALECT_FXPMATHOPS_FXPMATH_OPS_
 #define DIALECT_FXPMATHOPS_FXPMATH_OPS_
 
 include "mlir/IR/OpBase.td"
 include "mlir/Dialect/QuantOps/QuantPredicates.td"
+include "mlir/Interfaces/SideEffects.td"
 
 def fxpmath_Dialect : Dialect {
   let name = "fxpmath";
 }
 
 //===----------------------------------------------------------------------===//
 // Attributes
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Dialect/GPU/GPUOps.td

 //===-- GPUOps.td - GPU 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines some operations of the GPU dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef GPU_OPS
 #define GPU_OPS
 
-include "mlir/IR/OpBase.td"
 include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
+include "mlir/Interfaces/SideEffects.td"
 
 // Type constraint accepting standard integers, indices and wrapped LLVM integer
 // types.
 def IntLikeOrLLVMInt : TypeConstraint<
   Or<[AnySignlessInteger.predicate, Index.predicate, LLVMInt.predicate]>,
   "integer, index or LLVM dialect equivalent">;
 
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVMIR_OPS
 #define LLVMIR_OPS
 
 include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
+include "mlir/Interfaces/SideEffects.td"
 
 class LLVM_Builder<string builder> {
   string llvmBuilder = builder;
 }
 
 def LLVM_OneResultOpBuilder : OpBuilder<
   "Builder *, OperationState &result, Type resultType, "
   "ValueRange operands, ArrayRef<NamedAttribute> attributes = {}",

mlir/include/mlir/Dialect/LLVMIR/NVVMOps.td

 //===-- NVVMOps.td - NVVM IR dialect op definition file ----*- 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 is the NVVM IR operation definition file.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef NVVMIR_OPS
 #define NVVMIR_OPS
 
 include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
+include "mlir/Interfaces/SideEffects.td"
 
 //===----------------------------------------------------------------------===//
 // NVVM dialect definitions
 //===----------------------------------------------------------------------===//
 
 def NVVM_Dialect : Dialect {
   let name = "nvvm";
   let cppNamespace = "NVVM";

mlir/include/mlir/Dialect/LLVMIR/ROCDLOps.td

 //===-- ROCDLOps.td - ROCDL IR dialect op definition file --*- 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 is the ROCDL IR operation definition file.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef ROCDLIR_OPS
 #define ROCDLIR_OPS
 
 include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
+include "mlir/Interfaces/SideEffects.td"
 
 //===----------------------------------------------------------------------===//
 // ROCDL dialect definitions
 //===----------------------------------------------------------------------===//
 
 def ROCDL_Dialect : Dialect {
   let name = "rocdl";
   let cppNamespace = "ROCDL";

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

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LINALG_OPS
 #define LINALG_OPS
 
 include "mlir/Dialect/AffineOps/AffineOpsBase.td"
 include "mlir/Dialect/Linalg/IR/LinalgBase.td"
+include "mlir/Interfaces/SideEffects.td"
 
 // Base class for Linalg dialect ops that do not correspond to library calls.
 class Linalg_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<Linalg_Dialect, mnemonic, traits> {
   // For every linalg op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
   //   * LogicalResult verify(${C++ class of Op} op)
   //   * ParseResult parse${C++ class of Op}(OpAsmParser &parser,

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

 //===- Ops.td - Loop 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines MLIR loop operations.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LOOP_OPS
 #define LOOP_OPS
 
-include "mlir/IR/OpBase.td"
+include "mlir/Interfaces/SideEffects.td"
 include "mlir/Transforms/LoopLikeInterface.td"
 
 def Loop_Dialect : Dialect {
   let name = "loop";
   let cppNamespace = "";
 }
 
 // Base class for Loop dialect ops.

mlir/include/mlir/Dialect/QuantOps/QuantOps.td

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef DIALECT_QUANTOPS_QUANT_OPS_
 #define DIALECT_QUANTOPS_QUANT_OPS_
 
 include "mlir/IR/OpBase.td"
 include "mlir/Dialect/QuantOps/QuantPredicates.td"
+include "mlir/Interfaces/SideEffects.td"
 
 def quant_Dialect : Dialect {
   let name = "quant";
 }
 
 //===----------------------------------------------------------------------===//
 // Base classes
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Dialect/SPIRV/SPIRVArithmeticOps.td

 // to "3.32.13. Arithmetic Instructions" of the SPIR-V specification.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SPIRV_ARITHMETIC_OPS
 #define SPIRV_ARITHMETIC_OPS
 
 include "mlir/Dialect/SPIRV/SPIRVBase.td"
+include "mlir/Interfaces/SideEffects.td"
 
 class SPV_ArithmeticBinaryOp<string mnemonic, Type type,
                        list<OpTrait> traits = []> :
       // Operands type same as result type.
       SPV_BinaryOp<mnemonic, type, type,
                    !listconcat(traits,
                                [NoSideEffect, SameOperandsAndResultType])>;
 

mlir/include/mlir/Dialect/SPIRV/SPIRVBitOps.td

 // to "3.32.13. Bit Instructions" of the SPIR-V specification.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SPIRV_BIT_OPS
 #define SPIRV_BIT_OPS
 
 include "mlir/Dialect/SPIRV/SPIRVBase.td"
+include "mlir/Interfaces/SideEffects.td"
 
 class SPV_BitBinaryOp<string mnemonic, list<OpTrait> traits = []> :
       // All the operands type used in bit instructions are SPV_Integer.
       SPV_BinaryOp<mnemonic, SPV_Integer, SPV_Integer,
                    !listconcat(traits,
                                [NoSideEffect, SameOperandsAndResultType])>;
 
 class SPV_BitFieldExtractOp<string mnemonic, list<OpTrait> traits = []> :

mlir/include/mlir/Dialect/SPIRV/SPIRVCastOps.td

 // to "3.32.11. Convertion Instructions" of the SPIR-V specification.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SPIRV_CAST_OPS
 #define SPIRV_CAST_OPS
 
 include "mlir/Dialect/SPIRV/SPIRVBase.td"
+include "mlir/Interfaces/SideEffects.td"
 
 class SPV_CastOp<string mnemonic, Type resultType, Type operandType,
                  list<OpTrait> traits = []> :
       SPV_Op<mnemonic,
              !listconcat(traits,
                          [NoSideEffect, SameOperandsAndResultShape])> {
   let arguments = (ins
     SPV_ScalarOrVectorOf<operandType>:$operand

mlir/include/mlir/Dialect/SPIRV/SPIRVCompositeOps.td

 // to "3.32.12. Composite Instructions" of the SPIR-V spec.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SPIRV_COMPOSITE_OPS
 #define SPIRV_COMPOSITE_OPS
 
 include "mlir/Dialect/SPIRV/SPIRVBase.td"
+include "mlir/Interfaces/SideEffects.td"
 
 // -----
 
 def SPV_CompositeConstructOp : SPV_Op<"CompositeConstruct", [NoSideEffect]> {
   let summary = [{
     Construct a new composite object from a set of constituent objects that
     will fully form it.
   }];

mlir/include/mlir/Dialect/SPIRV/SPIRVControlFlowOps.td

 //===----------------------------------------------------------------------===//
 
 #ifndef SPIRV_CONTROLFLOW_OPS
 #define SPIRV_CONTROLFLOW_OPS
 
 include "mlir/Dialect/SPIRV/SPIRVBase.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
+include "mlir/Interfaces/SideEffects.td"
 
 // -----
 
 def SPV_BranchOp : SPV_Op<"Branch", [
     DeclareOpInterfaceMethods<BranchOpInterface>, InFunctionScope, NoSideEffect,
     Terminator]> {
   let summary = "Unconditional branch to target block.";
 

mlir/include/mlir/Dialect/SPIRV/SPIRVGLSLOps.td

 //===- SPIRVGLSLOps.td - GLSL extended insts spec file -----*- 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 is the op definition spec of GLSL extension ops.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SPIRV_GLSL_OPS
 #define SPIRV_GLSL_OPS
 
 include "mlir/Dialect/SPIRV/SPIRVBase.td"
+include "mlir/Interfaces/SideEffects.td"
 
 //===----------------------------------------------------------------------===//
 // SPIR-V GLSL 4.50 opcode specification.
 //===----------------------------------------------------------------------===//
 
 // Base class for all GLSL ops.
 class SPV_GLSLOp<string mnemonic, int opcode, list<OpTrait> traits = []> :
   SPV_ExtInstOp<mnemonic, "GLSL", "GLSL.std.450", opcode, traits>;

mlir/include/mlir/Dialect/SPIRV/SPIRVLogicalOps.td

 // to "3.32.15. Relational and Logical Instructions" of the SPIR-V spec.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SPIRV_LOGICAL_OPS
 #define SPIRV_LOGICAL_OPS
 
 include "mlir/Dialect/SPIRV/SPIRVBase.td"
+include "mlir/Interfaces/SideEffects.td"
 
 class SPV_LogicalBinaryOp<string mnemonic, Type operandsType,
                     list<OpTrait> traits = []> :
       // Result type is SPV_Bool.
       SPV_BinaryOp<mnemonic, SPV_Bool, operandsType,
                    !listconcat(traits,
                                [NoSideEffect, SameTypeOperands,
                                 SameOperandsAndResultShape])> {

mlir/include/mlir/Dialect/SPIRV/SPIRVOps.td

 include "mlir/Dialect/SPIRV/SPIRVCastOps.td"
 include "mlir/Dialect/SPIRV/SPIRVCompositeOps.td"
 include "mlir/Dialect/SPIRV/SPIRVControlFlowOps.td"
 include "mlir/Dialect/SPIRV/SPIRVGLSLOps.td"
 include "mlir/Dialect/SPIRV/SPIRVGroupOps.td"
 include "mlir/Dialect/SPIRV/SPIRVLogicalOps.td"
 include "mlir/Dialect/SPIRV/SPIRVNonUniformOps.td"
 include "mlir/Dialect/SPIRV/SPIRVStructureOps.td"
+include "mlir/Interfaces/SideEffects.td"
 
 // -----
 
 def SPV_AccessChainOp : SPV_Op<"AccessChain", [NoSideEffect]> {
   let summary = [{
     Create a pointer into a composite object that can be used with OpLoad
     and OpStore.
   }];

mlir/include/mlir/Dialect/SPIRV/SPIRVStructureOps.td

 // and module-level operations. The representational form of these ops deviate
 // from the SPIR-V binary format in order to utilize MLIR mechanisms.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SPIRV_STRUCTURE_OPS
 #define SPIRV_STRUCTURE_OPS
 
-include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Dialect/SPIRV/SPIRVBase.td"
+include "mlir/Interfaces/CallInterfaces.td"
+include "mlir/Interfaces/SideEffects.td"
 
 // -----
 
 def SPV_AddressOfOp : SPV_Op<"_address_of", [InFunctionScope, NoSideEffect]> {
   let summary = "Get the address of a global variable.";
 
   let description = [{
     Variables in module scope are defined using symbol names. This op generates

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

 //===- Ops.td - Standard 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines some MLIR standard operations.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef STANDARD_OPS
 #define STANDARD_OPS
 
+include "mlir/IR/OpAsmInterface.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
-include "mlir/IR/OpAsmInterface.td"
 include "mlir/Interfaces/SideEffects.td"
 
 def Std_Dialect : Dialect {
   let name = "std";
   let cppNamespace = "";
 }
 
 // Base class for Standard dialect ops.

mlir/include/mlir/Dialect/VectorOps/VectorOps.td

 //===- VectorOps.td - Vector op 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines MLIR vector operations.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef VECTOR_OPS
 #define VECTOR_OPS
 
-include "mlir/IR/OpBase.td"
 include "mlir/Dialect/AffineOps/AffineOpsBase.td"
+include "mlir/Interfaces/SideEffects.td"
 
 def Vector_Dialect : Dialect {
   let name = "vector";
   let cppNamespace = "vector";
 }
 
 // Base class for Vector dialect ops.
 class Vector_Op<string mnemonic, list<OpTrait> traits = []> :

mlir/include/mlir/IR/OpBase.td

 // X op Y == Y op X
 def Commutative  : NativeOpTrait<"IsCommutative">;
 // Op behaves like a function.
 def FunctionLike : NativeOpTrait<"FunctionLike">;
 // Op is isolated from above.
 def IsolatedFromAbove : NativeOpTrait<"IsIsolatedFromAbove">;
 // Op results are float or vectors/tensors thereof.
 def ResultsAreFloatLike : NativeOpTrait<"ResultsAreFloatLike">;
-// Op has no side effect.
-def NoSideEffect : NativeOpTrait<"HasNoSideEffect">;
-// Op has recursively computed side effects.
-def RecursiveSideEffects : NativeOpTrait<"HasRecursiveSideEffects">;
 // Op has the same operand type.
 def SameTypeOperands : NativeOpTrait<"SameTypeOperands">;
 // Op has same shape for all operands.
 def SameOperandsShape : NativeOpTrait<"SameOperandsShape">;
 // Op has same operand and result shape.
 def SameOperandsAndResultShape : NativeOpTrait<"SameOperandsAndResultShape">;
 // Op has the same operand and result type.
 def SameOperandsAndResultType : NativeOpTrait<"SameOperandsAndResultType">;

mlir/include/mlir/Interfaces/SideEffects.td

 
 // 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<"">;
 
+//===----------------------------------------------------------------------===//
+// Effect Traits
+//===----------------------------------------------------------------------===//
+
+// Op has no side effect.
+def NoSideEffect : NativeOpTrait<"HasNoSideEffect">;
+// Op has recursively computed side effects.
+def RecursiveSideEffects : NativeOpTrait<"HasRecursiveSideEffects">;
+
 #endif // MLIR_INTERFACES_SIDEEFFECTS

mlir/test/lib/TestDialect/TestOps.td

 #define TEST_OPS
 
 include "mlir/IR/OpBase.td"
 include "mlir/IR/OpAsmInterface.td"
 include "mlir/Interfaces/SideEffects.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
+include "mlir/Interfaces/SideEffects.td"
 
 def TEST_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "";
 }
 
 class TEST_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<TEST_Dialect, mnemonic, traits>;

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>;
 

mlir/tools/mlir-tblgen/LLVMIRIntrinsicGen.cpp

 }
 
 /// Traverses the list of TableGen definitions derived from the "Intrinsic"
 /// class and generates MLIR ODS definitions for those intrinsics that have
 /// the name matching the filter.
 static bool emitIntrinsics(const llvm::RecordKeeper &records,
                            llvm::raw_ostream &os) {
   llvm::emitSourceFileHeader("Operations for LLVM intrinsics", os);
-  os << "include \"mlir/Dialect/LLVMIR/LLVMOpBase.td\"\n\n";
+  os << "include \"mlir/Dialect/LLVMIR/LLVMOpBase.td\"\n";
+  os << "include \"mlir/Interfaces/SideEffects.td\"\n\n";
 
   auto defs = records.getAllDerivedDefinitions("Intrinsic");
   for (const llvm::Record *r : defs) {
     if (!nameFilter.empty() && !r->getName().contains(nameFilter))
       continue;
     if (emitIntrinsic(*r, os))
       return true;
   }
 
   return false;
 }
 
 static mlir::GenRegistration genLLVMIRIntrinsics("gen-llvmir-intrinsics",
                                                  "Generate LLVM IR intrinsics",
                                                  emitIntrinsics);