Introduce a ConditionallySpeculatable op interface

[sanjoy]

Summary

This patch takes the first step towards a more principled modeling of undefined behavior in MLIR as discussed in the following discourse threads:

1. https://discourse.llvm.org/t/semantics-modeling-undefined-behavior-and-side-effects/4812
2. https://discourse.llvm.org/t/rfc-mark-tensor-dim-and-memref-dim-as-side-effecting/65729

This patch in particular does the following:

1. Introduces a ConditionallySpeculatable OpInterface that dynamically determines whether an Operation can be speculated.
2. Re-defines NoSideEffect to allow undefined behavior, making it necessary but not sufficient for speculation. Also renames it to NoMemoryEffect.
3. Makes LICM respect the above semantics.
4. Changes all ops tagged with NoSideEffect today to additionally implement ConditionallySpeculatable and mark themselves as always speculatable. This combined trait is named Pure. This makes this change NFC.

For out of tree dialects:

1. Replace NoSideEffect with Pure if the operation does not have any memory effects, undefined behavior or infinite loops.
2. Replace NoSideEffect with NoSideEffect otherwise.

The next steps in this process are (I'm proposing to do these in upcoming patches):

1. Update operations like tensor.dim, memref.dim, scf.for, affine.for to implement a correct hook for ConditionallySpeculatable. I'm also happy to update ops in other dialects if the respective dialect owners would like to and can give me some pointers.
2. Update other passes that speculate operations to consult ConditionallySpeculatable in addition to NoMemoryEffect. I could not find any other than LICM on a quick skim, but I could have missed some.
3. Add some documentation / FAQs detailing the differences between side effects, undefined behavior, speculatabilty.

[sanjoy]

• No need for extraClassDeclaration in always_speculatable_op

[dcaballe]

Thanks, Sanjoy. Just did a quick pass for now.

mlir/include/mlir/Interfaces/SideEffectInterfaces.h

199

nit: use ` ` for code references?

242

typo: remove injects? Not sure I can parse this properly. Same below.

mlir/include/mlir/Interfaces/SideEffectInterfaces.td

159

nit: indent?

mlir/test/Transforms/loop-invariant-code-motion.mlir

442

nit: add // ----- markers or split-input-file

[zero9178]

I am a bit concerned by this patch conflating the concepts of specutability and the notion of side effects. In particular the fact that AlwaysSpeculatable and RecursiveSpeculatable have essentially now been made supersets of NoSideEffect. I believe these two things to be orthogonal concepts. That means that an operation that has side effects, may still want to implement the specutable interface, if it is possibly free of undefined behaviour. I think this is actually rather common with MemAlloc ops. Callers of the interface (aka the passes like LICM), should be the ones to do analysis and to choose whether it can handle a specutable op with side effects and I don't see a reason the interface can't support this.

I would personally, if possible, also split the patch. First one maybe implementing the interface and its API, followed by LICM changes, followed by changes to upstream dialects. I'd wait for other reviewers to suggest this as well however and not just take my word for it.

mlir/include/mlir/Interfaces/SideEffectInterfaces.h

259

There is a little trick/hack you can do here, but I am not sure how others feel about it. Instead of inheriting from TraitBase you could inherit from ConditionallySpeculatable::Trait. This would lead to an Op using this trait to both, automatically become an instance of ConditionallySpeculatable as well as inject an implementation via the trait.

mlir/lib/Transforms/Utils/LoopInvariantCodeMotionUtils.cpp

103–105

This should check for both isSideEffectFree, and isSpecutable. The former, as it'd require analysis to prove there is not interferring writes otherwise, the later to not introduce any UB.

mlir/lib/Transforms/Utils/SideEffectUtils.cpp

67

The MemoryEffectsOpInterface is capable of conditionally returning side effects based on an operations property, so this already exists.

I also think this assert should be removed due to the reasons in my comment.

[sanjoy]

@zero9178

Just making sure I understand -- are you saying that MemAlloc is speculatable but still needs a non-trivial MemoryEffect because it allocates memory? Now that I think of it, another such example is a load from a global variable. Since the global variable is deferenceable for the lifetime of the program, the load itself is speculatable, but we still need to model the read memory effect to make sure we don't reorder it with aliasing writes.

So I agree that splitting Speculatable from MemoryEffect is a good idea. However, IMO it is confusing to say "this op has side effects but can be speculated", so I propose s/NoSideEffect/NoMemoryEffect and s/isSideEffectFree/isMemoryEffectFree in the patch and then make the other changes you suggest below.

And I'll create a def Pure : TraitList[AlwaysSpeculatable, NoMemoryEffects]; (name bikeshedding welcome) to reduce boilerplate for the large number of ops that need both.

What do you think? CC @rriddle

Regarding

I would personally, if possible, also split the patch.

I wanted a non-trivial test case for the op interface with its patch, so I had to combine LICM with adding it, and this meant I need to change all the upstream ops to avoid regression.

[sanjoy]

Addressed review comments:

• Cleanly split out memory effects from speculatibility
• Fixed nits

[sanjoy]

mlir/test/Transforms/loop-invariant-code-motion.mlir

442

My understanding was that for tests that are not checking for errors, the benefit of // ----- is that it avoids name clashes, e.g. I didn't need to check if test_never_speculatable_op existed earlier in this file. If that's true, then this scope looks fine to me; it demarcates a "block" of related tests.

Please let me know if I'm missing something here.

[sanjoy]

• fix comment

[sanjoy]

@zero9178: incorporated your suggestion, PTAL.

mlir/include/mlir/Interfaces/SideEffectInterfaces.h

259

Does this trick exist elsewhere in the codebase?

[silvas]

3. Add some documentation / FAQs detailing the differences between side effects, undefined behavior, speculatabilty.

Where is this? I would have perhaps expected it in Rationale.md

mlir/lib/Transforms/Utils/SideEffectUtils.cpp

16

Is this a TODO?

[sanjoy]

Remove stray comment

[sanjoy]

Where is this? I would have perhaps expected it in Rationale.md

Thanks, Rationale.md sounds good!

mlir/lib/Transforms/Utils/SideEffectUtils.cpp

16

That's a stray comment, removed.

[sanjoy]

• remove stray whitespace

[zero9178]

In D135505#3845658, @sanjoy wrote:

@zero9178

Just making sure I understand -- are you saying that MemAlloc is speculatable but still needs a non-trivial MemoryEffect because it allocates memory? Now that I think of it, another such example is a load from a global variable. Since the global variable is deferenceable for the lifetime of the program, the load itself is speculatable, but we still need to model the read memory effect to make sure we don't reorder it with aliasing writes.

Yes, and your load operation example is even better (and something LLVM does IIRC).

So I agree that splitting Speculatable from MemoryEffect is a good idea. However, IMO it is confusing to say "this op has side effects but can be speculated", so I propose s/NoSideEffect/NoMemoryEffect and s/isSideEffectFree/isMemoryEffectFree in the patch and then make the other changes you suggest below.

I am indifferent about that, but do wonder whether it is somewhat out of scope for this patch and requires more discussion. It is renaming one of the (if not the) most used trait after all, and its not obvious for downstream users looking through the commit title that such a rename is required.

mlir/include/mlir/Interfaces/SideEffectInterfaces.h

259

I don't think so. On further thought your ODS logic is probably better.

mlir/include/mlir/Interfaces/SideEffectInterfaces.td

114–116

Why is the method body here required? I believe this is equal to what TableGen generates by default.

[sanjoy]

• Remove code that TableGen generates anyway

[sanjoy]

In D135505#3847282, @zero9178 wrote:

I am indifferent about that, but do wonder whether it is somewhat out of scope for this patch and requires more discussion. It is renaming one of the (if not the) most used trait after all, and its not obvious for downstream users looking through the commit title that such a rename is required.

I'm happy to change the commit message or announce in a wider forum, but I don't think keeping both Speculatable and NoSideEffect (in its current form) in the MLIR vocabulary is a reasonable end state. Operations with side effects (in the traditional sense) are by definition not speculatable so having an operation that both has "side effects" and is also speculatable is pretty confusiong IMO.

I also don't think the migration cost for out of tree dialects is high -- they just need to s/NoSideEffect/Pure/ to get the older behavior.

[mehdi_amini]

In D135505#3847337, @sanjoy wrote:

I also don't think the migration cost for out of tree dialects is high -- they just need to s/NoSideEffect/Pure/ to get the older behavior.

Technically the "safe" update is s/NoSideEffect /NoMemoryEffect/ right?
(I agree that most of the time they want Pure instead)

Current patch LGTM overall, but of course it is central enough to MLIR that we should make sure we have a larger consensus, waiting to hear from @rriddle and @jpienaar in particular.

[sanjoy]

In D135505#3848200, @mehdi_amini wrote:

Technically the "safe" update is s/NoSideEffect /NoMemoryEffect/

(I agree that most of the time they want Pure instead)

Yes to both.

[rriddle]

Sorry for the delay, I've been out. This LGTM. I had the same concerns as others about the original patch, which had speculatability becoming a superset of no memory effects. Pure seems like a good name to describe the behavior.

In D135505#3846950, @sanjoy wrote:

Where is this? I would have perhaps expected it in Rationale.md

Thanks, Rationale.md sounds good!

I'd love to instead have a proper SideEffects.md (or something) document that details our modeling of side effect behaviors, when to use which trait/interface, etc.

mlir/include/mlir/Dialect/SCF/IR/SCFOps.td

333–334

Is this really useful to add here? I'd rather just remove this and actually add it in the future if necessary.

mlir/include/mlir/Interfaces/SideEffectInterfaces.h

202–203

243

Is the ::mlir:: here necessary? Same below.

mlir/include/mlir/Interfaces/SideEffectInterfaces.td

96–116

I would move the speculation stuff under a new:

//===----------------------------------------------------------------------===//
// Speculation
//===----------------------------------------------------------------------===//

114

Can you rename this? Having an is method return something other than bool is a little confusing. It'd be nicer to name this something like: getSpeculatability

[aartbik]

LGTM for the sparse dialect ops changes (all marked as PURE)

[sanjoy]

Address review

[clementval]

Why this patch landed with obvious failures in the pre merge checks? https://buildkite.com/llvm-project/premerge-checks/builds/116406#0183ca8c-bc14-4314-9b1d-c764cf47e0aa

[mehdi_amini]

In D135505#3853465, @clementval wrote:

Why this patch landed with obvious failures in the pre merge checks? https://buildkite.com/llvm-project/premerge-checks/builds/116406#0183ca8c-bc14-4314-9b1d-c764cf47e0aa

The premiere checks aren't "visible enough": I never notice them myself (I use to when they were posting the results in a comment initially).

Please revert if a fix forward isn't straightforward (should be a sed in flang I think?)

[sanjoy]

I didn't notice the failure either. A comment would be more visible.

I'll fix forward or revert within the next hour.

[clementval]

In D135505#3853489, @mehdi_amini wrote:

In D135505#3853465, @clementval wrote:

Why this patch landed with obvious failures in the pre merge checks? https://buildkite.com/llvm-project/premerge-checks/builds/116406#0183ca8c-bc14-4314-9b1d-c764cf47e0aa

The premiere checks aren't "visible enough": I never notice them myself (I use to when they were posting the results in a comment initially).

Please revert if a fix forward isn't straightforward (should be a sed in flang I think?)

Fixed in e4ccba1598c07bc1fb6f3b73942dbc0a03fa51ed

[sanjoy]

In D135505#3853519, @clementval wrote:

In D135505#3853489, @mehdi_amini wrote:

In D135505#3853465, @clementval wrote:

Why this patch landed with obvious failures in the pre merge checks? https://buildkite.com/llvm-project/premerge-checks/builds/116406#0183ca8c-bc14-4314-9b1d-c764cf47e0aa

The premiere checks aren't "visible enough": I never notice them myself (I use to when they were posting the results in a comment initially).

Please revert if a fix forward isn't straightforward (should be a sed in flang I think?)

Fixed in e4ccba1598c07bc1fb6f3b73942dbc0a03fa51ed

Thanks @clementval !

[NathanielMcVicar]

There is also a failure in the MLIR Windows bot. https://lab.llvm.org/buildbot/#/builders/13/builds/27028

C:\buildbot\mlir-x64-windows-ninja\llvm-project\mlir\lib\Transforms\Utils\SideEffectUtils.cpp(58) : error C2220: the following warning is treated as an error
C:\buildbot\mlir-x64-windows-ninja\llvm-project\mlir\lib\Transforms\Utils\SideEffectUtils.cpp(58) : warning C4715: 'mlir::isSpeculatable': not all control paths return a value

[sanjoy]

In D135505#3855933, @NathanielMcVicar wrote:

There is also a failure in the MLIR Windows bot. https://lab.llvm.org/buildbot/#/builders/13/builds/27028

C:\buildbot\mlir-x64-windows-ninja\llvm-project\mlir\lib\Transforms\Utils\SideEffectUtils.cpp(58) : error C2220: the following warning is treated as an error
C:\buildbot\mlir-x64-windows-ninja\llvm-project\mlir\lib\Transforms\Utils\SideEffectUtils.cpp(58) : warning C4715: 'mlir::isSpeculatable': not all control paths return a value

How do we usually address these? I believe that switch covers all enums so this looks like a false positive to me.

[NathanielMcVicar]

In D135505#3856160, @sanjoy wrote:

How do we usually address these? I believe that switch covers all enums so this looks like a false positive to me.

I believe the easiest way to make all the compilers happy is to put an llvm_unreachable or equivalent at the end of the function after the case.

[clementval]

In D135505#3856160, @sanjoy wrote:

In D135505#3855933, @NathanielMcVicar wrote:

There is also a failure in the MLIR Windows bot. https://lab.llvm.org/buildbot/#/builders/13/builds/27028

C:\buildbot\mlir-x64-windows-ninja\llvm-project\mlir\lib\Transforms\Utils\SideEffectUtils.cpp(58) : error C2220: the following warning is treated as an error
C:\buildbot\mlir-x64-windows-ninja\llvm-project\mlir\lib\Transforms\Utils\SideEffectUtils.cpp(58) : warning C4715: 'mlir::isSpeculatable': not all control paths return a value

How do we usually address these? I believe that switch covers all enums so this looks like a false positive to me.

gcc is also raising a wanring for this. I think you need need a default case to get rid of it.

[sanjoy]

Sent https://reviews.llvm.org/D135899 adding the llvm_unreachable.

I'd prefer to not add a default: since that would silence the warning we'd otherwise get if someone adds a new enum value and forgets to update this method.

[silvas]

More info on switches here: https://llvm.org/docs/CodingStandards.html#don-t-use-default-labels-in-fully-covered-switches-over-enumerations

[lattner]

I just noticed this patch when it got merged into our tree.

@sanjoy question for you:

Replace NoSideEffect with Pure if the operation does not have any memory effects, undefined behavior or infinite loops.

Did you consider alternate names for this than "Pure"? Pure has historically been super confusing for people because it means different things in different contexts. For example, the GCC/Clang "pure" attribute, actually means "readonly" and not "readnone".

Did you consider something more explicit and less loaded with terminology baggage?

[lattner]

More information on the GCC/Clang attribute semantics:
https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html

The confusion here is why llvm calls the corresponding concepts "readonly" and "readnone". These are perhaps not general enough to model the MLIR concept, but you can hopefully understand the need for better names than "pure" and "const".

[sanjoy]

In D135505#3860870, @lattner wrote:

Did you consider something more explicit and less loaded with terminology baggage?

How about NoMemoryEffectAndTotal ("total" as in "total function") or NoMemoryEffectAndAlwaysSpeculatable (verbose but more obvious)?

mlir/docs/OpDefinitions.md

 *   The `AttrConstraint` class hierarchy: They are used to specify the
     constraints over attributes. A notable subclass hierarchy is `Attr`, which
     stands for constraints for attributes whose values are of common types.
 
 An operation is defined by specializing the `Op` class with concrete contents
 for all the fields it requires. For example, `tf.AvgPool` is defined as
 
 ```tablegen
-def TF_AvgPoolOp : TF_Op<"AvgPool", [NoSideEffect]> {
+def TF_AvgPoolOp : TF_Op<"AvgPool", [NoMemoryEffect]> {
   let summary = "Performs average pooling on the input.";
 
   let description = [{
 Each entry in `output` is the mean of the corresponding size `ksize`
 window in `value`.
   }];
 
   let arguments = (ins

mlir/docs/Tutorials/QuickstartRewrites.md

*   Documentation of the operation. This includes a one-line summary as well as
     a longer human-readable description of the operation.
 *   Dialect specific information. Additional information could be added to the
     operation definition that are only used by dialect specific drivers. These
     are ignored by the main op and doc generators, but could be used in, say,
     the translation from a dialect to another representation.
 
 ```tablegen
 def TFL_LeakyReluOp: TFL_Op<TFL_Dialect, "leaky_relu",
-                            [NoSideEffect, SameValueType]>,
+                            [NoMemoryEffect, SameValueType]>,
                      Results<(outs Tensor)> {
   let arguments = (ins
     F32Tensor:$x,
     // Slope of the activation function at x < 0.
     F32Attr:$alpha
   );
 
   let summary = "Leaky ReLU operator";

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

 ```
 
 As expected, we now directly return the function argument, bypassing any
 transpose operation. However, one of the transposes still hasn't been
 eliminated. That is not ideal! What happened is that our pattern replaced the
 last transform with the function input and left behind the now dead transpose
 input. The Canonicalizer knows to clean up dead operations; however, MLIR
 conservatively assumes that operations may have side-effects. We can fix this by
-adding a new trait, `NoSideEffect`, to our `TransposeOp`:
+adding a new trait, `NoMemoryEffect`, to our `TransposeOp`:
 
 ```tablegen
-def TransposeOp : Toy_Op<"transpose", [NoSideEffect]> {...}
+def TransposeOp : Toy_Op<"transpose", [NoMemoryEffect]> {...}
 ```
 
 Let's retry now `toyc-ch3 test/transpose_transpose.toy -emit=mlir -opt`:
 
 ```mlir
 toy.func @transpose_transpose(%arg0: tensor<*xf64>) -> tensor<*xf64> {
   toy.return %arg0 : tensor<*xf64>
 }

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

 the inputs to the function expect `tensor<*xf64>`. To resolve this difference,
 the inliner expects an explicit cast operation to be inserted. For this, we need
 to add a new operation to the Toy dialect, `ToyCastOp`(toy.cast), to represent
 casts between two different shapes.
 
 ```tablegen
 def CastOp : Toy_Op<"cast", [
     DeclareOpInterfaceMethods<CastOpInterface>,
-    NoSideEffect,
+    NoMemoryEffect,
     SameOperandsAndResultShape]
   > {
   let summary = "shape cast operation";
   let description = [{
     The "cast" operation converts a tensor from one type to an equivalent type
     without changing any data elements. The source and destination types
     must both be tensor types with the same element type. If both are ranked,
     then shape is required to match. The operation is invalid if converting

mlir/examples/standalone/include/Standalone/StandaloneOps.td

 //===- StandaloneOps.td - Standalone dialect ops -----------*- tablegen -*-===//
 //
 // This file is licensed 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 STANDALONE_OPS
 #define STANDALONE_OPS
 
 include "Standalone/StandaloneDialect.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
-def Standalone_FooOp : Standalone_Op<"foo", [NoSideEffect,
+def Standalone_FooOp : Standalone_Op<"foo", [Pure,
                                              SameOperandsAndResultType]> {
     let summary = "Illustrates how to define an operation.";
     let description = [{
         The `standalone.foo` operation illustrates how to define a new
         operation in a dialect. It uses an operation trait to declare that it
         has no side effects.
 
         This operation takes an integer argument and returns an integer.

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

 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 // 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
-// constant operation is marked as 'NoSideEffect' as it is a pure operation
+// constant operation is marked as 'Pure' as it is a pure operation
 // and may be removed if dead.
-def ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
+def ConstantOp : Toy_Op<"constant", [Pure]> {
   // 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";
   let description = [{
     Constant operation turns a literal into an SSA value. The data is attached
     to the operation as an attribute. For example:
 
     ```mlir
let assemblyFormat = [{
     `(` $input `:` type($input) `)` attr-dict `to` type(results)
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // ReturnOp
 //===----------------------------------------------------------------------===//
 
-def ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
+def ReturnOp : Toy_Op<"return", [Pure, HasParent<"FuncOp">,
                                  Terminator]> {
   let summary = "return operation";
   let description = [{
     The "return" operation represents a return operation within a function.
     The operation takes an optional tensor operand and produces no results.
     The operand type must match the signature of the function that contains
     the operation. For example:
 

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

 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 // 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
-// constant operation is marked as 'NoSideEffect' as it is a pure operation
+// constant operation is marked as 'Pure' as it is a pure operation
 // and may be removed if dead.
-def ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
+def ConstantOp : Toy_Op<"constant", [Pure]> {
   // 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";
   let description = [{
     Constant operation turns a literal into an SSA value. The data is attached
     to the operation as an attribute. For example:
 
     ```mlir
def ConstantOp : Toy_Op<"constant", [Pure]> {
   // Indicate that additional verification for this operation is necessary.
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AddOp
 //===----------------------------------------------------------------------===//
 
-def AddOp : Toy_Op<"add", [NoSideEffect]> {
+def AddOp : Toy_Op<"add", [Pure]> {
   let summary = "element-wise addition operation";
   let description = [{
     The "add" operation performs element-wise addition between two tensors.
     The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
let builders = [
     OpBuilder<(ins "StringRef":$callee, "ArrayRef<Value>":$arguments)>
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // MulOp
 //===----------------------------------------------------------------------===//
 
-def MulOp : Toy_Op<"mul", [NoSideEffect]> {
+def MulOp : Toy_Op<"mul", [Pure]> {
   let summary = "element-wise multiplication operation";
   let description = [{
     The "mul" operation performs element-wise multiplication between two
     tensors. The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
def PrintOp : Toy_Op<"print"> {
 
   let assemblyFormat = "$input attr-dict `:` type($input)";
 }
 
 //===----------------------------------------------------------------------===//
 // ReshapeOp
 //===----------------------------------------------------------------------===//
 
-def ReshapeOp : Toy_Op<"reshape", [NoSideEffect]> {
+def ReshapeOp : Toy_Op<"reshape", [Pure]> {
   let summary = "tensor reshape operation";
   let description = [{
     Reshape operation is transforming its input tensor into a new tensor with
     the same number of elements but different shapes. For example:
 
     ```mlir
        %0 = toy.reshape (%arg1 : tensor<10xf64>) to tensor<5x2xf64>
     ```
def ReshapeOp : Toy_Op<"reshape", [Pure]> {
   // Enable registering canonicalization patterns with this operation.
   let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ReturnOp
 //===----------------------------------------------------------------------===//
 
-def ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
+def ReturnOp : Toy_Op<"return", [Pure, HasParent<"FuncOp">,
                                  Terminator]> {
   let summary = "return operation";
   let description = [{
     The "return" operation represents a return operation within a function.
     The operation takes an optional tensor operand and produces no results.
     The operand type must match the signature of the function that contains
     the operation. For example:
 
def ReturnOp : Toy_Op<"return", [Pure, HasParent<"FuncOp">,
   // Indicate that additional verification for this operation is necessary.
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 //===----------------------------------------------------------------------===//
 
-def TransposeOp : Toy_Op<"transpose", [NoSideEffect]> {
+def TransposeOp : Toy_Op<"transpose", [Pure]> {
   let summary = "transpose operation";
 
   let arguments = (ins F64Tensor:$input);
   let results = (outs F64Tensor);
 
   let assemblyFormat = [{
     `(` $input `:` type($input) `)` attr-dict `to` type(results)
   }];

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

 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 // 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
-// constant operation is marked as 'NoSideEffect' as it is a pure operation
+// constant operation is marked as 'Pure' as it is a pure operation
 // and may be removed if dead.
-def ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
+def ConstantOp : Toy_Op<"constant", [Pure]> {
   // 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";
   let description = [{
     Constant operation turns a literal into an SSA value. The data is attached
     to the operation as an attribute. For example:
 
     ```mlir
def ConstantOp : Toy_Op<"constant", [Pure]> {
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AddOp
 //===----------------------------------------------------------------------===//
 
 def AddOp : Toy_Op<"add",
-    [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "element-wise addition operation";
   let description = [{
     The "add" operation performs element-wise addition between two tensors.
     The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);

 
 //===----------------------------------------------------------------------===//
 // CastOp
 //===----------------------------------------------------------------------===//
 
 def CastOp : Toy_Op<"cast", [
      DeclareOpInterfaceMethods<CastOpInterface>,
      DeclareOpInterfaceMethods<ShapeInferenceOpInterface>,
-     NoSideEffect,
+     Pure,
      SameOperandsAndResultShape
   ]> {
   let summary = "shape cast operation";
   let description = [{
     The "cast" operation converts a tensor from one type to an equivalent type
     without changing any data elements. The source and destination types must
     both be tensor types with the same element type. If both are ranked, then
     shape is required to match. The operation is invalid if converting to a
def GenericCallOp : Toy_Op<"generic_call",
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // MulOp
 //===----------------------------------------------------------------------===//
 
 def MulOp : Toy_Op<"mul",
-    [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "element-wise multiplication operation";
   let description = [{
     The "mul" operation performs element-wise multiplication between two
     tensors. The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
def PrintOp : Toy_Op<"print"> {
 
   let assemblyFormat = "$input attr-dict `:` type($input)";
 }
 
 //===----------------------------------------------------------------------===//
 // ReshapeOp
 //===----------------------------------------------------------------------===//
 
-def ReshapeOp : Toy_Op<"reshape", [NoSideEffect]> {
+def ReshapeOp : Toy_Op<"reshape", [Pure]> {
   let summary = "tensor reshape operation";
   let description = [{
     Reshape operation is transforming its input tensor into a new tensor with
     the same number of elements but different shapes. For example:
 
     ```mlir
        %0 = toy.reshape (%arg1 : tensor<10xf64>) to tensor<5x2xf64>
     ```
def ReshapeOp : Toy_Op<"reshape", [Pure]> {
   // Enable registering canonicalization patterns with this operation.
   let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ReturnOp
 //===----------------------------------------------------------------------===//
 
-def ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
+def ReturnOp : Toy_Op<"return", [Pure, HasParent<"FuncOp">,
                                  Terminator]> {
   let summary = "return operation";
   let description = [{
     The "return" operation represents a return operation within a function.
     The operation takes an optional tensor operand and produces no results.
     The operand type must match the signature of the function that contains
     the operation. For example:
 
def ReturnOp : Toy_Op<"return", [Pure, HasParent<"FuncOp">,
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 //===----------------------------------------------------------------------===//
 
 def TransposeOp : Toy_Op<"transpose",
-    [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "transpose operation";
 
   let arguments = (ins F64Tensor:$input);
   let results = (outs F64Tensor);
 
   let assemblyFormat = [{
     `(` $input `:` type($input) `)` attr-dict `to` type(results)
   }];

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

 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 // 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
-// constant operation is marked as 'NoSideEffect' as it is a pure operation
+// constant operation is marked as 'Pure' as it is a pure operation
 // and may be removed if dead.
-def ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
+def ConstantOp : Toy_Op<"constant", [Pure]> {
   // 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";
   let description = [{
     Constant operation turns a literal into an SSA value. The data is attached
     to the operation as an attribute. For example:
 
     ```mlir
def ConstantOp : Toy_Op<"constant", [Pure]> {
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AddOp
 //===----------------------------------------------------------------------===//
 
 def AddOp : Toy_Op<"add",
-    [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "element-wise addition operation";
   let description = [{
     The "add" operation performs element-wise addition between two tensors.
     The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);

 
 //===----------------------------------------------------------------------===//
 // CastOp
 //===----------------------------------------------------------------------===//
 
 def CastOp : Toy_Op<"cast", [
      DeclareOpInterfaceMethods<CastOpInterface>,
      DeclareOpInterfaceMethods<ShapeInferenceOpInterface>,
-     NoSideEffect,
+     Pure,
      SameOperandsAndResultShape
   ]> {
   let summary = "shape cast operation";
   let description = [{
     The "cast" operation converts a tensor from one type to an equivalent type
     without changing any data elements. The source and destination types must
     both be tensor types with the same element type. If both are ranked, then
     shape is required to match. The operation is invalid if converting to a
def GenericCallOp : Toy_Op<"generic_call",
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // MulOp
 //===----------------------------------------------------------------------===//
 
 def MulOp : Toy_Op<"mul",
-    [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "element-wise multiplication operation";
   let description = [{
     The "mul" operation performs element-wise multiplication between two
     tensors. The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
def PrintOp : Toy_Op<"print"> {
 
   let assemblyFormat = "$input attr-dict `:` type($input)";
 }
 
 //===----------------------------------------------------------------------===//
 // ReshapeOp
 //===----------------------------------------------------------------------===//
 
-def ReshapeOp : Toy_Op<"reshape", [NoSideEffect]> {
+def ReshapeOp : Toy_Op<"reshape", [Pure]> {
   let summary = "tensor reshape operation";
   let description = [{
     Reshape operation is transforming its input tensor into a new tensor with
     the same number of elements but different shapes. For example:
 
     ```mlir
        %0 = toy.reshape (%arg1 : tensor<10xf64>) to tensor<5x2xf64>
     ```
def ReshapeOp : Toy_Op<"reshape", [Pure]> {
   // Enable registering canonicalization patterns with this operation.
   let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ReturnOp
 //===----------------------------------------------------------------------===//
 
-def ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
+def ReturnOp : Toy_Op<"return", [Pure, HasParent<"FuncOp">,
                                  Terminator]> {
   let summary = "return operation";
   let description = [{
     The "return" operation represents a return operation within a function.
     The operation takes an optional tensor operand and produces no results.
     The operand type must match the signature of the function that contains
     the operation. For example:
 
def ReturnOp : Toy_Op<"return", [Pure, HasParent<"FuncOp">,
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 //===----------------------------------------------------------------------===//
 
 def TransposeOp : Toy_Op<"transpose",
-    [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "transpose operation";
 
   let arguments = (ins F64Tensor:$input);
   let results = (outs F64Tensor);
 
   let assemblyFormat = [{
     `(` $input `:` type($input) `)` attr-dict `to` type(results)
   }];

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

 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 // 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
-// constant operation is marked as 'NoSideEffect' as it is a pure operation
+// constant operation is marked as 'Pure' as it is a pure operation
 // and may be removed if dead.
-def ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
+def ConstantOp : Toy_Op<"constant", [Pure]> {
   // 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";
   let description = [{
     Constant operation turns a literal into an SSA value. The data is attached
     to the operation as an attribute. For example:
 
     ```mlir
def ConstantOp : Toy_Op<"constant", [Pure]> {
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AddOp
 //===----------------------------------------------------------------------===//
 
 def AddOp : Toy_Op<"add",
-    [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "element-wise addition operation";
   let description = [{
     The "add" operation performs element-wise addition between two tensors.
     The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);

 
 //===----------------------------------------------------------------------===//
 // CastOp
 //===----------------------------------------------------------------------===//
 
 def CastOp : Toy_Op<"cast", [
      DeclareOpInterfaceMethods<CastOpInterface>,
      DeclareOpInterfaceMethods<ShapeInferenceOpInterface>,
-     NoSideEffect,
+     Pure,
      SameOperandsAndResultShape
   ]> {
   let summary = "shape cast operation";
   let description = [{
     The "cast" operation converts a tensor from one type to an equivalent type
     without changing any data elements. The source and destination types must
     both be tensor types with the same element type. If both are ranked, then
     shape is required to match. The operation is invalid if converting to a
def GenericCallOp : Toy_Op<"generic_call",
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // MulOp
 //===----------------------------------------------------------------------===//
 
 def MulOp : Toy_Op<"mul",
-    [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "element-wise multiplication operation";
   let description = [{
     The "mul" operation performs element-wise multiplication between two
     tensors. The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
def PrintOp : Toy_Op<"print"> {
 
   let assemblyFormat = "$input attr-dict `:` type($input)";
 }
 
 //===----------------------------------------------------------------------===//
 // ReshapeOp
 //===----------------------------------------------------------------------===//
 
-def ReshapeOp : Toy_Op<"reshape", [NoSideEffect]> {
+def ReshapeOp : Toy_Op<"reshape", [Pure]> {
   let summary = "tensor reshape operation";
   let description = [{
     Reshape operation is transforming its input tensor into a new tensor with
     the same number of elements but different shapes. For example:
 
     ```mlir
        %0 = toy.reshape (%arg1 : tensor<10xf64>) to tensor<5x2xf64>
     ```
def ReshapeOp : Toy_Op<"reshape", [Pure]> {
   // We expect that the reshape operation returns a statically shaped tensor.
   let results = (outs StaticShapeTensorOf<[F64]>);
 }
 
 //===----------------------------------------------------------------------===//
 // ReturnOp
 //===----------------------------------------------------------------------===//
 
-def ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
+def ReturnOp : Toy_Op<"return", [Pure, HasParent<"FuncOp">,
                                  Terminator]> {
   let summary = "return operation";
   let description = [{
     The "return" operation represents a return operation within a function.
     The operation takes an optional tensor operand and produces no results.
     The operand type must match the signature of the function that contains
     the operation. For example:
 
def ReturnOp : Toy_Op<"return", [Pure, HasParent<"FuncOp">,
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 //===----------------------------------------------------------------------===//
 
 def TransposeOp : Toy_Op<"transpose",
-    [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "transpose operation";
 
   let arguments = (ins F64Tensor:$input);
   let results = (outs F64Tensor);
 
   let assemblyFormat = [{
     `(` $input `:` type($input) `)` attr-dict `to` type(results)
   }];

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

 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 // 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
-// constant operation is marked as 'NoSideEffect' as it is a pure operation
+// constant operation is marked as 'Pure' as it is a pure operation
 // and may be removed if dead.
 def ConstantOp : Toy_Op<"constant",
-    [ConstantLike, NoSideEffect,
+    [ConstantLike, Pure,
      DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   // 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";
   let description = [{
     Constant operation turns a literal into an SSA value. The data is attached
     to the operation as an attribute. For example:
 
def ConstantOp : Toy_Op<"constant",
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AddOp
 //===----------------------------------------------------------------------===//
 
 def AddOp : Toy_Op<"add",
-    [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "element-wise addition operation";
   let description = [{
     The "add" operation performs element-wise addition between two tensors.
     The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);

 
 //===----------------------------------------------------------------------===//
 // CastOp
 //===----------------------------------------------------------------------===//
 
 def CastOp : Toy_Op<"cast", [
      DeclareOpInterfaceMethods<CastOpInterface>,
      DeclareOpInterfaceMethods<ShapeInferenceOpInterface>,
-     NoSideEffect,
+     Pure,
      SameOperandsAndResultShape
   ]> {
   let summary = "shape cast operation";
   let description = [{
     The "cast" operation converts a tensor from one type to an equivalent type
     without changing any data elements. The source and destination types must
     both be tensor types with the same element type. If both are ranked, then
     shape is required to match. The operation is invalid if converting to a
def GenericCallOp : Toy_Op<"generic_call",
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // MulOp
 //===----------------------------------------------------------------------===//
 
 def MulOp : Toy_Op<"mul",
-    [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "element-wise multiplication operation";
   let description = [{
     The "mul" operation performs element-wise multiplication between two
     tensors. The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
def PrintOp : Toy_Op<"print"> {
 
   let assemblyFormat = "$input attr-dict `:` type($input)";
 }
 
 //===----------------------------------------------------------------------===//
 // ReshapeOp
 //===----------------------------------------------------------------------===//
 
-def ReshapeOp : Toy_Op<"reshape", [NoSideEffect]> {
+def ReshapeOp : Toy_Op<"reshape", [Pure]> {
   let summary = "tensor reshape operation";
   let description = [{
     Reshape operation is transforming its input tensor into a new tensor with
     the same number of elements but different shapes. For example:
 
     ```mlir
        %0 = toy.reshape (%arg1 : tensor<10xf64>) to tensor<5x2xf64>
     ```
def ReshapeOp : Toy_Op<"reshape", [Pure]> {
   // We expect that the reshape operation returns a statically shaped tensor.
   let results = (outs StaticShapeTensorOf<[F64]>);
 }
 
 //===----------------------------------------------------------------------===//
 // ReturnOp
 //===----------------------------------------------------------------------===//
 
-def ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
+def ReturnOp : Toy_Op<"return", [Pure, HasParent<"FuncOp">,
                                  Terminator]> {
   let summary = "return operation";
   let description = [{
     The "return" operation represents a return operation within a function.
     The operation takes an optional operand and produces no results.
     The operand type must match the signature of the function that contains
     the operation. For example:
 
def ReturnOp : Toy_Op<"return", [Pure, HasParent<"FuncOp">,
   // Indicate that additional verification for this operation is necessary.
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // StructAccessOp
 //===----------------------------------------------------------------------===//
 
-def StructAccessOp : Toy_Op<"struct_access", [NoSideEffect]> {
+def StructAccessOp : Toy_Op<"struct_access", [Pure]> {
   let summary = "struct access";
   let description = [{
     Access the Nth element of a value returning a struct type.
   }];
 
   let arguments = (ins Toy_StructType:$input, I64Attr:$index);
   let results = (outs Toy_Type:$output);
 
def StructAccessOp : Toy_Op<"struct_access", [Pure]> {
   // Set the folder bit so that we can fold constant accesses.
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // StructConstantOp
 //===----------------------------------------------------------------------===//
 
-def StructConstantOp : Toy_Op<"struct_constant", [ConstantLike, NoSideEffect]> {
+def StructConstantOp : Toy_Op<"struct_constant", [ConstantLike, Pure]> {
   let summary = "struct constant";
   let description = [{
     Constant operation turns a literal struct value into an SSA value. The data
     is attached to the operation as an attribute. The struct constant is encoded
     as an array of other constant values. For example:
 
     ```mlir
       %0 = toy.struct_constant [
def StructConstantOp : Toy_Op<"struct_constant", [ConstantLike, Pure]> {
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 //===----------------------------------------------------------------------===//
 
 def TransposeOp : Toy_Op<"transpose",
-    [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "transpose operation";
 
   let arguments = (ins F64Tensor:$input);
   let results = (outs F64Tensor);
 
   let assemblyFormat = [{
     `(` $input `:` type($input) `)` attr-dict `to` type(results)
   }];

mlir/include/mlir/Dialect/AMDGPU/AMDGPU.td

 def MFMAOutTypes : AnyTypeOf<[F64,
                               VectorOfLengthAndType<[4, 16, 32], [F32]>,
                               VectorOfLengthAndType<[4, 16, 32], [I32]>,
                               VectorOfLengthAndType<[4], [F64]>]>;
 
 def AMDGPU_MFMAOp :
     AMDGPU_Op<"mfma", [AllTypesMatch<["sourceA", "sourceB"]>,
                         AllTypesMatch<["destC", "destD"]>,
-                        NoSideEffect]>,
+                        Pure]>,
     Arguments<(ins
                    I32Attr:$m,
                    I32Attr:$n,
                    I32Attr:$k,
                    I32Attr:$blocks,
                    MFMAInTypes:$sourceA,
                    MFMAInTypes:$sourceB,
                    MFMAOutTypes:$destC,

mlir/include/mlir/Dialect/AMX/AMX.td

 //===----------------------------------------------------------------------===//
 // AMX Op definitions (user facing).
 //===----------------------------------------------------------------------===//
 
 //
 // Tile reset.
 //
 
-def TileZeroOp : AMX_Op<"tile_zero", [NoSideEffect]> {
+def TileZeroOp : AMX_Op<"tile_zero", [Pure]> {
   let summary = "tile zero operation";
   let description = [{
     Zeroes the destination tile, with the shape defined by the 2-dim
     vector type of the result. This is eventually lowered into the
     "tilezero" instruction with the corresponding tile configuration.
 
     Example:
 
def TileZeroOp : AMX_Op<"tile_zero", [Pure]> {
   let assemblyFormat = "attr-dict `:` type($res)";
   let hasVerifier = 1;
 }
 
 //
 // Tile memory operations.
 //
 
-def TileLoadOp : AMX_Op<"tile_load", [NoSideEffect]> {
+def TileLoadOp : AMX_Op<"tile_load", [Pure]> {
   let summary = "tile load operation";
   let description = [{
     Loads a tile from memory defined by a base and indices, with the
     shape defined by the 2-dim vector type of the result. This is
     eventually lowered into the "tileloadd" instruction with the
     corresponding tile configuration.
 
     Example:
let assemblyFormat = "$base `[` $indices `]` `,` $val attr-dict `:` "
                        "type($base) `,` type($val)";
   let hasVerifier = 1;
 }
 
 //
 // Tile arithmetic operations.
 //
 
-def TileMulFOp : AMX_Op<"tile_mulf", [NoSideEffect, AllTypesMatch<["acc", "res"]>]> {
+def TileMulFOp : AMX_Op<"tile_mulf", [
+    Pure, AllTypesMatch<["acc", "res"]>]> {
   let summary = "tile multiplication operation (floating-point)";
   let description = [{
     Multiplies a "m x k" tile with a "k x n" tile and accumulates the results
     into a "m x n" destination tile. Supports "f32 <- bf16 x bf16" (with
     pairs of "bf16"). The operation is eventually lowered into the
     "tdpbf16ps" instruction with the corresponding tile configuration.
 
     Example:
VectorType getVectorType() {
       return getRes().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat = "$lhs `,` $rhs `,` $acc attr-dict `:` "
                        "type($lhs) `,` type($rhs) `,` type($acc) ";
   let hasVerifier = 1;
 }
 
-def TileMulIOp : AMX_Op<"tile_muli", [NoSideEffect, AllTypesMatch<["acc", "res"]>]> {
+def TileMulIOp : AMX_Op<"tile_muli", [
+    Pure, AllTypesMatch<["acc", "res"]>]> {
   let summary = "tile multiplication operation (integer)";
   let description = [{
     Multiplies a "m x k" tile with a "k x n" tile and accumulates the results
     into a "m x n" destination tile. Supports all "si32 <- s/ui8 x s/ui8"
     combinations (4 bytes packed into dwords in the columns of both the
     source operand tiles; the zero or sign extension is specified with
     the attributes and default to sign extended). The operation is eventually
     lowered into one of the "tdpbssd", "tdpbsud", "tdpbusd", or "tdpbuud"

mlir/include/mlir/Dialect/Affine/IR/AffineOps.td

 // Base class for Affine dialect ops.
 class Affine_Op<string mnemonic, list<Trait> traits = []> :
     Op<Affine_Dialect, mnemonic, traits>;
 
 // Require regions to have affine.yield.
 def ImplicitAffineTerminator
     : SingleBlockImplicitTerminator<"AffineYieldOp">;
 
-def AffineApplyOp : Affine_Op<"apply", [NoSideEffect]> {
+def AffineApplyOp : Affine_Op<"apply", [Pure]> {
   let summary = "affine apply operation";
   let description = [{
     The affine.apply operation applies an [affine mapping](#affine-expressions)
     to a list of SSA values, yielding a single SSA value. The number of
     dimension and symbol arguments to `affine.apply` must be equal to the
     respective number of dimensional and symbolic inputs to the affine mapping;
     the affine mapping has to be one-dimensional, and so the `affine.apply`
     operation always returns one value. The input operands and result must all
def AffineApplyOp : Affine_Op<"apply", [Pure]> {
 
   let hasCanonicalizer = 1;
   let hasCustomAssemblyFormat = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
 def AffineForOp : Affine_Op<"for",
-    [AutomaticAllocationScope, ImplicitAffineTerminator, RecursiveSideEffects,
-     DeclareOpInterfaceMethods<LoopLikeOpInterface,
+    [AutomaticAllocationScope, ImplicitAffineTerminator, RecursivelySpeculatable,
+     RecursiveMemoryEffects, DeclareOpInterfaceMethods<LoopLikeOpInterface,
      ["getSingleInductionVar", "getSingleLowerBound", "getSingleStep",
       "getSingleUpperBound"]>,
      DeclareOpInterfaceMethods<RegionBranchOpInterface,
      ["getSuccessorEntryOperands"]>]> {
   let summary = "for operation";
   let description = [{
     Syntax:
 
def AffineForOp : Affine_Op<"for",
 
   let hasCanonicalizer = 1;
   let hasCustomAssemblyFormat = 1;
   let hasFolder = 1;
   let hasRegionVerifier = 1;
 }
 
 def AffineIfOp : Affine_Op<"if",
-                           [ImplicitAffineTerminator, RecursiveSideEffects,
-                            NoRegionArguments]> {
+                           [ImplicitAffineTerminator, RecursivelySpeculatable,
+                            RecursiveMemoryEffects, NoRegionArguments]> {
   let summary = "if-then-else operation";
   let description = [{
     Syntax:
 
     ```
     operation  ::= `affine.if` if-op-cond `{` op* `}` (`else` `{` op* `}`)?
     if-op-cond ::= integer-set-attr dim-and-symbol-use-list
     ```
let extraClassDeclaration = [{
     }
   }];
   let hasCustomAssemblyFormat = 1;
   let hasFolder = 1;
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
 }
 
-def AffineMinOp : AffineMinMaxOpBase<"min", [NoSideEffect]> {
+def AffineMinOp : AffineMinMaxOpBase<"min", [Pure]> {
   let summary = "min operation";
   let description = [{
     Syntax:
 
     ```
     operation ::= ssa-id `=` `affine.min` affine-map-attribute dim-and-symbol-use-list
     ```
 
     The `affine.min` operation applies an [affine mapping](#affine-expressions)
     to a list of SSA values, and returns the minimum value of all result
     expressions. The number of dimension and symbol arguments to `affine.min`
     must be equal to the respective number of dimensional and symbolic inputs to
     the affine mapping; the `affine.min` operation always returns one value. The
     input operands and result must all have 'index' type.
 
     Example:
 
     ```mlir
     %0 = affine.min affine_map<(d0)[s0] -> (1000, d0 + 512, s0)> (%arg0)[%arg1]
     ```
   }];
 }
 
-def AffineMaxOp : AffineMinMaxOpBase<"max", [NoSideEffect]> {
+def AffineMaxOp : AffineMinMaxOpBase<"max", [Pure]> {
   let summary = "max operation";
   let description = [{
     The "max" operation computes the maximum value result from a multi-result
     affine map.
 
     Example:
 
     ```mlir
     %0 = affine.max (d0) -> (1000, d0 + 512) (%i0) : index
     ```
   }];
 }
 
 def AffineParallelOp : Affine_Op<"parallel",
-    [AutomaticAllocationScope, ImplicitAffineTerminator, RecursiveSideEffects,
-     DeclareOpInterfaceMethods<LoopLikeOpInterface>, MemRefsNormalizable]> {
+    [AutomaticAllocationScope, ImplicitAffineTerminator, RecursivelySpeculatable,
+     RecursiveMemoryEffects, DeclareOpInterfaceMethods<LoopLikeOpInterface>,
+     MemRefsNormalizable]> {
   let summary = "multi-index parallel band operation";
   let description = [{
     The "affine.parallel" operation represents a hyper-rectangular affine
     parallel band, defining zero or more SSA values for its induction variables.
     It has one region capturing the parallel band body. The induction variables
     are represented as arguments of this region. These SSA values always have
     type index, which is the size of the machine word. The strides, represented
     by steps, are positive constant integers which defaults to "1" if not
def AffineStoreOp : AffineStoreOpBase<"store"> {
   let extraClassDeclaration = extraClassDeclarationBase;
 
   let hasCanonicalizer = 1;
   let hasCustomAssemblyFormat = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
-def AffineYieldOp : Affine_Op<"yield", [NoSideEffect, Terminator, ReturnLike,
+def AffineYieldOp : Affine_Op<"yield", [Pure, Terminator, ReturnLike,
     MemRefsNormalizable]> {
   let summary = "Yield values to parent operation";
   let description = [{
     "affine.yield" yields zero or more SSA values from an affine op region and
     terminates the region. The semantics of how the values yielded are used
     is defined by the parent operation.
     If "affine.yield" has any operands, the operands must match the parent
     operation's results.
def AffineVectorStoreOp : AffineStoreOpBase<"vector_store"> {
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AffineDelinearizeIndexOp
 //===----------------------------------------------------------------------===//
 
 def AffineDelinearizeIndexOp : Affine_Op<"delinearize_index",
-    [NoSideEffect]> {
+    [Pure]> {
   let summary = "delinearize an index";
   let description = [{
     The `affine.delinearize_index` operation takes a single index value and
     calculates the multi-index according to the given basis.
 
     Example:
 
     ```

mlir/include/mlir/Dialect/Arith/IR/ArithOps.td

 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/VectorInterfaces.td"
 include "mlir/IR/BuiltinAttributeInterfaces.td"
 include "mlir/IR/OpAsmInterface.td"
 
 // Base class for Arith dialect ops. Ops in this dialect have no side
 // effects and can be applied element-wise to vectors and tensors.
 class Arith_Op<string mnemonic, list<Trait> traits = []> :
-    Op<Arith_Dialect, mnemonic, traits # [NoSideEffect,
+    Op<Arith_Dialect, mnemonic, traits # [Pure,
     DeclareOpInterfaceMethods<VectorUnrollOpInterface>] #
     ElementwiseMappable.traits>;
 
 // Base class for integer and floating point arithmetic ops. All ops have one
 // result, require operands and results to be of the same type, and can accept
 // tensors or vectors of integers or floats.
 class Arith_ArithOp<string mnemonic, list<Trait> traits = []> :
     Arith_Op<mnemonic, traits # [SameOperandsAndResultType]>;
class Arith_CompareOpOfAnyRank<string mnemonic, list<Trait> traits = []> :
   let results = (outs BoolLikeOfAnyRank:$result);
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 def Arith_ConstantOp : Op<Arith_Dialect, "constant",
-    [ConstantLike, NoSideEffect,
+    [ConstantLike, Pure,
      DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
      AllTypesMatch<["value", "result"]>,
      DeclareOpInterfaceMethods<InferIntRangeInterface>]> {
   let summary = "integer or floating point constant";
   let description = [{
     The `constant` operation produces an SSA value equal to some integer or
     floating-point constant specified by an attribute. This is the way MLIR
     forms simple integer and floating point constants.

mlir/include/mlir/Dialect/ArmNeon/ArmNeon.td

 // ArmNeon dialect op that corresponds to an LLVM IR intrinsic with one
 // overloaded result and overloaded operands list.
 class ArmNeon_OverloadedOperandsWithOneResultIntrOp<string mnemonic,
                                                     list<int> overloadedOperands,
                                                     list<Trait> traits = []>
   : ArmNeon_IntrOp<mnemonic, [0], overloadedOperands, 1, traits>;
 
 def SMullOp : ArmNeon_OverloadedOneResultIntrOp<"smull", [
-       NoSideEffect,
+       Pure,
        AllTypesMatch<["a", "b"]>,
        TypesMatchWith<
          "res has same vector shape and element bitwidth scaled by 2 as a",
          "a", "res", "$_self.cast<VectorType>().scaleElementBitwidth(2)">
     ]> {
   let summary = "smull roundscale op";
   let description = [{
     Signed Multiply Long (vector). This instruction multiplies corresponding
def SMullOp : ArmNeon_OverloadedOneResultIntrOp<"smull", [
   let arguments = (ins VectorOfLengthAndType<[8, 4, 2], [I8, I16, I32]>:$a,
                        VectorOfLengthAndType<[8, 4, 2], [I8, I16, I32]>:$b);
   let results = (outs VectorOfLengthAndType<[8, 4, 2], [I16, I32, I64]>:$res);
   let assemblyFormat =
     "$a `,` $b attr-dict `:` type($a) `to` type($res)";
 }
 
 def SdotOp : ArmNeon_OverloadedOperandsWithOneResultIntrOp<"sdot",[1], [
-      NoSideEffect,
+      Pure,
       AllTypesMatch<["b", "c"]>,
       AllTypesMatch<["a", "res"]>,
       TypesMatchWith<"res has the same number of elements as operand b",
                      "b", "res",
                      "VectorType::get({$_self.cast<VectorType>().getShape()[0] / 4},"
                      "IntegerType::get($_self.getContext(), 32))">]> {
   let summary = "sdot op";
   let description = [{
def SdotOp : ArmNeon_OverloadedOperandsWithOneResultIntrOp<"sdot",[1], [
   }
 
 class ArmNeon_2dOp<string mnemonic, list<Trait> traits = []>
     : Op</*dialect=*/ArmNeon_Dialect,
          /*opName=*/"2d." # mnemonic,
          /*traits=*/traits>;
 
 def Sdot2dOp : ArmNeon_2dOp<"sdot", [
-      NoSideEffect,
+      Pure,
       AllTypesMatch<["b", "c"]>,
       AllTypesMatch<["a", "res"]>,
       PredOpTrait<
         "operand `a` should be 1-dimensional",
         CPred<"getA().getType().cast<VectorType>().getShape().size() == 1">
       >,
       PredOpTrait<
         "operand `b` should be 2-dimensional",

mlir/include/mlir/Dialect/ArmSVE/ArmSVE.td

let arguments = (ins
           ScalableVectorOf<[I8, I16, I32, I64]>:$src2
   );
   let results = (outs ScalableVectorOf<[I8, I16, I32, I64]>:$res);
   let assemblyFormat =
     "$mask `,` $src1 `,` $src2 attr-dict `:` type($mask) `,` type($res)";
 }
 
 def SdotOp : ArmSVE_Op<"sdot",
-               [NoSideEffect,
+               [Pure,
                AllTypesMatch<["src1", "src2"]>,
                AllTypesMatch<["acc", "dst"]>,
              ]> {
   let summary = "Vector-vector dot product and accumulate op";
   let description = [{
     SDOT: Signed integer addition of dot product.
 
     This function maps to the SDOT instruction, and it takes signless integer
let arguments = (ins
           ScalableVectorOfLengthAndType<[16, 8], [I8, I16]>:$src2
   );
   let results = (outs ScalableVectorOfLengthAndType<[4, 2], [I32, I64]>:$dst);
   let assemblyFormat =
     "$acc `,` $src1 `,` $src2 attr-dict `:` type($src1) `to` type($dst)";
 }
 
 def SmmlaOp : ArmSVE_Op<"smmla",
-                [NoSideEffect,
+                [Pure,
                 AllTypesMatch<["src1", "src2"]>,
                 AllTypesMatch<["acc", "dst"]>,
               ]> {
   let summary = "Matrix-matrix multiply and accumulate op";
   let description = [{
     SMMLA: Signed integer matrix multiply-accumulate.
 
     This function maps to the SMMLA instruction, and it takes signless integer
let arguments = (ins
           ScalableVectorOfLengthAndType<[16], [I8]>:$src2
   );
   let results = (outs ScalableVectorOfLengthAndType<[4], [I32]>:$dst);
   let assemblyFormat =
     "$acc `,` $src1 `,` $src2 attr-dict `:` type($src1) `to` type($dst)";
 }
 
 def UdotOp : ArmSVE_Op<"udot",
-               [NoSideEffect,
+               [Pure,
                AllTypesMatch<["src1", "src2"]>,
                AllTypesMatch<["acc", "dst"]>,
              ]> {
   let summary = "Vector-vector dot product and accumulate op";
   let description = [{
     UDOT: Unsigned integer addition of dot product.
 
     This function maps to the UDOT instruction, and it takes signless integer
let arguments = (ins
           ScalableVectorOfLengthAndType<[16, 8], [I8, I16]>:$src2
   );
   let results = (outs ScalableVectorOfLengthAndType<[4, 2], [I32, I64]>:$dst);
   let assemblyFormat =
     "$acc `,` $src1 `,` $src2 attr-dict `:` type($src1) `to` type($dst)";
 }
 
 def UmmlaOp : ArmSVE_Op<"ummla",
-                [NoSideEffect,
+                [Pure,
                 AllTypesMatch<["src1", "src2"]>,
                 AllTypesMatch<["acc", "dst"]>,
               ]> {
   let summary = "Matrix-matrix multiply and accumulate op";
   let description = [{
     UMMLA: Unsigned integer matrix multiply-accumulate.
 
     This function maps to the UMMLA instruction, and it takes signless integer

mlir/include/mlir/Dialect/Async/IR/AsyncOps.td

let extraClassDeclaration = [{
     using BodyBuilderFn =
         function_ref<void(OpBuilder &, Location, ValueRange)>;
 
   }];
 }
 
 def Async_YieldOp :
     Async_Op<"yield", [
-      HasParent<"ExecuteOp">, NoSideEffect, Terminator,
+      HasParent<"ExecuteOp">, Pure, Terminator,
       DeclareOpInterfaceMethods<RegionBranchTerminatorOpInterface>]> {
   let summary = "terminator for Async execute operation";
   let description = [{
     The `async.yield` is a special terminator operation for the block inside
     `async.execute` operation.
   }];
 
   let arguments = (ins Variadic<AnyType>:$operands);
def Async_AwaitOp : Async_Op<"await"> {
 
   let assemblyFormat = [{
     $operand `:` custom<AwaitResultType>(
       type($operand), type($result)
     ) attr-dict
   }];
 }
 
-def Async_CreateGroupOp : Async_Op<"create_group", [NoSideEffect]> {
+def Async_CreateGroupOp : Async_Op<"create_group", [Pure]> {
   let summary = "creates an empty async group";
   let description = [{
     The `async.create_group` allocates an empty async group. Async tokens or
     values can be added to this group later. The size of the group must be
     specified at construction time, and `await_all` operation will first
     wait until the number of added tokens or values reaches the group size.
 
     Example:

mlir/include/mlir/Dialect/Bufferization/IR/BufferizationOps.td

 //===----------------------------------------------------------------------===//
 // ToMemrefOp
 //===----------------------------------------------------------------------===//
 
 def Bufferization_ToMemrefOp : Bufferization_Op<"to_memref", [
     BufferizableOpInterface,
     SameOperandsAndResultShape,
     SameOperandsAndResultElementType,
-    NoSideEffect,
+    Pure,
     TypesMatchWith<"type of 'tensor' is the tensor equivalent of 'memref'",
                    "memref", "tensor",
                    "memref::getTensorTypeFromMemRefType($_self)">
   ]> {
   let summary = "tensor to memref cast operation";
   let description = [{
     Casts a tensor to a memref.
 

mlir/include/mlir/Dialect/Complex/IR/ComplexOps.td

 
 class Complex_Op<string mnemonic, list<Trait> traits = []>
     : Op<Complex_Dialect, mnemonic, traits>;
 
 // Base class for standard arithmetic operations on complex numbers with a
 // floating-point element type. These operations take two operands and return
 // one result, all of which must be complex numbers of the same type.
 class ComplexArithmeticOp<string mnemonic, list<Trait> traits = []> :
-    Complex_Op<mnemonic, traits # [NoSideEffect, SameOperandsAndResultType,
+    Complex_Op<mnemonic, traits # [Pure, SameOperandsAndResultType,
     Elementwise]> {
   let arguments = (ins Complex<AnyFloat>:$lhs, Complex<AnyFloat>:$rhs);
   let results = (outs Complex<AnyFloat>:$result);
   let assemblyFormat = "$lhs `,` $rhs  attr-dict `:` type($result)";
 }
 
 // Base class for standard unary operations on complex numbers with a
 // floating-point element type. These operations take one operand and return
 // one result; the operand must be a complex number.
 class ComplexUnaryOp<string mnemonic, list<Trait> traits = []> :
-    Complex_Op<mnemonic, traits # [NoSideEffect, Elementwise]> {
+    Complex_Op<mnemonic, traits # [Pure, Elementwise]> {
   let arguments = (ins Complex<AnyFloat>:$complex);
   let assemblyFormat = "$complex attr-dict `:` type($complex)";
 }
 
 //===----------------------------------------------------------------------===//
 // AbsOp
 //===----------------------------------------------------------------------===//
 
def Atan2Op : ComplexArithmeticOp<"atan2"> {
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 def ConstantOp : Complex_Op<"constant", [
-    ConstantLike, NoSideEffect,
+    ConstantLike, Pure,
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>
   ]> {
   let summary = "complex number constant operation";
   let description = [{
     The `complex.constant` operation creates a constant complex number from an
     attribute containing the real and imaginary parts.
 
     Example:
def CosOp : ComplexUnaryOp<"cos", [SameOperandsAndResultType]> {
   let results = (outs Complex<AnyFloat>:$result);
 }
 
 //===----------------------------------------------------------------------===//
 // CreateOp
 //===----------------------------------------------------------------------===//
 
 def CreateOp : Complex_Op<"create",
-    [NoSideEffect,
+    [Pure,
      AllTypesMatch<["real", "imaginary"]>,
      TypesMatchWith<"complex element type matches real operand type",
                     "complex", "real",
                     "$_self.cast<ComplexType>().getElementType()">,
      TypesMatchWith<"complex element type matches imaginary operand type",
                     "complex", "imaginary",
                     "$_self.cast<ComplexType>().getElementType()">]> {
 
def DivOp : ComplexArithmeticOp<"div"> {
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // EqualOp
 //===----------------------------------------------------------------------===//
 
 def EqualOp : Complex_Op<"eq",
-    [NoSideEffect, AllTypesMatch<["lhs", "rhs"]>, Elementwise]> {
+    [Pure, AllTypesMatch<["lhs", "rhs"]>, Elementwise]> {
   let summary = "computes whether two complex values are equal";
   let description = [{
     The `eq` op takes two complex numbers and returns whether they are equal.
 
     Example:
 
     ```mlir
     %a = complex.eq %b, %c : complex<f32>
def NegOp : ComplexUnaryOp<"neg", [SameOperandsAndResultType]> {
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // NotEqualOp
 //===----------------------------------------------------------------------===//
 
 def NotEqualOp : Complex_Op<"neq",
-    [NoSideEffect, AllTypesMatch<["lhs", "rhs"]>, Elementwise]> {
+    [Pure, AllTypesMatch<["lhs", "rhs"]>, Elementwise]> {
   let summary = "computes whether two complex values are not equal";
   let description = [{
     The `neq` op takes two complex numbers and returns whether they are not
     equal.
 
     Example:
 
     ```mlir

mlir/include/mlir/Dialect/ControlFlow/IR/ControlFlowOps.td

 }
 
 //===----------------------------------------------------------------------===//
 // BranchOp
 //===----------------------------------------------------------------------===//
 
 def BranchOp : CF_Op<"br", [
     DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>,
-    NoSideEffect, Terminator
+    Pure, Terminator
   ]> {
   let summary = "branch operation";
   let description = [{
     The `cf.br` operation represents a direct branch operation to a given
     block. The operands of this operation are forwarded to the successor block,
     and the number and type of the operands must match the arguments of the
     target block.
 

 
 //===----------------------------------------------------------------------===//
 // CondBranchOp
 //===----------------------------------------------------------------------===//
 
 def CondBranchOp : CF_Op<"cond_br",
     [AttrSizedOperandSegments,
      DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>,
-     NoSideEffect, Terminator]> {
+     Pure, Terminator]> {
   let summary = "conditional branch operation";
   let description = [{
     The `cond_br` terminator operation represents a conditional branch on a
     boolean (1-bit integer) value. If the bit is set, then the first destination
     is jumped to; if it is false, the second destination is chosen. The count
     and types of operands must align with the arguments in the corresponding
     target blocks.
 

 
 //===----------------------------------------------------------------------===//
 // SwitchOp
 //===----------------------------------------------------------------------===//
 
 def SwitchOp : CF_Op<"switch",
     [AttrSizedOperandSegments,
      DeclareOpInterfaceMethods<BranchOpInterface, ["getSuccessorForOperands"]>,
-     NoSideEffect, Terminator]> {
+     Pure, Terminator]> {
   let summary = "switch operation";
   let description = [{
     The `switch` terminator operation represents a switch on a signless integer
     value. If the flag matches one of the specified cases, then the
     corresponding destination is jumped to. If the flag does not match any of
     the cases, the default destination is jumped to. The count and types of
     operands must align with the arguments in the corresponding target blocks.
 

mlir/include/mlir/Dialect/EmitC/IR/EmitC.td

def EmitC_ConstantOp : EmitC_Op<"constant", [ConstantLike]> {
   let results = (outs AnyType);
 
   let hasFolder = 1;
   // TODO: Disallow empty constants.
   let hasVerifier = 1;
 }
 
 def EmitC_IncludeOp
-    : EmitC_Op<"include", [NoSideEffect, HasParent<"ModuleOp">]> {
+    : EmitC_Op<"include", [Pure, HasParent<"ModuleOp">]> {
   let summary = "Include operation";
   let description = [{
     The `include` operation allows to define a source file inclusion via the
     `#include` directive.
 
     Example:
 
     ```mlir

mlir/include/mlir/Dialect/Func/IR/FuncOps.td

def CallIndirectOp : Func_Op<"call_indirect", [
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 def ConstantOp : Func_Op<"constant",
-    [ConstantLike, NoSideEffect,
+    [ConstantLike, Pure,
      DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]> {
   let summary = "constant";
   let description = [{
     The `func.constant` operation produces an SSA value from a symbol reference
     to a `func.func` operation
 
     Example:
 
]> {
   }];
   let hasCustomAssemblyFormat = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ReturnOp
 //===----------------------------------------------------------------------===//
 
-def ReturnOp : Func_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
+def ReturnOp : Func_Op<"return", [Pure, HasParent<"FuncOp">,
                                 MemRefsNormalizable, ReturnLike, Terminator]> {
   let summary = "Function return operation";
   let description = [{
     The `func.return` operation represents a return operation within a function.
     The operation takes variable number of operands and produces no results.
     The operand number and types must match the signature of the function
     that contains the operation.
 

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

def GPU_Dimension : I32EnumAttr<"Dimension",
     ]>{
   let genSpecializedAttr = 0;
   let cppNamespace = "::mlir::gpu";
 }
 def GPU_DimensionAttr : EnumAttr<GPU_Dialect, GPU_Dimension, "dim">;
 
 class GPU_IndexOp<string mnemonic, list<Trait> traits = []> :
     GPU_Op<mnemonic, !listconcat(traits, [
-        NoSideEffect, DeclareOpInterfaceMethods<InferIntRangeInterface>])>,
+        Pure, DeclareOpInterfaceMethods<InferIntRangeInterface>])>,
     Arguments<(ins GPU_DimensionAttr:$dimension)>, Results<(outs Index)> {
   let assemblyFormat = "$dimension attr-dict";
 }
 
 def GPU_BlockDimOp : GPU_IndexOp<"block_dim"> {
   let description = [{
     Returns the number of threads in the thread block (aka the block size) along
     the x, y, or z `dimension`.
let description = [{
 
     ```mlir
     %tIdX = gpu.thread_id x
     ```
   }];
 }
 
 def GPU_LaneIdOp : GPU_Op<"lane_id", [
-      NoSideEffect, DeclareOpInterfaceMethods<InferIntRangeInterface>]> {
+      Pure, DeclareOpInterfaceMethods<InferIntRangeInterface>]> {
   let description = [{
     Returns the lane id within the subgroup (warp/wave).
 
     Example:
     ```mlir
     %laneId = gpu.lane_id
     ```
   }];
   let results = (outs Index:$result);
   let assemblyFormat = "attr-dict";
 }
 
 def GPU_SubgroupIdOp : GPU_Op<"subgroup_id", [
-      NoSideEffect, DeclareOpInterfaceMethods<InferIntRangeInterface>]>,
+      Pure, DeclareOpInterfaceMethods<InferIntRangeInterface>]>,
     Arguments<(ins)>, Results<(outs Index:$result)> {
   let description = [{
     Returns the subgroup id, i.e. the index of the current subgroup within the
     workgroup.
 
     Example:
 
     ```mlir
let description = [{
     ```mlir
     %gidX = gpu.global_id x
     ```
   }];
 }
 
 
 def GPU_NumSubgroupsOp : GPU_Op<"num_subgroups", [
-      NoSideEffect, DeclareOpInterfaceMethods<InferIntRangeInterface>]>,
+      Pure, DeclareOpInterfaceMethods<InferIntRangeInterface>]>,
     Arguments<(ins)>, Results<(outs Index:$result)> {
   let description = [{
     Returns the number of subgroups within a workgroup.
 
     Example:
 
     ```mlir
     %numSg = gpu.num_subgroups : index
     ```
   }];
 
   let assemblyFormat = "attr-dict `:` type($result)";
 }
 
 def GPU_SubgroupSizeOp : GPU_Op<"subgroup_size", [
-      NoSideEffect, DeclareOpInterfaceMethods<InferIntRangeInterface>]>,
+      Pure, DeclareOpInterfaceMethods<InferIntRangeInterface>]>,
     Arguments<(ins)>, Results<(outs Index:$result)> {
   let description = [{
     Returns the number of threads within a subgroup.
 
     Example:
 
     ```mlir
     %sgSz = gpu.subgroup_size : index
let description = [{
     The format string is a C-style printf string, subject to any restrictions
     imposed by one's target platform.
   }];
   let assemblyFormat = [{
     $format attr-dict ($args^ `:` type($args))?
   }];
 }
 
-def GPU_ReturnOp : GPU_Op<"return", [HasParent<"GPUFuncOp">, NoSideEffect,
+def GPU_ReturnOp : GPU_Op<"return", [HasParent<"GPUFuncOp">, Pure,
                                      Terminator]>,
     Arguments<(ins Variadic<AnyType>:$operands)>, Results<(outs)> {
   let summary = "Terminator for GPU functions.";
   let description = [{
     A terminator operation for regions that appear in the body of  `gpu.func`
     functions. The operands to the `gpu.return` are the result values returned
     by an invocation of the `gpu.func`.
   }];
 
   let builders = [OpBuilder<(ins), [{ // empty}]>];
 
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
   let hasVerifier = 1;
 }
 
 def GPU_TerminatorOp : GPU_Op<"terminator", [HasParent<"LaunchOp">,
-                                             NoSideEffect, Terminator]>,
+                                             Pure, Terminator]>,
     Arguments<(ins)>, Results<(outs)> {
   let summary = "Terminator for GPU launch regions.";
   let description = [{
     A terminator operation for regions that appear in the body of `gpu.launch`
     operation.  These regions are not expected to return any value so the
     terminator takes no operands.
   }];
 
   let assemblyFormat = "attr-dict";
 }
 
-def GPU_YieldOp : GPU_Op<"yield", [NoSideEffect, Terminator]>,
+def GPU_YieldOp : GPU_Op<"yield", [Pure, Terminator]>,
     Arguments<(ins Variadic<AnyType>:$values)> {
   let summary = "GPU yield operation";
   let description = [{
     gpu.yield` is a special terminator operation for blocks inside regions
     in gpu ops. It returns values to the immediately enclosing gpu op.
 
     Example:
 

 }
 def GPU_ShuffleModeAttr : EnumAttr<GPU_Dialect, GPU_ShuffleMode,
                                    "shuffle_mode">;
 
 def I32OrF32 : TypeConstraint<Or<[I32.predicate, F32.predicate]>,
                                  "i32 or f32">;
 
 def GPU_ShuffleOp : GPU_Op<
-    "shuffle", [NoSideEffect, AllTypesMatch<["value", "shuffleResult"]>]>,
+    "shuffle", [Pure, AllTypesMatch<["value", "shuffleResult"]>]>,
     Arguments<(ins I32OrF32:$value, I32:$offset, I32:$width,
                GPU_ShuffleModeAttr:$mode)>,
     Results<(outs I32OrF32:$shuffleResult, I1:$valid)> {
   let summary = "Shuffles values within a subgroup.";
   let description = [{
     The "shuffle" op moves values to a different invocation within the same
     subgroup.
 
def GPU_SubgroupMmaStoreMatrixOp : GPU_Op<"subgroup_mma_store_matrix",
 
   let assemblyFormat = [{
     $src`,` $dstMemref`[`$indices`]` attr-dict `:` type($src)`,` type($dstMemref)
   }];
   let hasVerifier = 1;
 }
 
 def GPU_SubgroupMmaComputeOp : GPU_Op<"subgroup_mma_compute",
-   [NoSideEffect, AllTypesMatch<["opC", "res"]>]>{
+   [Pure, AllTypesMatch<["opC", "res"]>]>{
 
   let summary = "GPU warp synchronous matrix multiply accumulate";
 
   let description = [{
     The `gpu.subgroup_mma_compute` operation performs a matrix-multiply accumulate (mma)
     operation using all the threads in a subgroup.
 
     This operation takes three `!gpu.mma_matrix`s as arguments: these hold `A`,
def GPU_SubgroupMmaComputeOp : GPU_Op<"subgroup_mma_compute",
 
   let assemblyFormat = [{
     $opA`,` $opB`,` $opC attr-dict `:` type($opA)`,` type($opB) `->` type($res)
   }];
   let hasVerifier = 1;
 }
 
 def GPU_SubgroupMmaConstantMatrixOp : GPU_Op<"subgroup_mma_constant_matrix",
-    [NoSideEffect,
+    [Pure,
      TypesMatchWith<"value type matches element type of mma_matrix",
                     "res", "value",
                     "$_self.cast<gpu::MMAMatrixType>().getElementType()">]>{
 
   let summary = "GPU warp synchronous constant matrix";
 
   let description = [{
     The `gpu.subgroup_mma_constant_matrix` creates a `!gpu.mma_matrix` with
def MMAElementWise : I32EnumAttr<"MMAElementwiseOp",
   ]> {
   let genSpecializedAttr = 0;
   let cppNamespace = "::mlir::gpu";
 }
 def MMAElementWiseAttr : EnumAttr<GPU_Dialect, MMAElementWise,
                                   "mma_element_wise">;
 
 def GPU_SubgroupMmaElementwiseOp : GPU_Op<"subgroup_mma_elementwise",
-    [NoSideEffect,
+    [Pure,
      AllTypesMatch<["args"]>]>{
 
   let summary = "GPU warp elementwise operation on a matrix";
 
   let description = [{
     The `gpu.subgroup_mma_elementwise` takes `!gpu.mma_matrix` inputs and
     compute a new `!gpu.mma_matrix` by applying an elementwise operation to each
     element.

mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td

 #ifndef LLVM_INTRINSIC_OPS
 #define LLVM_INTRINSIC_OPS
 
 include "mlir/IR/OpBase.td"
 include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 
 // Operations that correspond to LLVM intrinsics. With MLIR operation set being
 // extendable, there is no reason to introduce a hard boundary between "core"
 // operations and intrinsics. However, we systematically prefix them with
 // "intr." to avoid potential name clashes.
 
 class LLVM_UnaryIntrinsicOp<string func, list<Trait> traits = []> :
     LLVM_OneResultIntrOp<func, [], [0],
-           !listconcat([NoSideEffect, SameOperandsAndResultType], traits)> {
+           !listconcat([Pure, SameOperandsAndResultType], traits)> {
   let arguments = (ins LLVM_Type:$in);
 }
 
 class LLVM_BinarySameArgsIntrinsicOp<string func, list<Trait> traits = []> :
     LLVM_OneResultIntrOp<func, [], [0],
-           !listconcat([NoSideEffect, SameOperandsAndResultType], traits)> {
+           !listconcat([Pure, SameOperandsAndResultType], traits)> {
   let arguments = (ins LLVM_Type:$a, LLVM_Type:$b);
 }
 
 class LLVM_BinaryIntrinsicOp<string func, list<Trait> traits = []> :
     LLVM_OneResultIntrOp<func, [], [0,1],
-           !listconcat([NoSideEffect], traits)> {
+           !listconcat([Pure], traits)> {
   let arguments = (ins LLVM_Type:$a, LLVM_Type:$b);
 }
 
 class LLVM_TernarySameArgsIntrinsicOp<string func, list<Trait> traits = []> :
     LLVM_OneResultIntrOp<func, [], [0],
-           !listconcat([NoSideEffect, SameOperandsAndResultType], traits)> {
+           !listconcat([Pure, SameOperandsAndResultType], traits)> {
   let arguments = (ins LLVM_Type:$a, LLVM_Type:$b, LLVM_Type:$c);
 }
 
 class LLVM_CountZerosIntrinsicOp<string func, list<Trait> traits = []> :
     LLVM_OneResultIntrOp<func, [], [0],
-           !listconcat([NoSideEffect], traits)> {
+           !listconcat([Pure], traits)> {
   let arguments = (ins LLVM_Type:$in, I1:$zero_undefined);
 }
 
-def LLVM_AbsOp : LLVM_OneResultIntrOp<"abs", [], [0], [NoSideEffect]> {
+def LLVM_AbsOp : LLVM_OneResultIntrOp<"abs", [], [0], [Pure]> {
   let arguments = (ins LLVM_Type:$in, I1:$is_int_min_poison);
 }
 
 def LLVM_CopySignOp : LLVM_BinarySameArgsIntrinsicOp<"copysign">;
 def LLVM_CosOp : LLVM_UnaryIntrinsicOp<"cos">;
 def LLVM_ExpOp : LLVM_UnaryIntrinsicOp<"exp">;
 def LLVM_Exp2Op : LLVM_UnaryIntrinsicOp<"exp2">;
 def LLVM_FAbsOp : LLVM_UnaryIntrinsicOp<"fabs">;

 }
 
 //
 // LLVM masked operations.
 //
 
 /// Create a llvm.get.active.lane.mask to set a mask up to a given position.
 def LLVM_GetActiveLaneMaskOp
-    : LLVM_OneResultIntrOp<"get.active.lane.mask", [0], [0], [NoSideEffect]> {
+    : LLVM_OneResultIntrOp<"get.active.lane.mask", [0], [0], [Pure]> {
   let arguments = (ins LLVM_Type:$base, LLVM_Type:$n);
   let assemblyFormat = "$base `,` $n attr-dict `:` "
     "type($base) `,` type($n) `to` type($res)";
 }
 
 /// Create a call to Masked Load intrinsic.
 def LLVM_MaskedLoadOp : LLVM_Op<"intr.masked.load"> {
   let arguments = (ins LLVM_Type:$data, LLVM_Type:$mask,
def LLVM_masked_compressstore
   let arguments = (ins LLVM_Type, LLVM_Type, LLVM_Type);
 }
 
 /// Create a call to vscale intrinsic.
 def LLVM_vscale : LLVM_IntrOp<"vscale", [0], [], [], 1>;
 
 /// Create a call to stepvector intrinsic.
 def LLVM_StepVectorOp
-    : LLVM_IntrOp<"experimental.stepvector", [0], [], [NoSideEffect], 1> {
+    : LLVM_IntrOp<"experimental.stepvector", [0], [], [Pure], 1> {
   let arguments = (ins);
   let results = (outs LLVM_Type:$res);
   let assemblyFormat = "attr-dict `:` type($res)";
 }
 
 /// Create a call to vector.insert intrinsic
 def LLVM_vector_insert
     : LLVM_Op<"intr.vector.insert",
-                 [NoSideEffect, AllTypesMatch<["dstvec", "res"]>,
+                 [Pure, AllTypesMatch<["dstvec", "res"]>,
                   PredOpTrait<"vectors are not bigger than 2^17 bits.", And<[
                     CPred<"getSrcVectorBitWidth() <= 131072">,
                     CPred<"getDstVectorBitWidth() <= 131072">
                   ]>>,
                   PredOpTrait<"it is not inserting scalable into fixed-length vectors.",
                     CPred<"!isScalableVectorType($srcvec.getType()) || "
                           "isScalableVectorType($dstvec.getType())">>]> {
   let arguments = (ins LLVM_AnyVector:$srcvec, LLVM_AnyVector:$dstvec,
uint64_t getDstVectorBitWidth() {
       return getVectorBitWidth(getDstvec().getType());
     }
   }];
 }
 
 /// Create a call to vector.extract intrinsic
 def LLVM_vector_extract
     : LLVM_Op<"intr.vector.extract",
-                 [NoSideEffect,
+                 [Pure,
                   PredOpTrait<"vectors are not bigger than 2^17 bits.", And<[
                     CPred<"getSrcVectorBitWidth() <= 131072">,
                     CPred<"getResVectorBitWidth() <= 131072">
                   ]>>,
                   PredOpTrait<"it is not extracting scalable from fixed-length vectors.",
                     CPred<"!isScalableVectorType($res.getType()) || "
                           "isScalableVectorType($srcvec.getType())">>]> {
   let arguments = (ins LLVM_AnyVector:$srcvec, I64Attr:$pos);
def LLVM_vector_extract
   }];
 }
 
 //
 // LLVM Vector Predication operations.
 //
 
 class LLVM_VPBinaryBase<string mnem, Type element>
-    : LLVM_OneResultIntrOp<"vp." # mnem, [0], [], [NoSideEffect]>,
+    : LLVM_OneResultIntrOp<"vp." # mnem, [0], [], [Pure]>,
       Arguments<(ins LLVM_VectorOf<element>:$lhs, LLVM_VectorOf<element>:$rhs,
                      LLVM_VectorOf<I1>:$mask, I32:$evl)>;
 
 class LLVM_VPBinaryI<string mnem> : LLVM_VPBinaryBase<mnem, AnyInteger>;
 
 class LLVM_VPBinaryF<string mnem> : LLVM_VPBinaryBase<mnem, AnyFloat>;
 
 class LLVM_VPUnaryBase<string mnem, Type element>
-    : LLVM_OneResultIntrOp<"vp." # mnem, [0], [], [NoSideEffect]>,
+    : LLVM_OneResultIntrOp<"vp." # mnem, [0], [], [Pure]>,
       Arguments<(ins LLVM_VectorOf<element>:$op,
                      LLVM_VectorOf<I1>:$mask, I32:$evl)>;
 
 class LLVM_VPUnaryF<string mnem> : LLVM_VPUnaryBase<mnem, AnyFloat>;
 
 class LLVM_VPTernaryBase<string mnem, Type element>
-    : LLVM_OneResultIntrOp<"vp." # mnem, [0], [], [NoSideEffect]>,
+    : LLVM_OneResultIntrOp<"vp." # mnem, [0], [], [Pure]>,
       Arguments<(ins LLVM_VectorOf<element>:$op1, LLVM_VectorOf<element>:$op2,
                      LLVM_VectorOf<element>:$op3, LLVM_VectorOf<I1>:$mask,
                      I32:$evl)>;
 
 class LLVM_VPTernaryF<string mnem> : LLVM_VPTernaryBase<mnem, AnyFloat>;
 
 class LLVM_VPReductionBase<string mnem, Type element>
-    : LLVM_OneResultIntrOp<"vp.reduce." # mnem, [], [1], [NoSideEffect]>,
+    : LLVM_OneResultIntrOp<"vp.reduce." # mnem, [], [1], [Pure]>,
       Arguments<(ins element:$satrt_value, LLVM_VectorOf<element>:$val,
                      LLVM_VectorOf<I1>:$mask, I32:$evl)>;
 
 class LLVM_VPReductionI<string mnem> : LLVM_VPReductionBase<mnem, AnyInteger>;
 
 class LLVM_VPReductionF<string mnem> : LLVM_VPReductionBase<mnem, AnyFloat>;
 
 class LLVM_VPSelectBase<string mnem>
-    : LLVM_OneResultIntrOp<"vp." # mnem, [], [1], [NoSideEffect]>,
+    : LLVM_OneResultIntrOp<"vp." # mnem, [], [1], [Pure]>,
       Arguments<(ins LLVM_VectorOf<I1>:$cond, LLVM_AnyVector:$true_val,
                      LLVM_AnyVector:$false_val, I32:$evl)>;
 
 class LLVM_VPCastBase<string mnem, Type element>
-    : LLVM_OneResultIntrOp<"vp." # mnem, [0], [0], [NoSideEffect]>,
+    : LLVM_OneResultIntrOp<"vp." # mnem, [0], [0], [Pure]>,
       Arguments<(ins LLVM_VectorOf<element>:$src,
                      LLVM_VectorOf<I1>:$mask, I32:$evl)>;
 
 class LLVM_VPCastI<string mnem>   : LLVM_VPCastBase<mnem, AnyInteger>;
 
 class LLVM_VPCastF<string mnem>   : LLVM_VPCastBase<mnem, AnyFloat>;
 
 class LLVM_VPCastPtr<string mnem> : LLVM_VPCastBase<mnem, LLVM_AnyPointer>;

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

: LLVM_IntrOpBase<LLVM_Dialect, "intr." # mnem, !subst(".", "_", mnem),
                       overloadedResults, overloadedOperands, traits,
                       numResults, requiresAccessGroup, requiresAliasScope>;
 
 // Base class for LLVM intrinsic operations returning no results. Places the
 // intrinsic into the LLVM dialect and prefixes its name with "intr.".
 //
 // Sample use: derive an entry from this class and populate the fields.
 //
-//    def LLVM_Name : LLVM_ZeroResultIntrOp<"name", [0], [NoSideEffect]>,
+//    def LLVM_Name : LLVM_ZeroResultIntrOp<"name", [0], [Pure]>,
 //                    Arguments<(ins LLVM_Type, LLVM_Type)>;
 //
 // The mnemonic will be prefixed with "llvm.intr.", where the "llvm." part comes
 // from the LLVM dialect. The overloadedOperands list contains the indices of
 // the operands the type of which will be passed in the LLVM IR intrinsic
 // builder. In the example above, the Op has two arguments, but only the first
 // one (as indicated by `[0]`) is necessary to resolve the overloaded intrinsic.
 // The Op has no results.

 class LLVM_OneResultIntrOp<string mnem, list<int> overloadedResults = [],
                            list<int> overloadedOperands = [],
                            list<Trait> traits = []>
     : LLVM_IntrOp<mnem, overloadedResults, overloadedOperands, traits, 1>;
 
 // LLVM vector reduction over a single vector.
 class LLVM_VectorReduction<string mnem>
     : LLVM_OneResultIntrOp<"vector.reduce." # mnem,
-                           [], [0], [NoSideEffect]>,
+                           [], [0], [Pure]>,
       Arguments<(ins LLVM_Type)>;
 
 // LLVM vector reduction over a single vector, with an initial value,
 // and with permission to reassociate the reduction operations.
 class LLVM_VectorReductionAcc<string mnem>
     : LLVM_OpBase<LLVM_Dialect, "intr.vector.reduce." # mnem,
-                  [NoSideEffect]>,
+                  [Pure]>,
       Results<(outs LLVM_Type:$res)>,
       Arguments<(ins LLVM_Type, LLVM_Type,
                  DefaultValuedAttr<BoolAttr, "false">:$reassoc)> {
   let llvmBuilder = [{
     llvm::Module *module = builder.GetInsertBlock()->getModule();
     llvm::Function *fn = llvm::Intrinsic::getDeclaration(
         module,
         llvm::Intrinsic::vector_reduce_}] # mnem # [{,

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

 // zero results and an optional list of successors.
 class LLVM_TerminatorOp<string mnemonic, list<Trait> traits = []> :
     LLVM_Op<mnemonic, !listconcat(traits, [Terminator])>;
 
 // Class for arithmetic binary operations.
 class LLVM_ArithmeticOpBase<Type type, string mnemonic,
                             string builderFunc, list<Trait> traits = []> :
     LLVM_Op<mnemonic,
-           !listconcat([NoSideEffect, SameOperandsAndResultType], traits)>,
+           !listconcat([Pure, SameOperandsAndResultType], traits)>,
     LLVM_Builder<"$res = builder." # builderFunc # "($lhs, $rhs);"> {
   dag commonArgs = (ins LLVM_ScalarOrVectorOf<type>:$lhs,
                     LLVM_ScalarOrVectorOf<type>:$rhs);
   let results = (outs LLVM_ScalarOrVectorOf<type>:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "$lhs `,` $rhs custom<LLVMOpAttrs>(attr-dict) `:` type($res)";
 }
 class LLVM_IntArithmeticOp<string mnemonic, string builderFunc,
                            list<Trait> traits = []> :
     LLVM_ArithmeticOpBase<AnyInteger, mnemonic, builderFunc, traits> {
   let arguments = commonArgs;
 }
 class LLVM_FloatArithmeticOp<string mnemonic, string builderFunc,
                              list<Trait> traits = []> :
     LLVM_ArithmeticOpBase<LLVM_AnyFloat, mnemonic, builderFunc,
     !listconcat([DeclareOpInterfaceMethods<FastmathFlagsInterface>], traits)> {
   dag fmfArg = (ins DefaultValuedAttr<LLVM_FMFAttr, "{}">:$fastmathFlags);
   let arguments = !con(commonArgs, fmfArg);
 }
 
 // Class for arithmetic unary operations.
 class LLVM_UnaryFloatArithmeticOp<Type type, string mnemonic,
                              string builderFunc, list<Trait> traits = []> :
     LLVM_Op<mnemonic,
-           !listconcat([NoSideEffect, SameOperandsAndResultType, DeclareOpInterfaceMethods<FastmathFlagsInterface>], traits)>,
+           !listconcat([Pure, SameOperandsAndResultType, DeclareOpInterfaceMethods<FastmathFlagsInterface>], traits)>,
     LLVM_Builder<"$res = builder." # builderFunc # "($operand);"> {
   let arguments = (ins type:$operand, DefaultValuedAttr<LLVM_FMFAttr, "{}">:$fastmathFlags);
   let results = (outs type:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "$operand custom<LLVMOpAttrs>(attr-dict) `:` type($res)";
 }
 
 // Integer binary operations.
def ICmpPredicate : I64EnumAttr<
     "llvm.icmp comparison predicate",
     [ICmpPredicateEQ, ICmpPredicateNE, ICmpPredicateSLT, ICmpPredicateSLE,
      ICmpPredicateSGT, ICmpPredicateSGE, ICmpPredicateULT, ICmpPredicateULE,
      ICmpPredicateUGT, ICmpPredicateUGE]> {
   let cppNamespace = "::mlir::LLVM";
 }
 
 // Other integer operations.
-def LLVM_ICmpOp : LLVM_Op<"icmp", [NoSideEffect]> {
+def LLVM_ICmpOp : LLVM_Op<"icmp", [Pure]> {
   let arguments = (ins ICmpPredicate:$predicate,
                    AnyTypeOf<[LLVM_ScalarOrVectorOf<AnyInteger>, LLVM_ScalarOrVectorOf<LLVM_AnyPointer>]>:$lhs,
                    AnyTypeOf<[LLVM_ScalarOrVectorOf<AnyInteger>, LLVM_ScalarOrVectorOf<LLVM_AnyPointer>]>:$rhs);
   let results = (outs LLVM_ScalarOrVectorOf<I1>:$res);
   let llvmBuilder = [{
     $res = builder.CreateICmp(getLLVMCmpPredicate($predicate), $lhs, $rhs);
   }];
   let builders = [
def FCmpPredicate : I64EnumAttr<
      FCmpPredicateUEQ, FCmpPredicateUGT, FCmpPredicateUGE, FCmpPredicateULT,
      FCmpPredicateULE, FCmpPredicateUNE, FCmpPredicateUNO, FCmpPredicateTRUE
     ]> {
   let cppNamespace = "::mlir::LLVM";
 }
 
 // Other floating-point operations.
 def LLVM_FCmpOp : LLVM_Op<"fcmp", [
-    NoSideEffect, DeclareOpInterfaceMethods<FastmathFlagsInterface>]> {
+    Pure, DeclareOpInterfaceMethods<FastmathFlagsInterface>]> {
   let arguments = (ins FCmpPredicate:$predicate,
                    LLVM_ScalarOrVectorOf<LLVM_AnyFloat>:$lhs,
                    LLVM_ScalarOrVectorOf<LLVM_AnyFloat>:$rhs,
                    DefaultValuedAttr<LLVM_FMFAttr, "{}">:$fastmathFlags);
   let results = (outs LLVM_ScalarOrVectorOf<I1>:$res);
   let llvmBuilder = [{
     $res = builder.CreateFCmp(getLLVMCmpPredicate($predicate), $lhs, $rhs);
   }];
[{
             elemTypeAttr);
 
     }]>
     ];
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
-def LLVM_GEPOp : LLVM_Op<"getelementptr", [NoSideEffect]> {
+def LLVM_GEPOp : LLVM_Op<"getelementptr", [Pure]> {
   let arguments = (ins LLVM_ScalarOrVectorOf<LLVM_AnyPointer>:$base,
                    Variadic<LLVM_ScalarOrVectorOf<AnyInteger>>:$dynamicIndices,
                    DenseI32ArrayAttr:$rawConstantIndices,
                    OptionalAttr<TypeAttr>:$elem_type);
   let results = (outs LLVM_ScalarOrVectorOf<LLVM_AnyPointer>:$res);
   let skipDefaultBuilders = 1;
 
   let description = [{
let builders = [
     ];
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
 // Casts.
 class LLVM_CastOp<string mnemonic, string builderFunc, Type type,
                   Type resultType, list<Trait> traits = []> :
-    LLVM_Op<mnemonic, !listconcat([NoSideEffect], traits)>,
+    LLVM_Op<mnemonic, !listconcat([Pure], traits)>,
     LLVM_Builder<"$res = builder." # builderFunc # "($arg, $_resultType);"> {
   let arguments = (ins type:$arg);
   let results = (outs resultType:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "$arg attr-dict `:` type($arg) `to` type($res)";
 }
 def LLVM_BitcastOp : LLVM_CastOp<"bitcast", "CreateBitCast",
                                  LLVM_AnyNonAggregate, LLVM_AnyNonAggregate> {
def LLVM_CallOp : LLVM_Op<"call",
 
   let hasCustomAssemblyFormat = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ExtractElementOp
 //===----------------------------------------------------------------------===//
 
-def LLVM_ExtractElementOp : LLVM_Op<"extractelement", [NoSideEffect,
+def LLVM_ExtractElementOp : LLVM_Op<"extractelement", [Pure,
     TypesMatchWith<"result type matches vector element type", "vector", "res",
                    "LLVM::getVectorElementType($_self)">]> {
   let summary = "Extract an element from an LLVM vector.";
 
   let arguments = (ins LLVM_AnyVector:$vector, AnyInteger:$position);
   let results = (outs LLVM_Type:$res);
 
   let builders = [
string llvmBuilder = [{
     $res = builder.CreateExtractElement($vector, $position);
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // ExtractValueOp
 //===----------------------------------------------------------------------===//
 
-def LLVM_ExtractValueOp : LLVM_Op<"extractvalue", [NoSideEffect]> {
+def LLVM_ExtractValueOp : LLVM_Op<"extractvalue", [Pure]> {
   let summary = "Extract a value from an LLVM struct.";
 
   let arguments = (ins LLVM_AnyAggregate:$container, DenseI64ArrayAttr:$position);
   let results = (outs LLVM_Type:$res);
 
   let builders = [
     OpBuilder<(ins "Value":$container, "ArrayRef<int64_t>":$position)>
   ];
string llvmBuilder = [{
     $res = builder.CreateExtractValue($container, extractPosition($position));
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // InsertElementOp
 //===----------------------------------------------------------------------===//
 
-def LLVM_InsertElementOp : LLVM_Op<"insertelement", [NoSideEffect,
+def LLVM_InsertElementOp : LLVM_Op<"insertelement", [Pure,
     TypesMatchWith<"argument type matches vector element type", "vector",
                    "value", "LLVM::getVectorElementType($_self)">,
     AllTypesMatch<["res", "vector"]>]> {
   let summary = "Insert an element into an LLVM vector.";
 
   let arguments = (ins LLVM_AnyVector:$vector, LLVM_PrimitiveType:$value,
                        AnyInteger:$position);
   let results = (outs LLVM_AnyVector:$res);
def LLVM_InsertElementOp : LLVM_Op<"insertelement", [Pure,
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // InsertValueOp
 //===----------------------------------------------------------------------===//
 
 def LLVM_InsertValueOp : LLVM_Op<
-    "insertvalue", [NoSideEffect, AllTypesMatch<["container", "res"]>]> {
+    "insertvalue", [Pure, AllTypesMatch<["container", "res"]>]> {
   let summary = "Insert a value into an LLVM struct.";
 
   let arguments = (ins LLVM_AnyAggregate:$container, LLVM_PrimitiveType:$value,
                        DenseI64ArrayAttr:$position);
   let results = (outs LLVM_AnyAggregate:$res);
 
   let assemblyFormat = [{
     $value `,` $container `` $position attr-dict `:` type($container)
def LLVM_InsertValueOp : LLVM_Op<
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // ShuffleVectorOp
 //===----------------------------------------------------------------------===//
 
 def LLVM_ShuffleVectorOp : LLVM_Op<"shufflevector",
-    [NoSideEffect, AllTypesMatch<["v1", "v2"]>]> {
+    [Pure, AllTypesMatch<["v1", "v2"]>]> {
   let summary = "Construct a permutation of two vectors.";
 
   let arguments = (ins LLVM_AnyVector:$v1, LLVM_AnyVector:$v2,
                        DenseI32ArrayAttr:$mask);
   let results = (outs LLVM_AnyVector:$res);
 
   let builders = [
     OpBuilder<(ins "Value":$v1, "Value":$v2, "DenseI32ArrayAttr":$mask,
def LLVM_ShuffleVectorOp : LLVM_Op<"shufflevector",
   string llvmBuilder = [{
     $res = builder.CreateShuffleVector($v1, $v2, $mask);
   }];
 }
 
 // Misc operations.
 def LLVM_SelectOp
     : LLVM_Op<"select",
-          [NoSideEffect, AllTypesMatch<["trueValue", "falseValue", "res"]>]>,
+          [Pure, AllTypesMatch<["trueValue", "falseValue", "res"]>]>,
       LLVM_Builder<
           "$res = builder.CreateSelect($condition, $trueValue, $falseValue);"> {
   let arguments = (ins LLVM_ScalarOrVectorOf<I1>:$condition,
                    LLVM_Type:$trueValue, LLVM_Type:$falseValue);
   let results = (outs LLVM_Type:$res);
   let assemblyFormat = "operands attr-dict `:` type($condition) `,` type($res)";
 }
 def LLVM_FreezeOp : LLVM_Op<"freeze", [SameOperandsAndResultType]> {
   let arguments = (ins LLVM_Type:$val);
   let results = (outs LLVM_Type:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "$val attr-dict `:` type($val)";
   string llvmBuilder = "builder.CreateFreeze($val);";
 }
 
 // Terminators.
 def LLVM_BrOp : LLVM_TerminatorOp<"br",
-    [DeclareOpInterfaceMethods<BranchOpInterface>, NoSideEffect]> {
+    [DeclareOpInterfaceMethods<BranchOpInterface>, Pure]> {
   let arguments = (ins Variadic<LLVM_Type>:$destOperands);
   let successors = (successor AnySuccessor:$dest);
   let assemblyFormat = [{
     $dest (`(` $destOperands^ `:` type($destOperands) `)`)? attr-dict
   }];
   let builders = [LLVM_TerminatorPassthroughOpBuilder];
 }
 def LLVM_CondBrOp : LLVM_TerminatorOp<"cond_br",
     [AttrSizedOperandSegments, DeclareOpInterfaceMethods<BranchOpInterface>,
-     NoSideEffect]> {
+     Pure]> {
   let arguments = (ins I1:$condition,
                    Variadic<LLVM_Type>:$trueDestOperands,
                    Variadic<LLVM_Type>:$falseDestOperands,
                    OptionalAttr<ElementsAttr>:$branch_weights);
   let successors = (successor AnySuccessor:$trueDest, AnySuccessor:$falseDest);
   let assemblyFormat = [{
     $condition ( `weights` `(` $branch_weights^ `)` )? `,`
     $trueDest (`(` $trueDestOperands^ `:` type($trueDestOperands) `)`)? `,`
[{
             falseOperands);
   }]>, LLVM_TerminatorPassthroughOpBuilder];
 }
 
 //===----------------------------------------------------------------------===//
 // ReturnOp
 //===----------------------------------------------------------------------===//
 
-def LLVM_ReturnOp : LLVM_TerminatorOp<"return", [NoSideEffect]> {
+def LLVM_ReturnOp : LLVM_TerminatorOp<"return", [Pure]> {
   let arguments = (ins Optional<LLVM_Type>:$arg);
   let assemblyFormat = "attr-dict ($arg^ `:` type($arg))?";
 
   let builders = [
     OpBuilder<(ins "ValueRange":$args), [{
       build($_builder, $_state, TypeRange(), args);
     }]>
   ];

 }
 def LLVM_UnreachableOp : LLVM_TerminatorOp<"unreachable"> {
   string llvmBuilder = [{ builder.CreateUnreachable(); }];
   let assemblyFormat = "attr-dict";
 }
 
 def LLVM_SwitchOp : LLVM_TerminatorOp<"switch",
     [AttrSizedOperandSegments, DeclareOpInterfaceMethods<BranchOpInterface>,
-     NoSideEffect]> {
+     Pure]> {
   let arguments = (ins
     AnyInteger:$value,
     Variadic<AnyType>:$defaultOperands,
     VariadicOfVariadic<AnyType, "case_operand_segments">:$caseOperands,
     OptionalAttr<ElementsAttr>:$case_values,
     DenseI32ArrayAttr:$case_operand_segments,
     OptionalAttr<ElementsAttr>:$branch_weights
   );
def UnnamedAddr : LLVM_EnumAttr<
     "UnnamedAddr",
     "::llvm::GlobalValue::UnnamedAddr",
     "LLVM GlobalValue UnnamedAddr",
     [UnnamedAddrNone, UnnamedAddrLocal, UnnamedAddrGlobal]> {
   let cppNamespace = "::mlir::LLVM";
 }
 
 def LLVM_AddressOfOp : LLVM_Op<"mlir.addressof",
-    [NoSideEffect, DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
   let arguments = (ins FlatSymbolRefAttr:$global_name);
   let results = (outs LLVM_AnyPointer:$res);
 
   let summary = "Creates a pointer pointing to a global or a function";
 
   let description = [{
     Creates an SSA value containing a pointer to a global variable or constant
     defined by `llvm.mlir.global`. The global value can be defined after its
def LLVM_LLVMFuncOp : LLVM_Op<"func", [
   }];
 
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
   let hasRegionVerifier = 1;
 }
 
 def LLVM_NullOp
-    : LLVM_Op<"mlir.null", [NoSideEffect]>,
+    : LLVM_Op<"mlir.null", [Pure]>,
       LLVM_Builder<"$res = llvm::ConstantPointerNull::get("
                    "    cast<llvm::PointerType>($_resultType));"> {
   let summary = "Defines a value containing a null pointer to LLVM type.";
   let description = [{
     Unlike LLVM IR, MLIR does not have first-class null pointers. They must be
     explicitly created as SSA values using `llvm.mlir.null`. This operation has
     no operands or attributes, and returns a null value of a wrapped LLVM IR
     pointer type.
let description = [{
     ```
   }];
 
   let results = (outs LLVM_AnyPointer:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "attr-dict `:` type($res)";
 }
 
-def LLVM_UndefOp : LLVM_Op<"mlir.undef", [NoSideEffect]>,
+def LLVM_UndefOp : LLVM_Op<"mlir.undef", [Pure]>,
                    LLVM_Builder<"$res = llvm::UndefValue::get($_resultType);"> {
   let summary = "Creates an undefined value of LLVM dialect type.";
   let description = [{
     Unlike LLVM IR, MLIR does not have first-class undefined values. Such values
     must be created as SSA values using `llvm.mlir.undef`. This operation has no
     operands or attributes. It creates an undefined value of the specified LLVM
     IR dialect type wrapping an LLVM IR structure type.
 
     Example:
 
     ```mlir
     // Create a structure with a 32-bit integer followed by a float.
     %0 = llvm.mlir.undef : !llvm.struct<(i32, f32)>
     ```
   }];
   let results = (outs LLVM_Type:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "attr-dict `:` type($res)";
 }
 
 def LLVM_ConstantOp
-    : LLVM_Op<"mlir.constant", [NoSideEffect, ConstantLike]>,
+    : LLVM_Op<"mlir.constant", [Pure, ConstantLike]>,
       LLVM_Builder<[{$res = getLLVMConstant($_resultType, $value, $_location,
                                             moduleTranslation);}]>
 {
   let summary = "Defines a constant of LLVM type.";
   let description = [{
     Unlike LLVM IR, MLIR does not have first-class constant values. Therefore,
     all constants must be created as SSA values before being used in other
     operations. `llvm.mlir.constant` creates such values for scalars and

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

: LLVM_IntrOpBase<NVVM_Dialect, mnem, "nvvm_" # !subst(".", "_", mnem),
                     traits, numResults>;
 
 
 //===----------------------------------------------------------------------===//
 // NVVM special register op definitions
 //===----------------------------------------------------------------------===//
 
 class NVVM_SpecialRegisterOp<string mnemonic, list<Trait> traits = []> :
-  NVVM_IntrOp<mnemonic, !listconcat(traits, [NoSideEffect]), 1> {
+  NVVM_IntrOp<mnemonic, !listconcat(traits, [Pure]), 1> {
   let arguments = (ins);
   let assemblyFormat = "attr-dict `:` type($res)";
 }
 
 //===----------------------------------------------------------------------===//
 // Lane index and range
 def NVVM_LaneIdOp : NVVM_SpecialRegisterOp<"read.ptx.sreg.laneid">;
 def NVVM_WarpSizeOp : NVVM_SpecialRegisterOp<"read.ptx.sreg.warpsize">;

 def NVVM_GridDimXOp : NVVM_SpecialRegisterOp<"read.ptx.sreg.nctaid.x">;
 def NVVM_GridDimYOp : NVVM_SpecialRegisterOp<"read.ptx.sreg.nctaid.y">;
 def NVVM_GridDimZOp : NVVM_SpecialRegisterOp<"read.ptx.sreg.nctaid.z">;
 
 //===----------------------------------------------------------------------===//
 // NVVM approximate op definitions
 //===----------------------------------------------------------------------===//
 
-def NVVM_RcpApproxFtzF32Op : NVVM_IntrOp<"rcp.approx.ftz.f", [NoSideEffect], 1> {
+def NVVM_RcpApproxFtzF32Op : NVVM_IntrOp<"rcp.approx.ftz.f", [Pure], 1> {
   let arguments = (ins F32:$arg);
   let results = (outs F32:$res);
   let assemblyFormat = "$arg attr-dict `:` type($res)";
 }
 
 //===----------------------------------------------------------------------===//
 // NVVM synchronization op definitions
 //===----------------------------------------------------------------------===//

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

 }
 
 //===----------------------------------------------------------------------===//
 // ROCDL special register op definitions
 //===----------------------------------------------------------------------===//
 
 class ROCDL_SpecialRegisterOp<string mnemonic,
     list<Trait> traits = []> :
-  ROCDL_Op<mnemonic, !listconcat(traits, [NoSideEffect])>,
+  ROCDL_Op<mnemonic, !listconcat(traits, [Pure])>,
   Results<(outs LLVM_Type:$res)>, Arguments<(ins)> {
   string llvmBuilder = "$res = createIntrinsicCall(builder,"
     # "llvm::Intrinsic::amdgcn_" # !subst(".","_", mnemonic) # ");";
   let assemblyFormat = "attr-dict `:` type($res)";
 }
 
 class ROCDL_DeviceFunctionOp<string mnemonic, string device_function,
                              int parameter, list<Trait> traits = []> :
-  ROCDL_Op<mnemonic, !listconcat(traits, [NoSideEffect])>,
+  ROCDL_Op<mnemonic, !listconcat(traits, [Pure])>,
   Results<(outs LLVM_Type:$res)>, Arguments<(ins)> {
   string llvmBuilder = "$res = createDeviceFunctionCall(builder, \""
   # device_function # "\", " # parameter # ");";
   let assemblyFormat = "attr-dict `:` type($res)";
 }
 
 //===----------------------------------------------------------------------===//
 // Thread index and Block index

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

 include "mlir/Interfaces/LoopLikeInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/ViewLikeInterface.td"
 
 // Base class for Linalg dialect ops that do not correspond to library calls.
 class Linalg_Op<string mnemonic, list<Trait> traits = []> :
     Op<Linalg_Dialect, mnemonic, traits>;
 
-def Linalg_YieldOp : Linalg_Op<"yield", [NoSideEffect, ReturnLike, Terminator]>,
+def Linalg_YieldOp : Linalg_Op<"yield", [Pure, ReturnLike, Terminator]>,
     Arguments<(ins Variadic<AnyType>:$values)> {
   let summary = "Linalg yield operation";
   let description = [{
     `linalg.yield` is a special terminator operation for blocks inside regions
     in `linalg` generic ops. It returns values to the immediately enclosing
     `linalg` generic op.
 
     Example:
 
     ```mlir
     linalg.yield %f0, %f1 : f32, f32
     ```
   }];
   let builders = [OpBuilder<(ins), [{ /* nothing to do */ }]>];
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
-def Linalg_IndexOp : Linalg_Op<"index", [NoSideEffect]>,
+def Linalg_IndexOp : Linalg_Op<"index", [Pure]>,
     Arguments<(ins ConfinedAttr<I64Attr, [IntMinValue<0>]>:$dim)>,
     Results<(outs Index:$result)> {
   let summary = "linalg index operation";
   let description = [{
     The `linalg.index` operation returns the iteration index of the immediately
     enclosing linalg structured operation for the iteration dimension `dim`. The
     `dim` attribute specifies the position of the accessed dimension in the
     indexing map domain.

mlir/include/mlir/Dialect/MLProgram/IR/MLProgramOps.td

def MLProgram_GlobalLoadOp : MLProgram_Op<"global_load", [
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // GlobalLoadConstOp
 //===----------------------------------------------------------------------===//
 
 def MLProgram_GlobalLoadConstOp : MLProgram_Op<"global_load_const", [
-    NoSideEffect,
+    Pure,
     DeclareOpInterfaceMethods<SymbolUserOpInterface>
   ]> {
   let summary = "Direct load a constant value from a global";
   let description = [{
     Loads a constant (immutable) value from a global directly by symbol.
 
     This op is only legal for globals that are not mutable and exists because
     such a load can be considered to have no side effects.
def MLProgram_SubgraphOp : MLProgram_Op<"subgraph", [
   let hasCustomAssemblyFormat = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // OutputOp
 //===----------------------------------------------------------------------===//
 
 def MLProgram_OutputOp : MLProgram_Op<"output", [
-    NoSideEffect, HasParent<"SubgraphOp">, ReturnLike, Terminator
+    Pure, HasParent<"SubgraphOp">, ReturnLike, Terminator
   ]> {
   let summary = "Outputs values from a subgraph function";
   let description = [{
     The `output` operation terminates a subgraph by yielding values
     to the caller.
     The operation takes variable number of operands and produces no results.
     The operand number and types must match the signature of the function
     that contains the operation.
def MLProgram_OutputOp : MLProgram_Op<"output", [
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ReturnOp
 //===----------------------------------------------------------------------===//
 
 def MLProgram_ReturnOp : MLProgram_Op<"return", [
-    NoSideEffect, HasParent<"FuncOp">, ReturnLike, Terminator
+    Pure, HasParent<"FuncOp">, ReturnLike, Terminator
   ]> {
   let summary = "Returns values from a `func` function";
   let description = [{
     The `return` operation terminates a `func` function by yielding values
     to the caller.
     The operation takes variable number of operands and produces no results.
     The operand number and types must match the signature of the function
     that contains the operation.
def MLProgram_ReturnOp : MLProgram_Op<"return", [
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // TokenOp
 //===----------------------------------------------------------------------===//
 
 def MLProgram_TokenOp : MLProgram_Op<"token", [
-    NoSideEffect
+    Pure
   ]> {
   let summary = "Produces a new token value";
   let description = [{
     Token values are used to chain side effecting ops in a graph so as to
     establish an execution order. This op produces a token.
   }];
 
   let results = (outs
     MLProgram_TokenType:$token
   );
 
   let assemblyFormat = "attr-dict";
 }
 
 #endif // MLPROGRAM_OPS

mlir/include/mlir/Dialect/Math/IR/MathOps.td

 include "mlir/Dialect/Math/IR/MathBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/VectorInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // Base class for math dialect ops. Ops in this dialect have no side effects and
 // can be applied element-wise to vectors and tensors.
 class Math_Op<string mnemonic, list<Trait> traits = []> :
-    Op<Math_Dialect, mnemonic, traits # [NoSideEffect,
+    Op<Math_Dialect, mnemonic, traits # [Pure,
     DeclareOpInterfaceMethods<VectorUnrollOpInterface>] #
     ElementwiseMappable.traits>;
 
 // Base class for unary math operations on integer types. Require an operand
 // and result of the same type. This type can be an integer type, vector or
 // tensor thereof.
 class Math_IntegerUnaryOp<string mnemonic, list<Trait> traits = []> :
     Math_Op<mnemonic, traits # [SameOperandsAndResultType]> {

mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td

 //===----------------------------------------------------------------------===//
 // AllocaScopeOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_AllocaScopeOp : MemRef_Op<"alloca_scope",
       [AutomaticAllocationScope,
        DeclareOpInterfaceMethods<RegionBranchOpInterface>,
        SingleBlockImplicitTerminator<"AllocaScopeReturnOp">,
-       RecursiveSideEffects,
+       RecursiveMemoryEffects,
        NoRegionArguments]> {
   let summary = "explicitly delimited scope for stack allocation";
   let description = [{
     The `memref.alloca_scope` operation represents an explicitly-delimited
     scope for the alloca allocations. Any `memref.alloca` operations that are
     used within this scope are going to be cleaned up automatically once
     the control-flow exits the nested region. For example:
 

 }
 
 //===----------------------------------------------------------------------===//
 // AllocaScopeReturnOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_AllocaScopeReturnOp : MemRef_Op<"alloca_scope.return",
       [HasParent<"AllocaScopeOp">,
-       NoSideEffect,
+       Pure,
        ReturnLike,
        Terminator]> {
   let summary = "terminator for alloca_scope operation";
   let description = [{
     `memref.alloca_scope.return` operation returns zero or more SSA values
     from the region within `memref.alloca_scope`. If no values are returned,
     the return operation may be omitted. Otherwise, it has to be present
     to indicate which values are going to be returned. For example:

 //===----------------------------------------------------------------------===//
 // CastOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_CastOp : MemRef_Op<"cast", [
       DeclareOpInterfaceMethods<CastOpInterface>,
       DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
       MemRefsNormalizable,
-      NoSideEffect,
+      Pure,
       SameOperandsAndResultShape,
       ViewLikeOpInterface
     ]> {
   let summary = "memref cast operation";
   let description = [{
     Syntax:
 
     ```

 
 //===----------------------------------------------------------------------===//
 // DimOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_DimOp : MemRef_Op<"dim", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
     MemRefsNormalizable,
-    NoSideEffect,
+    Pure,
     ShapedDimOpInterface]> {
   let summary = "dimension index operation";
   let description = [{
     The `dim` operation takes a memref and a dimension operand of type `index`.
     It returns the size of the requested dimension of the given memref.
     If the dimension index is out of bounds the behavior is undefined.
 
     The specified memref type is that of the first operand.

 
 //===----------------------------------------------------------------------===//
 // ExtractAlignedPointerAsIndexOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_ExtractAlignedPointerAsIndexOp : 
   MemRef_Op<"extract_aligned_pointer_as_index", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-    NoSideEffect, 
+    Pure, 
     SameVariadicResultSize]> {
   let summary = "Extracts a memref's underlying aligned pointer as an index";
   let description = [{
     Extracts the underlying aligned pointer as an index.
 
     This operation is useful for lowering to lower-level dialects while still
     avoiding the need to define a pointer type in higher-level dialects such as
     the memref dialect.

 }
 
 //===----------------------------------------------------------------------===//
 // ExtractStridedMetadataOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_ExtractStridedMetadataOp : MemRef_Op<"extract_strided_metadata", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-    NoSideEffect, 
+    Pure, 
     SameVariadicResultSize]> {
   let summary = "Extracts a buffer base with offset and strides";
   let description = [{
     Extracts a base buffer, offset and strides. This op allows additional layers
     of transformations and foldings to be added as lowering progresses from
     higher-level dialect to lower-level dialects such as the LLVM dialect.
 
     The op requires a strided memref source operand. If the source operand is not
let extraClassDeclaration = [{
     }
   }];
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
 def AtomicYieldOp : MemRef_Op<"atomic_yield", [
       HasParent<"GenericAtomicRMWOp">,
-      NoSideEffect,
+      Pure,
       Terminator
     ]> {
   let summary = "yield operation for GenericAtomicRMWOp";
   let description = [{
     "memref.atomic_yield" yields an SSA value from a
     GenericAtomicRMWOp region.
   }];
 
   let arguments = (ins AnyType:$result);
   let assemblyFormat = "$result attr-dict `:` type($result)";
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // GetGlobalOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_GetGlobalOp : MemRef_Op<"get_global",
-    [NoSideEffect, DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
   let summary = "get the memref pointing to a global variable";
   let description = [{
      The `memref.get_global` operation retrieves the memref pointing to a
      named global variable. If the global variable is marked constant, writing
      to the result memref (such as through a `memref.store` operation) is
      undefined.
 
      Example:

 // ReinterpretCastOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_ReinterpretCastOp
   : MemRef_OpWithOffsetSizesAndStrides<"reinterpret_cast", [
       DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
       AttrSizedOperandSegments, 
       MemRefsNormalizable,
-      NoSideEffect, 
+      Pure, 
       OffsetSizeAndStrideOpInterface, 
       ViewLikeOpInterface
     ]> {
   let summary = "memref reinterpret cast operation";
   let description = [{
     Modify offset, sizes and strides of an unranked/ranked memref.
 
     Example:
def MemRef_ReinterpretCastOp
   let hasFolder = 1;
   let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // RankOp
 //===----------------------------------------------------------------------===//
 
-def MemRef_RankOp : MemRef_Op<"rank", [NoSideEffect]> {
+def MemRef_RankOp : MemRef_Op<"rank", [Pure]> {
   let summary = "rank operation";
   let description = [{
     The `memref.rank` operation takes a memref operand and returns its rank.
 
     Example:
 
     ```mlir
     %0 = memref.rank %arg0 : memref<*xf32>

 }
 
 //===----------------------------------------------------------------------===//
 // ReshapeOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_ReshapeOp: MemRef_Op<"reshape", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-    NoSideEffect,
+    Pure,
     ViewLikeOpInterface]>  {
   let summary = "memref reshape operation";
   let description = [{
     The `reshape` operation converts a memref from one type to an
     equivalent type with a provided shape. The data is never copied or
     modified. The source and destination types are compatible if both have the
     same element type, same number of elements, address space and identity
     layout map. The following combinations are possible:

 }
 
 //===----------------------------------------------------------------------===//
 // ExpandShapeOp / CollapseShapeOp
 //===----------------------------------------------------------------------===//
 
 class MemRef_ReassociativeReshapeOp<string mnemonic, list<Trait> traits = []> :
     MemRef_Op<mnemonic, !listconcat(traits,
-      [NoSideEffect, ViewLikeOpInterface])>,
+      [Pure, ViewLikeOpInterface])>,
     Arguments<(ins AnyStridedMemRef:$src, IndexListArrayAttr:$reassociation)>,
     Results<(outs AnyStridedMemRef:$result)>{
 
   code commonExtraClassDeclaration = [{
     SmallVector<AffineMap, 4> getReassociationMaps();
 
     SmallVector<ReassociationExprs, 4> getReassociationExprs();
 

 // SubViewOp
 //===----------------------------------------------------------------------===//
 
 def SubViewOp : MemRef_OpWithOffsetSizesAndStrides<"subview", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
     DeclareOpInterfaceMethods<ViewLikeOpInterface>,
     AttrSizedOperandSegments,
     OffsetSizeAndStrideOpInterface,
-    NoSideEffect
+    Pure
   ]> {
   let summary = "memref subview operation";
   let description = [{
     The "subview" operation converts a memref type to another memref type
     which represents a reduced-size view of the original memref as specified by
     the operation's offsets, sizes and strides arguments.
 
     The SubView operation supports the following arguments:

 }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_TransposeOp : MemRef_Op<"transpose", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-    NoSideEffect]>,
+    Pure]>,
     Arguments<(ins AnyStridedMemRef:$in, AffineMapAttr:$permutation)>,
     Results<(outs AnyStridedMemRef)> {
   let summary = "`transpose` produces a new strided memref (metadata-only)";
   let description = [{
     The `transpose` op produces a strided memref whose sizes and strides
     are a permutation of the original `in` memref. This is purely a metadata
     transformation.
 

 
 //===----------------------------------------------------------------------===//
 // ViewOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_ViewOp : MemRef_Op<"view", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
     DeclareOpInterfaceMethods<ViewLikeOpInterface>, 
-    NoSideEffect]> {
+    Pure]> {
   let summary = "memref view operation";
   let description = [{
     The "view" operation extracts an N-D contiguous memref with empty layout map
     with arbitrary element type from a 1-D contiguous memref with empty layout
     map of i8 element  type. The ViewOp supports the following arguments:
 
     * A single dynamic byte-shift operand must be specified which represents a
       a shift of the base 1-D memref pointer from which to create the resulting

mlir/include/mlir/Dialect/NVGPU/IR/NVGPU.td

def NVGPU_LdMatrixOp : NVGPU_Op<"ldmatrix", [
   let assemblyFormat = [{
     $srcMemref`[` $indices `]` attr-dict `:` type($srcMemref) `->` type($res)
   }];
 
   let hasVerifier = 1;
 }
 
 def NVGPU_MmaSyncOp : NVGPU_Op<"mma.sync", [
-                               NoSideEffect,
+                               Pure,
                                PredOpTrait<"matrixA and matrixB have same element type", 
                                            TCopVTEtIsSameAs<0, 1>>]> {
   let description = [{
   The `nvgpu.mma.sync` op represents the distributed form of a collective
   matrix-multiply-and-accumulate (mma) operation that is compatible with
   `nvvm.mma.sync`. The operands and results are fragments of the full matrix
   operands. The full shape of the distributed mma operation is given by the
   `mmaShape` attribute in the form of a list of dimensions `[m, n, k]`.

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

 
 //===----------------------------------------------------------------------===//
 // 2.6 parallel Construct
 //===----------------------------------------------------------------------===//
 
 def ParallelOp : OpenMP_Op<"parallel", [
                  AutomaticAllocationScope, AttrSizedOperandSegments,
                  DeclareOpInterfaceMethods<OutlineableOpenMPOpInterface>,
-                 RecursiveSideEffects, ReductionClauseInterface]> {
+                 RecursiveMemoryEffects, ReductionClauseInterface]> {
   let summary = "parallel construct";
   let description = [{
     The parallel construct includes a region of code which is to be executed
     by a team of threads.
 
     The optional $if_expr_var parameter specifies a boolean result of a
     conditional check. If this value is 1 or is not provided then the parallel
     region runs as normal, if it is 0 then the parallel region is executed with
oilist( `reduction` `(`
                 $allocators_vars, type($allocators_vars)
               ) `)`
           | `proc_bind` `(` custom<ClauseAttr>($proc_bind_val) `)`
     ) $region attr-dict
   }];
   let hasVerifier = 1;
 }
 
-def TerminatorOp : OpenMP_Op<"terminator", [Terminator, NoSideEffect]> {
+def TerminatorOp : OpenMP_Op<"terminator", [Terminator, Pure]> {
   let summary = "terminator for OpenMP regions";
   let description = [{
     A terminator operation for regions that appear in the body of OpenMP
     operation.  These regions are not expected to return any value so the
     terminator takes no operands. The terminator op returns control to the
     enclosing op.
   }];
 

 }
 
 //===----------------------------------------------------------------------===//
 // 2.9.2 Workshare Loop Construct
 //===----------------------------------------------------------------------===//
 
 def WsLoopOp : OpenMP_Op<"wsloop", [AttrSizedOperandSegments,
                          AllTypesMatch<["lowerBound", "upperBound", "step"]>,
-                         RecursiveSideEffects, ReductionClauseInterface]> {
+                         RecursiveMemoryEffects, ReductionClauseInterface]> {
   let summary = "worksharing-loop construct";
   let description = [{
     The worksharing-loop construct specifies that the iterations of the loop(s)
     will be executed in parallel by threads in the current context. These
     iterations are spread across threads that already exist in the enclosing
     parallel region. The lower and upper bounds specify a half-open range: the
     range includes the lower bound but does not include the upper bound. If the
     `inclusive` attribute is specified then the upper bound is also included.
let summary = "simd loop construct";
   }];
 
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
 
 def YieldOp : OpenMP_Op<"yield",
-    [NoSideEffect, ReturnLike, Terminator,
+    [Pure, ReturnLike, Terminator,
      ParentOneOf<["WsLoopOp", "ReductionDeclareOp",
      "AtomicUpdateOp", "SimdLoopOp"]>]> {
   let summary = "loop yield and termination operation";
   let description = [{
     "omp.yield" yields SSA values from the OpenMP dialect op region and
     terminates the region. The semantics of how the values are yielded is
     defined by the parent operation.
   }];
SmallVector<Value> getReductionVars() {
       return SmallVector<Value>(getInReductionVars().begin(),
                                 getInReductionVars().end());
     }
   }];
   let hasVerifier = 1;
 }
 
 def TaskLoopOp : OpenMP_Op<"taskloop", [AttrSizedOperandSegments,
-                           AutomaticAllocationScope, RecursiveSideEffects,
+                           AutomaticAllocationScope, RecursiveMemoryEffects,
                            AllTypesMatch<["lowerBound", "upperBound", "step"]>,
                            ReductionClauseInterface]> {
   let summary = "taskloop construct";
   let description = [{
     The taskloop construct specifies that the iterations of one or more
     associated loops will be executed in parallel using explicit tasks. The
     iterations are distributed across tasks generated by the construct and
     scheduled to be executed.
Value getVariableOperand(unsigned i) {
       assert(i < 2 && "invalid index position for an operand");
       return i == 0 ? getAddress() : getValue();
     }
   }];
 }
 
 def AtomicUpdateOp : OpenMP_Op<"atomic.update",
                                [SingleBlockImplicitTerminator<"YieldOp">,
-                                RecursiveSideEffects]> {
+                                RecursiveMemoryEffects]> {
 
   let summary = "performs an atomic update";
 
   let description = [{
     This operation performs an atomic update.
 
     The operand `x` is exactly the same as the operand `x` in the OpenMP
     Standard (OpenMP 5.0, section 2.17.7). It is the address of the variable

mlir/include/mlir/Dialect/PDL/IR/PDLOps.td

def PDL_ReplaceOp : PDL_Op<"replace", [
   }];
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ResultOp
 //===----------------------------------------------------------------------===//
 
-def PDL_ResultOp : PDL_Op<"result", [NoSideEffect]> {
+def PDL_ResultOp : PDL_Op<"result", [Pure]> {
   let summary = "Extract a result from an operation";
   let description = [{
     `pdl.result` operations extract result edges from an operation node within
     a pattern or rewrite region. The provided index is zero-based, and
     represents the concrete result to extract, i.e. this is not the result index
     as defined by the ODS definition of the operation.
 
     Example:
def PDL_ResultOp : PDL_Op<"result", [Pure]> {
   let results = (outs PDL_Value:$val);
   let assemblyFormat = "$index `of` $parent attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ResultsOp
 //===----------------------------------------------------------------------===//
 
-def PDL_ResultsOp : PDL_Op<"results", [NoSideEffect]> {
+def PDL_ResultsOp : PDL_Op<"results", [Pure]> {
   let summary = "Extract a result group from an operation";
   let description = [{
     `pdl.results` operations extract a result group from an operation within a
     pattern or rewrite region. If an index is provided, this operation extracts
     a result group as defined by the ODS definition of the operation. In this
     case the result of this operation may be either a single `pdl.value` or
     a `pdl.range<value>`, depending on the constraint of the result in ODS. If
     no index is provided, this operation extracts the full result range of the

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

def PDLInterp_ApplyRewriteOp : PDLInterp_Op<"apply_rewrite"> {
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::AreEqualOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_AreEqualOp
-    : PDLInterp_PredicateOp<"are_equal", [NoSideEffect, SameTypeOperands]> {
+    : PDLInterp_PredicateOp<"are_equal", [Pure, SameTypeOperands]> {
   let summary = "Check if two positional values or ranges are equivalent";
   let description = [{
     `pdl_interp.are_equal` operations compare two positional values for
     equality. On success, this operation branches to the true destination,
     otherwise the false destination is taken.
 
     Example:
 
     ```mlir
     pdl_interp.are_equal %result1, %result2 : !pdl.value -> ^matchDest, ^failureDest
     ```
   }];
 
   let arguments = (ins PDL_AnyType:$lhs, PDL_AnyType:$rhs);
   let assemblyFormat = "operands `:` type($lhs) attr-dict `->` successors";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::BranchOp
 //===----------------------------------------------------------------------===//
 
-def PDLInterp_BranchOp : PDLInterp_Op<"branch", [NoSideEffect, Terminator]> {
+def PDLInterp_BranchOp : PDLInterp_Op<"branch", [Pure, Terminator]> {
   let summary = "General branch operation";
   let description = [{
     `pdl_interp.branch` operations expose general branch functionality to the
     interpreter, and are generally used to branch from one pattern match
     sequence to another.
 
     Example:
 
     ```mlir
     pdl_interp.branch ^dest
     ```
   }];
 
   let successors = (successor AnySuccessor:$dest);
   let assemblyFormat = "$dest attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CheckAttributeOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_CheckAttributeOp
-    : PDLInterp_PredicateOp<"check_attribute", [NoSideEffect]> {
+    : PDLInterp_PredicateOp<"check_attribute", [Pure]> {
   let summary = "Check the value of an `Attribute`";
   let description = [{
     `pdl_interp.check_attribute` operations compare the value of a given
     attribute with a constant value. On success, this operation branches to the
     true destination, otherwise the false destination is taken.
 
     Example:
 
     ```mlir
     pdl_interp.check_attribute %attr is 10 -> ^matchDest, ^failureDest
     ```
   }];
 
   let arguments = (ins PDL_Attribute:$attribute, AnyAttr:$constantValue);
   let assemblyFormat = [{
     $attribute `is` $constantValue attr-dict `->` successors
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CheckOperandCountOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_CheckOperandCountOp
-    : PDLInterp_PredicateOp<"check_operand_count", [NoSideEffect]> {
+    : PDLInterp_PredicateOp<"check_operand_count", [Pure]> {
   let summary = "Check the number of operands of an `Operation`";
   let description = [{
     `pdl_interp.check_operand_count` operations compare the number of operands
     of a given operation value with a constant. The comparison is either exact
     or at_least, with the latter used to compare against a minimum number of
     expected operands. On success, this operation branches to the true
     destination, otherwise the false destination is taken.
 
def PDLInterp_CheckOperandCountOp
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CheckOperationNameOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_CheckOperationNameOp
-    : PDLInterp_PredicateOp<"check_operation_name", [NoSideEffect]> {
+    : PDLInterp_PredicateOp<"check_operation_name", [Pure]> {
   let summary = "Check the OperationName of an `Operation`";
   let description = [{
     `pdl_interp.check_operation_name` operations compare the name of a given
     operation with a known name. On success, this operation branches to the true
     destination, otherwise the false destination is taken.
 
     Example:
 
     ```mlir
     pdl_interp.check_operation_name of %op is "foo.op" -> ^matchDest, ^failureDest
     ```
   }];
 
   let arguments = (ins PDL_Operation:$inputOp, StrAttr:$name);
   let assemblyFormat = "`of` $inputOp `is` $name attr-dict `->` successors";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CheckResultCountOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_CheckResultCountOp
-    : PDLInterp_PredicateOp<"check_result_count", [NoSideEffect]> {
+    : PDLInterp_PredicateOp<"check_result_count", [Pure]> {
   let summary = "Check the number of results of an `Operation`";
   let description = [{
     `pdl_interp.check_result_count` operations compare the number of results
     of a given operation value with a constant. The comparison is either exact
     or at_least, with the latter used to compare against a minimum number of
     expected results. On success, this operation branches to the true
     destination, otherwise the false destination is taken.
 
def PDLInterp_CheckResultCountOp
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CheckTypeOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_CheckTypeOp
-    : PDLInterp_PredicateOp<"check_type", [NoSideEffect]> {
+    : PDLInterp_PredicateOp<"check_type", [Pure]> {
   let summary = "Compare a type to a known value";
   let description = [{
     `pdl_interp.check_type` operations compare a type with a statically known
     type. On success, this operation branches to the true destination, otherwise
     the false destination is taken.
 
     Example:
 
     ```mlir
     pdl_interp.check_type %type is i32 -> ^matchDest, ^failureDest
     ```
   }];
 
   let arguments = (ins PDL_Type:$value, TypeAttr:$type);
   let assemblyFormat = "$value `is` $type attr-dict `->` successors";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CheckTypesOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_CheckTypesOp
-    : PDLInterp_PredicateOp<"check_types", [NoSideEffect]> {
+    : PDLInterp_PredicateOp<"check_types", [Pure]> {
   let summary = "Compare a range of types to a range of known values";
   let description = [{
     `pdl_interp.check_types` operations compare a range of types with a
     statically known range of types. On success, this operation branches
     to the true destination, otherwise the false destination is taken.
 
     Example:
 
     ```mlir
     pdl_interp.check_types %type are [i32, i64] -> ^matchDest, ^failureDest
     ```
   }];
 
   let arguments = (ins PDL_RangeOf<PDL_Type>:$value,
                        TypeArrayAttr:$types);
   let assemblyFormat = "$value `are` $types attr-dict `->` successors";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::ContinueOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_ContinueOp
-    : PDLInterp_Op<"continue", [NoSideEffect, HasParent<"ForEachOp">,
+    : PDLInterp_Op<"continue", [Pure, HasParent<"ForEachOp">,
                                Terminator]> {
   let summary = "Breaks the current iteration";
   let description = [{
     `pdl_interp.continue` operation breaks the current iteration within the
     `pdl_interp.foreach` region and continues with the next iteration from
     the beginning of the region.
 
     Example:
 
     ```mlir
     pdl_interp.continue
     ```
   }];
 
   let assemblyFormat = "attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CreateAttributeOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_CreateAttributeOp
-    : PDLInterp_Op<"create_attribute", [NoSideEffect]> {
+    : PDLInterp_Op<"create_attribute", [Pure]> {
   let summary = "Create an interpreter handle to a constant `Attribute`";
   let description = [{
     `pdl_interp.create_attribute` operations generate a handle within the
     interpreter for a specific constant attribute value.
 
     Example:
 
     ```mlir
def PDLInterp_CreateOperationOp
   }];
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CreateTypeOp
 //===----------------------------------------------------------------------===//
 
-def PDLInterp_CreateTypeOp : PDLInterp_Op<"create_type", [NoSideEffect]> {
+def PDLInterp_CreateTypeOp : PDLInterp_Op<"create_type", [Pure]> {
   let summary = "Create an interpreter handle to a constant `Type`";
   let description = [{
     `pdl_interp.create_type` operations generate a handle within the interpreter
     for a specific constant type value.
 
     Example:
 
     ```mlir
let builders = [
     }]>
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CreateTypesOp
 //===----------------------------------------------------------------------===//
 
-def PDLInterp_CreateTypesOp : PDLInterp_Op<"create_types", [NoSideEffect]> {
+def PDLInterp_CreateTypesOp : PDLInterp_Op<"create_types", [Pure]> {
   let summary = "Create an interpreter handle to a range of constant `Type`s";
   let description = [{
     `pdl_interp.create_types` operations generate a handle within the
     interpreter for a specific range of constant type values.
 
     Example:
 
     ```mlir
def PDLInterp_EraseOp : PDLInterp_Op<"erase"> {
   let assemblyFormat = "$inputOp attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::ExtractOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_ExtractOp
-    : PDLInterp_Op<"extract", [NoSideEffect,
+    : PDLInterp_Op<"extract", [Pure,
      TypesMatchWith<
         "`range` is a PDL range whose element type matches type of `result`",
         "result", "range", "pdl::RangeType::get($_self)">]> {
   let summary = "Extract the item at the specified index in a range";
   let description = [{
     `pdl_interp.extract` operations are used to extract an item from a range
     at the specified index. If the index is out of range, returns null.
 
def PDLInterp_ExtractOp
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::FinalizeOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_FinalizeOp
-    : PDLInterp_Op<"finalize", [NoSideEffect, Terminator]> {
+    : PDLInterp_Op<"finalize", [Pure, Terminator]> {
   let summary = "Finalize a pattern match or rewrite sequence";
   let description = [{
     `pdl_interp.finalize` is used to denote the termination of a match or
     rewrite sequence.
 
     Example:
 
     ```mlir
def PDLInterp_FuncOp : PDLInterp_Op<"func", [
   let hasCustomAssemblyFormat = 1;
   let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetAttributeOp
 //===----------------------------------------------------------------------===//
 
-def PDLInterp_GetAttributeOp : PDLInterp_Op<"get_attribute", [NoSideEffect]> {
+def PDLInterp_GetAttributeOp : PDLInterp_Op<"get_attribute", [Pure]> {
   let summary = "Get a specified attribute value from an `Operation`";
   let description = [{
     `pdl_interp.get_attribute` operations try to get a specific attribute from
     an operation. If the operation does not have that attribute, a null value is
     returned.
 
     Example:
 
     ```mlir
     %attr = pdl_interp.get_attribute "attr" of %op
     ```
   }];
 
   let arguments = (ins PDL_Operation:$inputOp, StrAttr:$name);
   let results = (outs PDL_Attribute:$attribute);
   let assemblyFormat = "$name `of` $inputOp attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetAttributeTypeOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_GetAttributeTypeOp
-    : PDLInterp_Op<"get_attribute_type", [NoSideEffect]> {
+    : PDLInterp_Op<"get_attribute_type", [Pure]> {
   let summary = "Get the result type of a specified `Attribute`";
   let description = [{
     `pdl_interp.get_attribute_type` operations get the resulting type of a
     specific attribute.
 
     Example:
 
     ```mlir
def PDLInterp_GetAttributeTypeOp
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetDefiningOpOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_GetDefiningOpOp
-    : PDLInterp_Op<"get_defining_op", [NoSideEffect]> {
+    : PDLInterp_Op<"get_defining_op", [Pure]> {
   let summary = "Get the defining operation of a `Value`";
   let description = [{
     `pdl_interp.get_defining_op` operations try to get the defining operation
     of a specific value or range of values. In the case of range, the defining
     op of the first value is returned. If the value is not an operation result
     or range of operand results, null is returned.
 
     Example:
 
     ```mlir
     %op = pdl_interp.get_defining_op of %value : !pdl.value
     ```
   }];
 
   let arguments = (ins PDL_InstOrRangeOf<PDL_Value>:$value);
   let results = (outs PDL_Operation:$inputOp);
   let assemblyFormat = "`of` $value `:` type($value) attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetOperandOp
 //===----------------------------------------------------------------------===//
 
-def PDLInterp_GetOperandOp : PDLInterp_Op<"get_operand", [NoSideEffect]> {
+def PDLInterp_GetOperandOp : PDLInterp_Op<"get_operand", [Pure]> {
   let summary = "Get a specified operand from an `Operation`";
   let description = [{
     `pdl_interp.get_operand` operations try to get a specific operand from an
     operation If the operation does not have an operand for the given index, a
     null value is returned.
 
     Example:
 
     ```mlir
     %operand = pdl_interp.get_operand 1 of %op
     ```
   }];
 
   let arguments = (ins PDL_Operation:$inputOp,
                        ConfinedAttr<I32Attr, [IntNonNegative]>:$index);
   let results = (outs PDL_Value:$value);
   let assemblyFormat = "$index `of` $inputOp attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetOperandsOp
 //===----------------------------------------------------------------------===//
 
-def PDLInterp_GetOperandsOp : PDLInterp_Op<"get_operands", [NoSideEffect]> {
+def PDLInterp_GetOperandsOp : PDLInterp_Op<"get_operands", [Pure]> {
   let summary = "Get a specified operand group from an `Operation`";
   let description = [{
     `pdl_interp.get_operands` operations try to get a specific operand
     group from an operation. If the expected result is a single Value, null is
     returned if the operand group is not of size 1. If a range is expected,
     null is returned if the operand group is invalid. If no index is provided,
     the returned operand group corresponds to all operands of the operation.
 
let builders = [
     }]>,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetResultOp
 //===----------------------------------------------------------------------===//
 
-def PDLInterp_GetResultOp : PDLInterp_Op<"get_result", [NoSideEffect]> {
+def PDLInterp_GetResultOp : PDLInterp_Op<"get_result", [Pure]> {
   let summary = "Get a specified result from an `Operation`";
   let description = [{
     `pdl_interp.get_result` operations try to get a specific result from an
     operation. If the operation does not have a result for the given index, a
     null value is returned.
 
     Example:
 
     ```mlir
     %result = pdl_interp.get_result 1 of %op
     ```
   }];
 
   let arguments = (ins PDL_Operation:$inputOp,
                        ConfinedAttr<I32Attr, [IntNonNegative]>:$index);
   let results = (outs PDL_Value:$value);
   let assemblyFormat = "$index `of` $inputOp attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetResultsOp
 //===----------------------------------------------------------------------===//
 
-def PDLInterp_GetResultsOp : PDLInterp_Op<"get_results", [NoSideEffect]> {
+def PDLInterp_GetResultsOp : PDLInterp_Op<"get_results", [Pure]> {
   let summary = "Get a specified result group from an `Operation`";
   let description = [{
     `pdl_interp.get_results` operations try to get a specific result group
     from an operation. If the expected result is a single Value, null is
     returned if the result group is not of size 1. If a range is expected,
     null is returned if the result group is invalid. If no index is provided,
     the returned operand group corresponds to all results of the operation.
 
def PDLInterp_GetResultsOp : PDLInterp_Op<"get_results", [Pure]> {
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetUsersOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_GetUsersOp
-    : PDLInterp_Op<"get_users", [NoSideEffect]> {
+    : PDLInterp_Op<"get_users", [Pure]> {
   let summary = "Get the users of a `Value`";
   let description = [{
     `pdl_interp.get_users` extracts the users that accept this value. In the
     case of a range, the union of users of the all the values are returned,
     similarly to ResultRange::getUsers.
 
     Example:
 
let builders = [
     }]>,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetValueTypeOp
 //===----------------------------------------------------------------------===//
 
-def PDLInterp_GetValueTypeOp : PDLInterp_Op<"get_value_type", [NoSideEffect,
+def PDLInterp_GetValueTypeOp : PDLInterp_Op<"get_value_type", [Pure,
      TypesMatchWith<"`value` type matches arity of `result`",
                     "result", "value", "getGetValueTypeOpValueType($_self)">]> {
   let summary = "Get the result type of a specified `Value`";
   let description = [{
     `pdl_interp.get_value_type` operations get the resulting type of a specific
     value or range thereof.
 
     Example:
def PDLInterp_GetValueTypeOp : PDLInterp_Op<"get_value_type", [Pure,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::IsNotNullOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_IsNotNullOp
-    : PDLInterp_PredicateOp<"is_not_null", [NoSideEffect]> {
+    : PDLInterp_PredicateOp<"is_not_null", [Pure]> {
   let summary = "Check if a positional value is non-null";
   let description = [{
     `pdl_interp.is_not_null` operations check that a positional value or range
     exists. For ranges, this does not mean that the range was simply empty. On
     success, this operation branches to the true destination. Otherwise, the
     false destination is taken.
 
     Example:
def PDLInterp_ReplaceOp : PDLInterp_Op<"replace"> {
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchAttributeOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_SwitchAttributeOp
-    : PDLInterp_SwitchOp<"switch_attribute", [NoSideEffect]> {
+    : PDLInterp_SwitchOp<"switch_attribute", [Pure]> {
   let summary = "Switch on the value of an `Attribute`";
   let description = [{
     `pdl_interp.switch_attribute` operations compare the value of a given
     attribute with a set of constant attributes. If the value matches one of the
     provided case values the destination for that case value is taken, otherwise
     the default destination is taken.
 
     Example:
def PDLInterp_SwitchAttributeOp
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchOperandCountOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_SwitchOperandCountOp
-    : PDLInterp_SwitchOp<"switch_operand_count", [NoSideEffect]> {
+    : PDLInterp_SwitchOp<"switch_operand_count", [Pure]> {
   let summary = "Switch on the operand count of an `Operation`";
   let description = [{
     `pdl_interp.switch_operand_count` operations compare the operand count of a
     given operation with a set of potential counts. If the value matches one of
     the provided case values the destination for that case value is taken,
     otherwise the default destination is taken.
 
     Example:
def PDLInterp_SwitchOperandCountOp
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchOperationNameOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_SwitchOperationNameOp
-    : PDLInterp_SwitchOp<"switch_operation_name", [NoSideEffect]> {
+    : PDLInterp_SwitchOp<"switch_operation_name", [Pure]> {
   let summary = "Switch on the OperationName of an `Operation`";
   let description = [{
     `pdl_interp.switch_operation_name` operations compare the name of a given
     operation with a set of known names. If the value matches one of the
     provided case values the destination for that case value is taken, otherwise
     the default destination is taken.
 
     Example:
def PDLInterp_SwitchOperationNameOp
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchResultCountOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_SwitchResultCountOp
-    : PDLInterp_SwitchOp<"switch_result_count", [NoSideEffect]> {
+    : PDLInterp_SwitchOp<"switch_result_count", [Pure]> {
   let summary = "Switch on the result count of an `Operation`";
   let description = [{
     `pdl_interp.switch_result_count` operations compare the result count of a
     given operation with a set of potential counts. If the value matches one of
     the provided case values the destination for that case value is taken,
     otherwise the default destination is taken.
 
     Example:
def PDLInterp_SwitchResultCountOp
   }]>];
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchTypeOp
 //===----------------------------------------------------------------------===//
 
-def PDLInterp_SwitchTypeOp : PDLInterp_SwitchOp<"switch_type", [NoSideEffect]> {
+def PDLInterp_SwitchTypeOp : PDLInterp_SwitchOp<"switch_type", [Pure]> {
   let summary = "Switch on a `Type` value";
   let description = [{
     `pdl_interp.switch_type` operations compare a type with a set of statically
     known types. If the value matches one of the provided case values the
     destination for that case value is taken, otherwise the default destination
     is taken.
 
     Example:
def PDLInterp_SwitchTypeOp : PDLInterp_SwitchOp<"switch_type", [Pure]> {
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchTypesOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_SwitchTypesOp : PDLInterp_SwitchOp<"switch_types",
-                                                 [NoSideEffect]> {
+                                                 [Pure]> {
   let summary = "Switch on a range of `Type` values";
   let description = [{
     `pdl_interp.switch_types` operations compare a range of types with a set of
     statically known ranges. If the value matches one of the provided case
     values the destination for that case value is taken, otherwise the default
     destination is taken.
 
     Example:

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

 //      quantized representation may be acceptable.
 //
 // Especially early in transformation, it is common to have pairs of
 // qcast/dcast at points where a transition to a quantized type is
 // required. In addition, it is also common to have an identity qcast
 // (where the operand and result type are not quantized) at all points where
 // it is legal to use a quantized representation (but is not known to be
 // acceptable).
-def quant_QuantizeCastOp : quant_Op<"qcast", [NoSideEffect]> {
+def quant_QuantizeCastOp : quant_Op<"qcast", [Pure]> {
   let arguments = (ins quant_RealValueType:$arg);
   let results = (outs quant_RealValueType);
 }
 
 // A DequantizeCast op (dcast) represents the inverse of a qcast,
 // converting back from a quantized to quantizable (expressed) type.
 //
 // Like qcasts, a dcast is allowed to have both its operand and result
 // as non quantized types. This facilitates transformations and marks edges
 // where the computation must be carried out in the expressed type.
 //
 // Especially early in transformation, it is common to have dcasts on
 // all operands to ops that must operate with the expressed type (typically
 // math ops prior to lowering to target-specific, quantized kernels).
-def quant_DequantizeCastOp : quant_Op<"dcast", [NoSideEffect]> {
+def quant_DequantizeCastOp : quant_Op<"dcast", [Pure]> {
   let arguments = (ins quant_RealValueType:$arg);
   let results = (outs quant_RealValueType);
 }
 
 // A StorageCast (scast) represents a cast from or to a type based on the
 // storage type and a type based on a corresponding quantized type.
 //
 // This op exists to ensure type coherency for between parts of the computation
 // which are operating directly on an underlying storage type and those which
 // operate on quantized values.
 //
 // Examples from storage to quantized type:
 //   i8 -> !quant<"uniform[i8:f32]{1.0}">
 //   tensor<4xi8> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
 //   vector<4xi8> -> vector<4x!quant<"uniform[i8:f32]{1.0}">>
-def quant_StorageCastOp : quant_Op<"scast", [NoSideEffect]> {
+def quant_StorageCastOp : quant_Op<"scast", [Pure]> {
   let arguments = (ins quant_RealOrStorageValueType:$arg);
   let results = (outs quant_RealOrStorageValueType);
   let hasFolder = 1;
 }
 
 #endif // DIALECT_QUANT_QUANT_OPS_

mlir/include/mlir/Dialect/SCF/IR/SCFOps.td

 
 //===----------------------------------------------------------------------===//
 // ConditionOp
 //===----------------------------------------------------------------------===//
 
 def ConditionOp : SCF_Op<"condition", [
   HasParent<"WhileOp">,
   DeclareOpInterfaceMethods<RegionBranchTerminatorOpInterface>,
-  NoSideEffect,
+  Pure,
   Terminator
 ]> {
   let summary = "loop continuation condition";
   let description = [{
     This operation accepts the continuation (i.e., inverse of exit) condition
     of the `scf.while` construct. If its first argument is true, the "after"
     region of `scf.while` is executed, with the remaining arguments forwarded
     to the entry block of the region. Otherwise, the loop terminates.

 //===----------------------------------------------------------------------===//
 
 def ForOp : SCF_Op<"for",
       [AutomaticAllocationScope, DeclareOpInterfaceMethods<LoopLikeOpInterface,
        ["getSingleInductionVar", "getSingleLowerBound", "getSingleStep",
         "getSingleUpperBound"]>,
        DeclareOpInterfaceMethods<RegionBranchOpInterface>,
        SingleBlockImplicitTerminator<"scf::YieldOp">,
-       RecursiveSideEffects]> {
+       RecursiveMemoryEffects]> {
   let summary = "for operation";
   let description = [{
     The "scf.for" operation represents a loop taking 3 SSA value as operands
     that represent the lower bound, upper bound and step respectively. The
     operation defines an SSA value for its induction variable. It has one
     region capturing the loop body. The induction variable is represented as an
     argument of this region. This SSA value always has type index, which is the
     size of the machine word. The step is a value of type index, required to be
OpOperand &getOpOperandForResult(OpResult opResult) {
         getNumControlOperands() + opResult.getResultNumber());
     }
 
     /// Return operands used when entering the region at 'index'. These operands
     /// correspond to the loop iterator operands, i.e., those exclusing the
     /// induction variable. LoopOp only has one region, so 0 is the only valid
     /// value for `index`.
     OperandRange getSuccessorEntryOperands(Optional<unsigned> index);
+
+    // TODO: add isPure() if there is use case for hoisting scf.for
   }];
 
   let hasCanonicalizer = 1;
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
   let hasRegionVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ForeachThreadOp
 //===----------------------------------------------------------------------===//
 
 def ForeachThreadOp : SCF_Op<"foreach_thread", [
        AttrSizedOperandSegments,
        SingleBlockImplicitTerminator<"scf::PerformConcurrentlyOp">,
-       RecursiveSideEffects,
+       RecursiveMemoryEffects,
        AutomaticAllocationScope,
       ]> {
   let summary = "evaluate a block multiple times in parallel";
   let description = [{
     `scf.foreach_thread` is a target-independent multi-dimensional parallel
     region application operation. It has exactly one block that represents the
     parallel body and it takes index operands that indicate how many parallel
     instances of that function are created.
def ForeachThreadOp : SCF_Op<"foreach_thread", [
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // PerformConcurrentlyOp
 //===----------------------------------------------------------------------===//
 
 def PerformConcurrentlyOp : SCF_Op<"foreach_thread.perform_concurrently", [
-       NoSideEffect,
+       Pure,
        Terminator,
        DeclareOpInterfaceMethods<ParallelCombiningOpInterface>,
        HasParent<"ForeachThreadOp">,
       ] # GraphRegionNoTerminator.traits> {
   let summary = "terminates a `foreach_thread` block";
   let description = [{
     `scf.foreach_thread.perform_concurrently` is a designated terminator for
     the `scf.foreach_thread` operation.

 //===----------------------------------------------------------------------===//
 // IfOp
 //===----------------------------------------------------------------------===//
 
 def IfOp : SCF_Op<"if",
       [DeclareOpInterfaceMethods<RegionBranchOpInterface,
                                  ["getNumRegionInvocations",
                                   "getRegionInvocationBounds"]>,
-       SingleBlockImplicitTerminator<"scf::YieldOp">, RecursiveSideEffects,
+       SingleBlockImplicitTerminator<"scf::YieldOp">, RecursiveMemoryEffects,
        NoRegionArguments]> {
   let summary = "if-then-else operation";
   let description = [{
     The `scf.if` operation represents an if-then-else construct for
     conditionally executing two regions of code. The operand to an if operation
     is a boolean value. For example:
 
     ```mlir

 //===----------------------------------------------------------------------===//
 // ParallelOp
 //===----------------------------------------------------------------------===//
 
 def ParallelOp : SCF_Op<"parallel",
     [AutomaticAllocationScope,
      AttrSizedOperandSegments,
      DeclareOpInterfaceMethods<LoopLikeOpInterface>,
-     RecursiveSideEffects,
+     RecursiveMemoryEffects,
      SingleBlockImplicitTerminator<"scf::YieldOp">]> {
   let summary = "parallel for operation";
   let description = [{
     The "scf.parallel" operation represents a loop nest taking 4 groups of SSA
     values as operands that represent the lower bounds, upper bounds, steps and
     initial values, respectively. The operation defines a variadic number of
     SSA values for its induction variables. It has one region capturing the
     loop body. The induction variables are represented as an argument of this
def ReduceOp : SCF_Op<"reduce", [HasParent<"ParallelOp">]> {
   let hasRegionVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ReduceReturnOp
 //===----------------------------------------------------------------------===//
 
 def ReduceReturnOp :
-    SCF_Op<"reduce.return", [HasParent<"ReduceOp">, NoSideEffect,
+    SCF_Op<"reduce.return", [HasParent<"ReduceOp">, Pure,
                               Terminator]> {
   let summary = "terminator for reduce operation";
   let description = [{
     "scf.reduce.return" is a special terminator operation for the block inside
     "scf.reduce". It terminates the region. It should have the same type as
     the operand of "scf.reduce". Example for the custom format:
 
     ```mlir
     scf.reduce.return %res : f32
     ```
   }];
 
   let arguments = (ins AnyType:$result);
   let assemblyFormat = "$result attr-dict `:` type($result)";
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // WhileOp
 //===----------------------------------------------------------------------===//
 
 def WhileOp : SCF_Op<"while",
     [DeclareOpInterfaceMethods<RegionBranchOpInterface>,
-     RecursiveSideEffects]> {
+     RecursiveMemoryEffects]> {
   let summary = "a generic 'while' loop";
   let description = [{
     This operation represents a generic "while"/"do-while" loop that keeps
     iterating as long as a condition is satisfied. There is no restriction on
     the complexity of the condition. It consists of two regions (with single
     block each): "before" region and "after" region. The names of regions
     indicates whether they execute before or after the condition check.
     Therefore, if the main loop payload is located in the "before" region, the
def WhileOp : SCF_Op<"while",
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // YieldOp
 //===----------------------------------------------------------------------===//
 
-def YieldOp : SCF_Op<"yield", [NoSideEffect, ReturnLike, Terminator,
+def YieldOp : SCF_Op<"yield", [Pure, ReturnLike, Terminator,
                                ParentOneOf<["ExecuteRegionOp, ForOp",
                                             "IfOp, ParallelOp, WhileOp"]>]> {
   let summary = "loop yield and termination operation";
   let description = [{
     "scf.yield" yields an SSA value from the SCF dialect op region and
     terminates the regions. The semantics of how the values are yielded is
     defined by the parent operation.
     If "scf.yield" has any operands, the operands must match the parent

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

 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 class SPIRV_ArithmeticBinaryOp<string mnemonic, Type type,
                                list<Trait> traits = []> :
       // Operands type same as result type.
       SPIRV_BinaryOp<mnemonic, type, type,
                    !listconcat(traits,
-                               [NoSideEffect, SameOperandsAndResultType])> {
+                               [Pure, SameOperandsAndResultType])> {
   // In addition to normal types arithmetic instructions can support cooperative
   // matrix.
   let arguments = (ins
     SPIRV_ScalarOrVectorOrCoopMatrixOf<type>:$operand1,
     SPIRV_ScalarOrVectorOrCoopMatrixOf<type>:$operand2
   );
 
   let results = (outs
     SPIRV_ScalarOrVectorOrCoopMatrixOf<type>:$result
   );
   let assemblyFormat = "operands attr-dict `:` type($result)";
 }
 
 class SPIRV_ArithmeticUnaryOp<string mnemonic, Type type,
                               list<Trait> traits = []> :
       // Operand type same as result type.
       SPIRV_UnaryOp<mnemonic, type, type,
                    !listconcat(traits,
-                               [NoSideEffect, SameOperandsAndResultType])>;
+                               [Pure, SameOperandsAndResultType])>;
 
 // -----
 
 def SPIRV_FAddOp : SPIRV_ArithmeticBinaryOp<"FAdd", SPIRV_Float, [Commutative]> {
   let summary = "Floating-point addition of Operand 1 and Operand 2.";
 
   let description = [{
     Result Type must be a scalar or vector of floating-point type.
def SPIRV_IAddOp : SPIRV_ArithmeticBinaryOp<"IAdd",
 
   let hasFolder = 1;
 }
 
 // -----
 
 def SPIRV_IAddCarryOp : SPIRV_BinaryOp<"IAddCarry",
                                    SPIRV_AnyStruct, SPIRV_Integer,
-                                   [Commutative, NoSideEffect]> {
+                                   [Commutative, Pure]> {
   let summary = [{
     Integer addition of Operand 1 and Operand 2, including the carry.
   }];
 
   let description = [{
     Result Type must be from OpTypeStruct.  The struct must have two
     members, and the two members must be the same type.  The member type
     must be a scalar or vector of integer type, whose Signedness operand is
def SPIRV_ISubOp : SPIRV_ArithmeticBinaryOp<"ISub",
   }];
 
   let hasFolder = 1;
 }
 
 // -----
 
 def SPIRV_ISubBorrowOp : SPIRV_BinaryOp<"ISubBorrow", SPIRV_AnyStruct, SPIRV_Integer,
-                                    [NoSideEffect]> {
+                                    [Pure]> {
   let summary = [{
     Result is the unsigned integer subtraction of Operand 2 from Operand 1,
     and what it needed to borrow.
   }];
 
   let description = [{
     Result Type must be from OpTypeStruct.  The struct must have two
     members, and the two members must be the same type.  The member type
let description = [{
     %5 = spirv.UDiv %2, %3 : vector<4xi32>
 
     ```
   }];
 }
 
 // -----
 
-def SPIRV_VectorTimesScalarOp : SPIRV_Op<"VectorTimesScalar", [NoSideEffect]> {
+def SPIRV_VectorTimesScalarOp : SPIRV_Op<"VectorTimesScalar", [Pure]> {
   let summary = "Scale a floating-point vector.";
 
   let description = [{
     Result Type must be a vector of floating-point type.
 
      The type of Vector must be the same as Result Type. Each component of
     Vector is multiplied by Scalar.
 

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

 
 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 class SPIRV_BitBinaryOp<string mnemonic, list<Trait> traits = []> :
       // All the operands type used in bit instructions are SPIRV_Integer.
       SPIRV_BinaryOp<mnemonic, SPIRV_Integer, SPIRV_Integer,
                    !listconcat(traits,
-                               [NoSideEffect, SameOperandsAndResultType])> {
+                               [Pure, SameOperandsAndResultType])> {
   let assemblyFormat = "operands attr-dict `:` type($result)";
 }
 
 class SPIRV_BitFieldExtractOp<string mnemonic, list<Trait> traits = []> :
       SPIRV_Op<mnemonic, !listconcat(traits,
-             [NoSideEffect, AllTypesMatch<["base", "result"]>])> {
+             [Pure, AllTypesMatch<["base", "result"]>])> {
   let arguments = (ins
     SPIRV_ScalarOrVectorOf<SPIRV_Integer>:$base,
     SPIRV_Integer:$offset,
     SPIRV_Integer:$count
   );
 
   let results = (outs
     SPIRV_ScalarOrVectorOf<SPIRV_Integer>:$result
   );
 
   let hasVerifier = 0;
 
   let assemblyFormat = [{
     operands attr-dict `:` type($base) `,` type($offset) `,` type($count)
   }];
 }
 
 class SPIRV_BitUnaryOp<string mnemonic, list<Trait> traits = []> :
       SPIRV_UnaryOp<mnemonic, SPIRV_Integer, SPIRV_Integer,
                    !listconcat(traits,
-                               [NoSideEffect, SameOperandsAndResultType])>;
+                               [Pure, SameOperandsAndResultType])>;
 
 class SPIRV_ShiftOp<string mnemonic, list<Trait> traits = []> :
       SPIRV_BinaryOp<mnemonic, SPIRV_Integer, SPIRV_Integer,
                    !listconcat(traits,
-                               [NoSideEffect, SameOperandsAndResultShape,
+                               [Pure, SameOperandsAndResultShape,
                                 AllTypesMatch<["operand1", "result"]>])> {
   let assemblyFormat = [{
     operands attr-dict `:` type($operand1) `,` type($operand2)
   }];
   let hasVerifier = 1;
 }
 
 // -----
let description = [{
     %3 = spirv.BitCount %1: vector<4xi32>
     ```
   }];
 }
 
 // -----
 
 def SPIRV_BitFieldInsertOp : SPIRV_Op<"BitFieldInsert",
-    [NoSideEffect, AllTypesMatch<["base", "insert", "result"]>]> {
+    [Pure, AllTypesMatch<["base", "insert", "result"]>]> {
   let summary = [{
     Make a copy of an object, with a modified bit field that comes from
     another object.
   }];
 
   let description = [{
      Results are computed per component.
 

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVCLOps.td

let availability = [
     Extension<[]>,
     Capability<[SPIRV_C_Kernel]>
   ];
 }
 
 // Base class for OpenCL unary ops.
 class SPIRV_CLUnaryOp<string mnemonic, int opcode, Type resultType,
                       Type operandType, list<Trait> traits = []> :
-  SPIRV_CLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
+  SPIRV_CLOp<mnemonic, opcode, !listconcat([Pure], traits)> {
 
   let arguments = (ins
     SPIRV_ScalarOrVectorOf<operandType>:$operand
   );
 
   let results = (outs
     SPIRV_ScalarOrVectorOf<resultType>:$result
   );
 
   let assemblyFormat = "$operand `:` type($operand) attr-dict";
 
   let hasVerifier = 0;
 }
 
 // Base class for OpenCL Unary arithmetic ops where return type matches
 // the operand type.
 class SPIRV_CLUnaryArithmeticOp<string mnemonic, int opcode, Type type,
                                 list<Trait> traits = []> :
   SPIRV_CLUnaryOp<mnemonic, opcode, type, type,
                  traits # [SameOperandsAndResultType]>;
 
 // Base class for OpenCL binary ops.
 class SPIRV_CLBinaryOp<string mnemonic, int opcode, Type resultType,
                        Type operandType, list<Trait> traits = []> :
-  SPIRV_CLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
+  SPIRV_CLOp<mnemonic, opcode, !listconcat([Pure], traits)> {
 
   let arguments = (ins
     SPIRV_ScalarOrVectorOf<operandType>:$lhs,
     SPIRV_ScalarOrVectorOf<operandType>:$rhs
   );
 
   let results = (outs
     SPIRV_ScalarOrVectorOf<resultType>:$result
class SPIRV_CLBinaryArithmeticOp<string mnemonic, int opcode, Type type,
   SPIRV_CLBinaryOp<mnemonic, opcode, type, type,
                   traits # [SameOperandsAndResultType]> {
   let assemblyFormat = "operands attr-dict `:` type($result)";
 }
 
 // Base class for OpenCL binary ops.
 class SPIRV_CLTernaryOp<string mnemonic, int opcode, Type resultType,
                       Type operandType, list<Trait> traits = []> :
-  SPIRV_CLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
+  SPIRV_CLOp<mnemonic, opcode, !listconcat([Pure], traits)> {
 
   let arguments = (ins
     SPIRV_ScalarOrVectorOf<operandType>:$x,
     SPIRV_ScalarOrVectorOf<operandType>:$y,
     SPIRV_ScalarOrVectorOf<operandType>:$z
   );
 
   let results = (outs

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

 
 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 class SPIRV_CastOp<string mnemonic, Type resultType, Type operandType,
                    list<Trait> traits = []> :
       SPIRV_Op<mnemonic,
              !listconcat(traits,
-                         [NoSideEffect, SameOperandsAndResultShape])> {
+                         [Pure, SameOperandsAndResultShape])> {
   let arguments = (ins
     SPIRV_ScalarOrVectorOrCoopMatrixOf<operandType>:$operand
   );
 
   let results = (outs
     SPIRV_ScalarOrVectorOrCoopMatrixOf<resultType>:$result
   );
   let assemblyFormat = [{
     $operand attr-dict `:` type($operand) `to` type($result)
   }];
 }
 
 // -----
 
-def SPIRV_BitcastOp : SPIRV_Op<"Bitcast", [NoSideEffect]> {
+def SPIRV_BitcastOp : SPIRV_Op<"Bitcast", [Pure]> {
   let summary = "Bit pattern-preserving type conversion.";
 
   let description = [{
     Result Type must be an OpTypePointer, or a scalar or vector of
     numerical-type.
 
     Operand must have a type of OpTypePointer, or a scalar or vector of
     numerical-type. It must be a different type than Result Type.
let description = [{
     ```mlir
     %1 = spirv.UConvertOp %0 : i32 to i64
     %3 = spirv.UConvertOp %2 : vector<3xi32> to vector<3xi64>
     ```
   }];
 }
 
 // -----
-def SPIRV_PtrCastToGenericOp : SPIRV_Op<"PtrCastToGeneric", [NoSideEffect]> {
+def SPIRV_PtrCastToGenericOp : SPIRV_Op<"PtrCastToGeneric", [Pure]> {
   let summary = "Convert a pointer’s Storage Class to Generic.";
 
   let description = [{
     Result Type must be an OpTypePointer. Its Storage Class must be Generic.
 
     Pointer must point to the Workgroup, CrossWorkgroup, or Function Storage
     Class.
 
def SPIRV_PtrCastToGenericOp : SPIRV_Op<"PtrCastToGeneric", [Pure]> {
 
   let assemblyFormat = [{
     $pointer attr-dict `:` type($pointer) `to` type($result)
   }];
 }
 
 // -----
 
-def SPIRV_GenericCastToPtrOp : SPIRV_Op<"GenericCastToPtr", [NoSideEffect]> {
+def SPIRV_GenericCastToPtrOp : SPIRV_Op<"GenericCastToPtr", [Pure]> {
   let summary = "Convert a pointer’s Storage Class to a non-Generic class.";
 
   let description = [{
     Result Type must be an OpTypePointer. Its Storage Class must be
     Workgroup, CrossWorkgroup, or Function.
 
     Pointer must point to the Generic Storage Class.
 
def SPIRV_GenericCastToPtrOp : SPIRV_Op<"GenericCastToPtr", [Pure]> {
 
   let assemblyFormat = [{
     $pointer attr-dict `:` type($pointer) `to` type($result)
   }];
 }
 
 // -----
 
-def SPIRV_GenericCastToPtrExplicitOp : SPIRV_Op<"GenericCastToPtrExplicit", [NoSideEffect]> {
+def SPIRV_GenericCastToPtrExplicitOp : SPIRV_Op<"GenericCastToPtrExplicit", [Pure]> {
   let summary = [{
     Attempts to explicitly convert Pointer to Storage storage-class pointer
     value.
   }];
 
   let description = [{
     Result Type must be an OpTypePointer. Its Storage Class must be Storage.
 

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

 #ifndef MLIR_DIALECT_SPIRV_IR_COMPOSITE_OPS
 #define MLIR_DIALECT_SPIRV_IR_COMPOSITE_OPS
 
 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // -----
 
-def SPIRV_CompositeConstructOp : SPIRV_Op<"CompositeConstruct", [NoSideEffect]> {
+def SPIRV_CompositeConstructOp : SPIRV_Op<"CompositeConstruct", [Pure]> {
   let summary = [{
     Construct a new composite object from a set of constituent objects.
   }];
 
   let description = [{
     Result Type must be a composite type, whose top-level
     members/elements/components/columns have the same type as the types of
     the operands, with one exception. The exception is that for constructing
def SPIRV_CompositeConstructOp : SPIRV_Op<"CompositeConstruct", [Pure]> {
   let assemblyFormat = [{
     $constituents attr-dict `:` `(` type(operands) `)` `->` type($result)
   }];
 }
 
 // -----
 
 def SPIRV_CompositeExtractOp : SPIRV_Op<"CompositeExtract",
-                                        [NoSideEffect, UsableInSpecConstantOp]> {
+                                        [Pure, UsableInSpecConstantOp]> {
   let summary = "Extract a part of a composite object.";
 
   let description = [{
     Result Type must be the type of object selected by the last provided
     index.  The instruction result is the extracted object.
 
     Composite is the composite to extract from.
 
def SPIRV_CompositeExtractOp : SPIRV_Op<"CompositeExtract",
   ];
 
   let hasFolder = 1;
 }
 
 // -----
 
 def SPIRV_CompositeInsertOp : SPIRV_Op<"CompositeInsert",
-                                       [NoSideEffect, UsableInSpecConstantOp]> {
+                                       [Pure, UsableInSpecConstantOp]> {
   let summary = [{
     Make a copy of a composite object, while modifying one part of it.
   }];
 
   let description = [{
     Result Type must be the same type as Composite.
 
     Object is the object to use as the modified part.
let builders = [
     OpBuilder<(ins "Value":$object, "Value":$composite,
                       "ArrayRef<int32_t>":$indices)>
   ];
 }
 
 // -----
 
 def SPIRV_VectorExtractDynamicOp : SPIRV_Op<"VectorExtractDynamic", [
-    NoSideEffect,
+    Pure,
     TypesMatchWith<"type of 'result' matches element type of 'vector'",
                    "vector", "result",
                    "$_self.cast<mlir::VectorType>().getElementType()">]> {
   let summary = [{
     Extract a single, dynamically selected, component of a vector.
   }];
 
   let description = [{
def SPIRV_VectorExtractDynamicOp : SPIRV_Op<"VectorExtractDynamic", [
   let assemblyFormat = [{
     $vector `[` $index `]` attr-dict `:` type($vector) `,` type($index)
   }];
 }
 
 // -----
 
 def SPIRV_VectorInsertDynamicOp : SPIRV_Op<"VectorInsertDynamic", [
-    NoSideEffect,
+    Pure,
     TypesMatchWith<
       "type of 'component' matches element type of 'vector'",
       "vector", "component",
       "$_self.cast<mlir::VectorType>().getElementType()">,
     AllTypesMatch<["vector", "result"]>]> {
   let summary = [{
     Make a copy of a vector, with a single, variably selected, component
     modified.
def SPIRV_VectorInsertDynamicOp : SPIRV_Op<"VectorInsertDynamic", [
   let assemblyFormat = [{
     $component `,` $vector `[` $index `]` attr-dict `:` type($vector) `,` type($index)
   }];
 }
 
 // -----
 
 def SPIRV_VectorShuffleOp : SPIRV_Op<"VectorShuffle", [
-    NoSideEffect, AllElementTypesMatch<["vector1", "vector2", "result"]>]> {
+    Pure, AllElementTypesMatch<["vector1", "vector2", "result"]>]> {
   let summary = [{
     Select arbitrary components from two vectors to make a new vector.
   }];
 
   let description = [{
     Result Type must be an OpTypeVector. The number of components in Result
     Type must be the same as the number of Component operands.
 

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

 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // -----
 
 def SPIRV_BranchOp : SPIRV_Op<"Branch", [
-    DeclareOpInterfaceMethods<BranchOpInterface>, InFunctionScope, NoSideEffect,
+    DeclareOpInterfaceMethods<BranchOpInterface>, InFunctionScope, Pure,
     Terminator]> {
   let summary = "Unconditional branch to target block.";
 
   let description = [{
     This instruction must be the last instruction in a block.
 
     <!-- End of AutoGen section -->
 
let assemblyFormat = [{
     $target (`(` $targetOperands^ `:` type($targetOperands) `)`)? attr-dict
   }];
 }
 
 // -----
 
 def SPIRV_BranchConditionalOp : SPIRV_Op<"BranchConditional", [
     AttrSizedOperandSegments, DeclareOpInterfaceMethods<BranchOpInterface>,
-    InFunctionScope, NoSideEffect, Terminator]> {
+    InFunctionScope, Pure, Terminator]> {
   let summary = [{
     If Condition is true, branch to true block, otherwise branch to false
     block.
   }];
 
   let description = [{
     Condition must be a Boolean type scalar.
 
def SPIRV_LoopOp : SPIRV_Op<"mlir.loop", [InFunctionScope]> {
   let autogenSerialization = 0;
 
   let hasVerifier = 0;
   let hasRegionVerifier = 1;
 }
 
 // -----
 
-def SPIRV_MergeOp : SPIRV_Op<"mlir.merge", [NoSideEffect, Terminator]> {
+def SPIRV_MergeOp : SPIRV_Op<"mlir.merge", [Pure, Terminator]> {
   let summary = "A special terminator for merging a structured selection/loop.";
 
   let description = [{
     We use `spirv.mlir.selection`/`spirv.mlir.loop` for modelling structured selection/loop.
     This op is a terminator used inside their regions to mean jumping to the
     merge point, which is the next op following the `spirv.mlir.selection` or
     `spirv.mlir.loop` op. This op does not have a corresponding instruction in the
     SPIR-V binary format; it's solely for structural purpose.
   }];
 
   let arguments = (ins);
 
   let results = (outs);
 
   let assemblyFormat = "attr-dict";
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 }
 
 // -----
 
-def SPIRV_ReturnOp : SPIRV_Op<"Return", [InFunctionScope, NoSideEffect,
+def SPIRV_ReturnOp : SPIRV_Op<"Return", [InFunctionScope, Pure,
                                      Terminator]> {
   let summary = "Return with no value from a function with void return type.";
 
   let description = [{
     This instruction must be the last instruction in a block.
 
     <!-- End of AutoGen section -->
 
def SPIRV_UnreachableOp : SPIRV_Op<"Unreachable", [InFunctionScope, Terminator]> {
 
   let results = (outs);
 
   let assemblyFormat = "attr-dict";
 }
 
 // -----
 
-def SPIRV_ReturnValueOp : SPIRV_Op<"ReturnValue", [InFunctionScope, NoSideEffect,
+def SPIRV_ReturnValueOp : SPIRV_Op<"ReturnValue", [InFunctionScope, Pure,
                                                Terminator]> {
   let summary = "Return a value from a function.";
 
   let description = [{
     Value is the value returned, by copy, and must match the Return Type
     operand of the OpTypeFunction type of the OpFunction body this return
     instruction is in.
 

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVCooperativeMatrixOps.td

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_IR_COOPERATIVE_MATRIX_OPS
 #define MLIR_DIALECT_SPIRV_IR_COOPERATIVE_MATRIX_OPS
 
 // -----
 
 def SPIRV_NVCooperativeMatrixLengthOp : SPIRV_NvVendorOp<"CooperativeMatrixLength",
-  [NoSideEffect]> {
+  [Pure]> {
   let summary = "See extension SPV_NV_cooperative_matrix";
 
   let description = [{
     Number of components of a cooperative matrix type accessible to each
     invocation when treated as a composite.
 
     Result Type must be an OpTypeInt with 32-bit Width and 0 Signedness.
 
def SPIRV_NVCooperativeMatrixLoadOp : SPIRV_NvVendorOp<"CooperativeMatrixLoad", []> {
   let results = (outs
     SPIRV_AnyCooperativeMatrix:$result
   );
 }
 
 // -----
 
 def SPIRV_NVCooperativeMatrixMulAddOp : SPIRV_NvVendorOp<"CooperativeMatrixMulAdd",
-  [NoSideEffect, AllTypesMatch<["c", "result"]>]> {
+  [Pure, AllTypesMatch<["c", "result"]>]> {
   let summary = "See extension SPV_NV_cooperative_matrix";
 
   let description = [{
     Linear-algebraic matrix multiply of A by B and then component-wise add C.
     The order of the operations is implementation-dependent. The internal
     precision of floating-point operations is defined by the client API.
     Integer operations are performed at the precision of the Result Type and are
     exact unless there is overflow or underflow, in which case the result is

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVGLOps.td

let availability = [
     Extension<[]>,
     Capability<[SPIRV_C_Shader]>
   ];
 }
 
 // Base class for GL unary ops.
 class SPIRV_GLUnaryOp<string mnemonic, int opcode, Type resultType,
                       Type operandType, list<Trait> traits = []> :
-  SPIRV_GLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
+  SPIRV_GLOp<mnemonic, opcode, !listconcat([Pure], traits)> {
 
   let arguments = (ins
     SPIRV_ScalarOrVectorOf<operandType>:$operand
   );
 
   let results = (outs
     SPIRV_ScalarOrVectorOf<resultType>:$result
   );
 
   let hasVerifier = 0;
 }
 
 // Base class for GL Unary arithmetic ops where return type matches
 // the operand type.
 class SPIRV_GLUnaryArithmeticOp<string mnemonic, int opcode, Type type,
                                 list<Trait> traits = []> :
   SPIRV_GLUnaryOp<mnemonic, opcode, type, type,
                   traits # [SameOperandsAndResultType]> {
   let assemblyFormat = "$operand `:` type($operand) attr-dict";
 }
 
 // Base class for GL binary ops.
 class SPIRV_GLBinaryOp<string mnemonic, int opcode, Type resultType,
                         Type operandType, list<Trait> traits = []> :
-  SPIRV_GLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
+  SPIRV_GLOp<mnemonic, opcode, !listconcat([Pure], traits)> {
 
   let arguments = (ins
     SPIRV_ScalarOrVectorOf<operandType>:$lhs,
     SPIRV_ScalarOrVectorOf<operandType>:$rhs
   );
 
   let results = (outs
     SPIRV_ScalarOrVectorOf<resultType>:$result
class SPIRV_GLBinaryArithmeticOp<string mnemonic, int opcode, Type type,
   SPIRV_GLBinaryOp<mnemonic, opcode, type, type,
                    traits # [SameOperandsAndResultType]> {
   let assemblyFormat = "operands attr-dict `:` type($result)";
 }
 
 // Base class for GL ternary ops.
 class SPIRV_GLTernaryArithmeticOp<string mnemonic, int opcode, Type type,
                         list<Trait> traits = []> :
-  SPIRV_GLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
+  SPIRV_GLOp<mnemonic, opcode, !listconcat([Pure], traits)> {
 
   let arguments = (ins
     SPIRV_ScalarOrVectorOf<type>:$x,
     SPIRV_ScalarOrVectorOf<type>:$y,
     SPIRV_ScalarOrVectorOf<type>:$z
   );
 
   let results = (outs
let description = [{
     %0 = spirv.GL.Fma %a, %b, %c : f32
     %1 = spirv.GL.Fma %a, %b, %c : vector<3xf16>
     ```
   }];
 }
 
 // ----
 
-def SPIRV_GLFrexpStructOp : SPIRV_GLOp<"FrexpStruct", 52, [NoSideEffect]> {
+def SPIRV_GLFrexpStructOp : SPIRV_GLOp<"FrexpStruct", 52, [Pure]> {
   let summary = "Splits x into two components such that x = significand * 2^exponent";
 
   let description = [{
     Result is a structure containing x split into a floating-point significand
     in the range (-1.0, 0.5] or [0.5, 1.0) and an integral exponent of 2, such that:
 
     x = significand * 2^exponent
 
def SPIRV_GLFrexpStructOp : SPIRV_GLOp<"FrexpStruct", 52, [Pure]> {
 
   let assemblyFormat = [{
     attr-dict $operand `:` type($operand) `->` type($result)
   }];
 }
 
 def SPIRV_GLLdexpOp :
   SPIRV_GLOp<"Ldexp", 53, [
-      NoSideEffect, AllTypesMatch<["x", "y"]>]> {
+      Pure, AllTypesMatch<["x", "y"]>]> {
   let summary = "Builds y such that y = significand * 2^exponent";
 
   let description = [{
     Builds a floating-point number from x and the corresponding
     integral exponent of two in exp:
 
     significand * 2^exponent
 
def SPIRV_GLLdexpOp :
 
   let assemblyFormat = [{
     attr-dict $x `:` type($x) `,` $exp `:` type($exp) `->` type($y)
   }];
 }
 
 def SPIRV_GLFMixOp :
   SPIRV_GLOp<"FMix", 46, [
-      NoSideEffect, AllTypesMatch<["x", "y", "a", "result"]>]> {
+      Pure, AllTypesMatch<["x", "y", "a", "result"]>]> {
   let summary = "Builds the linear blend of x and y";
 
   let description = [{
     Result is the linear blend of x and y, i.e., x * (1 - a) + y * a.
 
     The operands must all be a scalar or vector whose component type is floating-point.
 
     Result Type and the type of all operands must be the same type. Results are computed per component.

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVGroupOps.td

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_IR_GROUP_OPS
 #define MLIR_DIALECT_SPIRV_IR_GROUP_OPS
 
 // -----
 
 def SPIRV_GroupBroadcastOp : SPIRV_Op<"GroupBroadcast",
-                              [NoSideEffect,
+                              [Pure,
                                AllTypesMatch<["value", "result"]>]> {
   let summary = [{
     Broadcast the Value of the invocation identified by the local id LocalId
     to the result of all invocations in the group.
   }];
 
   let description = [{
     All invocations of this module within Execution must reach this point of

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVImageOps.td

 #ifndef MLIR_DIALECT_SPIRV_IR_IMAGE_OPS
 #define MLIR_DIALECT_SPIRV_IR_IMAGE_OPS
 
 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // -----
 
-def SPIRV_ImageDrefGatherOp : SPIRV_Op<"ImageDrefGather", [NoSideEffect]> {
+def SPIRV_ImageDrefGatherOp : SPIRV_Op<"ImageDrefGather", [Pure]> {
   let summary = "Gathers the requested depth-comparison from four texels.";
 
   let description = [{
     Result Type must be a vector of four components of floating-point type
     or integer type.  Its components must be the same as Sampled Type of the
     underlying OpTypeImage (unless that underlying Sampled Type is
     OpTypeVoid). It has one component per gathered texel.
 
let assemblyFormat = [{$sampledimage `:` type($sampledimage) `,`
                          custom<ImageOperands>($imageoperands)
                          ( `(` $operand_arguments^ `:` type($operand_arguments) `)`)?
                          attr-dict
                          `->` type($result)}];
 }
 
 // -----
 
-def SPIRV_ImageQuerySizeOp : SPIRV_Op<"ImageQuerySize", [NoSideEffect]> {
+def SPIRV_ImageQuerySizeOp : SPIRV_Op<"ImageQuerySize", [Pure]> {
   let summary = "Query the dimensions of Image, with no level of detail.";
 
   let description = [{
     Result Type must be an integer type scalar or vector.  The number of
     components must be:
 
     1 for the 1D and Buffer dimensionalities,
 
def SPIRV_ImageQuerySizeOp : SPIRV_Op<"ImageQuerySize", [Pure]> {
   );
 
   let assemblyFormat = "attr-dict $image `:` type($image) `->` type($result)";
 }
 
 // -----
 
 def SPIRV_ImageOp : SPIRV_Op<"Image",
-    [NoSideEffect,
+    [Pure,
      TypesMatchWith<"type of 'result' matches image type of 'sampledimage'",
                     "sampledimage", "result",
                     "$_self.cast<spirv::SampledImageType>().getImageType()">]> {
   let summary = "Extract the image from a sampled image.";
 
   let description = [{
     Result Type must be OpTypeImage.
 

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVJointMatrixOps.td

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_IR_JOINT_MATRIX_OPS
 #define MLIR_DIALECT_SPIRV_IR_JOINT_MATRIX_OPS
 
 // -----
 
 def SPIRV_INTELJointMatrixWorkItemLengthOp : SPIRV_IntelVendorOp<"JointMatrixWorkItemLength",
-  [NoSideEffect]> {
+  [Pure]> {
   let summary = "See extension SPV_INTEL_joint_matrix";
 
   let description = [{
     Return number of components owned by the current work-item in
     a joint matrix.
 
     Result Type must be an 32-bit unsigned integer type scalar.
 
def SPIRV_INTELJointMatrixLoadOp : SPIRV_IntelVendorOp<"JointMatrixLoad", []> {
   let results = (outs
     SPIRV_AnyJointMatrix:$result
   );
 }
 
 // -----
 
 def SPIRV_INTELJointMatrixMadOp : SPIRV_IntelVendorOp<"JointMatrixMad",
-  [NoSideEffect, AllTypesMatch<["c", "result"]>]> {
+  [Pure, AllTypesMatch<["c", "result"]>]> {
   let summary = "See extension SPV_INTEL_joint_matrix";
 
   let description = [{
     Multiply matrix A by matrix B and add matrix C to the result
     of the multiplication: A*B+C. Here A is a M x K matrix, B is
     a K x N matrix and C is a M x N matrix.
 
     Behavior is undefined if sizes of operands do not meet the

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

 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 class SPIRV_LogicalBinaryOp<string mnemonic, Type operandsType,
                             list<Trait> traits = []> :
       // Result type is SPIRV_Bool.
       SPIRV_BinaryOp<mnemonic, SPIRV_Bool, operandsType,
                    !listconcat(traits, [
-                     NoSideEffect, SameTypeOperands,
+                     Pure, SameTypeOperands,
                      SameOperandsAndResultShape,
                      TypesMatchWith<"type of result to correspond to the `i1` "
                                     "equivalent of the operand",
                                     "operand1", "result",
                                     "getUnaryOpResultType($_self)"
                      >])> {
   let assemblyFormat = "$operand1 `,` $operand2 `:` type($operand1) attr-dict";
 
   let builders = [
     OpBuilder<(ins "Value":$lhs, "Value":$rhs),
     [{::buildLogicalBinaryOp($_builder, $_state, lhs, rhs);}]>
   ];
 }
 
 class SPIRV_LogicalUnaryOp<string mnemonic, Type operandType,
                          list<Trait> traits = []> :
       // Result type is SPIRV_Bool.
       SPIRV_UnaryOp<mnemonic, SPIRV_Bool, operandType,
                   !listconcat(traits, [
-                     NoSideEffect, SameTypeOperands, SameOperandsAndResultShape,
+                     Pure, SameTypeOperands, SameOperandsAndResultShape,
                      TypesMatchWith<"type of result to correspond to the `i1` "
                                     "equivalent of the operand",
                                     "operand", "result",
                                     "getUnaryOpResultType($_self)"
                      >])> {
   let assemblyFormat = "$operand `:` type($operand) attr-dict";
 
   let builders = [
let description = [{
 
     ```
   }];
 }
 
 // -----
 
 def SPIRV_SelectOp : SPIRV_Op<"Select",
-    [NoSideEffect,
+    [Pure,
      AllTypesMatch<["true_value", "false_value", "result"]>,
      UsableInSpecConstantOp]> {
   let summary = [{
     Select between two objects. Before version 1.4, results are only
     computed per component.
   }];
 
   let description = [{

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVMatrixOps.td

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_IR_MATRIX_OPS
 #define MLIR_DIALECT_SPIRV_IR_MATRIX_OPS
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // -----
 
-def SPIRV_MatrixTimesMatrixOp : SPIRV_Op<"MatrixTimesMatrix", [NoSideEffect]> {
+def SPIRV_MatrixTimesMatrixOp : SPIRV_Op<"MatrixTimesMatrix", [Pure]> {
   let summary = "Linear-algebraic multiply of LeftMatrix X RightMatrix.";
 
   let description = [{
     Result Type must be an OpTypeMatrix whose Column Type is a vector of
     floating-point type.
 
     LeftMatrix must be a matrix whose Column Type is the same as the Column
     Type in Result Type.
def SPIRV_MatrixTimesMatrixOp : SPIRV_Op<"MatrixTimesMatrix", [Pure]> {
 
   let assemblyFormat = [{
     operands attr-dict `:` type($leftmatrix) `,` type($rightmatrix) `->` type($result)
   }];
 }
 
 // -----
 
-def SPIRV_MatrixTimesScalarOp : SPIRV_Op<"MatrixTimesScalar", [NoSideEffect]> {
+def SPIRV_MatrixTimesScalarOp : SPIRV_Op<"MatrixTimesScalar", [Pure]> {
   let summary = "Scale a floating-point matrix.";
 
   let description = [{
     Result Type must be an OpTypeMatrix whose Column Type is a vector of
     floating-point type.
 
      The type of Matrix must be the same as Result Type. Each component in
     each column in Matrix is multiplied by Scalar.
let availability = [
     MaxVersion<SPIRV_V_1_6>,
     Extension<[]>,
     Capability<[SPIRV_C_Matrix]>
   ];
 }
 
 // -----
 
-def SPIRV_TransposeOp : SPIRV_Op<"Transpose", [NoSideEffect]> {
+def SPIRV_TransposeOp : SPIRV_Op<"Transpose", [Pure]> {
   let summary = "Transpose a matrix.";
 
   let description = [{
     Result Type must be an OpTypeMatrix.
 
     Matrix must be an object of type OpTypeMatrix. The number of columns and
     the column size of Matrix must be the reverse of those in Result Type.
     The types of the scalar components in Matrix and Result Type must be the

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVMemoryOps.td

 
 #ifndef MLIR_DIALECT_SPIRV_IR_MEMORY_OPS
 #define MLIR_DIALECT_SPIRV_IR_MEMORY_OPS
 
 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 
 // -----
 
-def SPIRV_AccessChainOp : SPIRV_Op<"AccessChain", [NoSideEffect]> {
+def SPIRV_AccessChainOp : SPIRV_Op<"AccessChain", [Pure]> {
   let summary = "Create a pointer into a composite object.";
 
   let description = [{
     Result Type must be an OpTypePointer. Its Type operand must be the type
     reached by walking the Base’s type hierarchy down to the last provided
     index in Indexes, and its Storage Class operand must be the same as the
     Storage Class of Base.
 
def SPIRV_CopyMemoryOp : SPIRV_Op<"CopyMemory", []> {
 
   let results = (outs);
 
   let autogenSerialization = 0;
 }
 
 // -----
 
-def SPIRV_InBoundsPtrAccessChainOp : SPIRV_Op<"InBoundsPtrAccessChain", [NoSideEffect]> {
+def SPIRV_InBoundsPtrAccessChainOp : SPIRV_Op<"InBoundsPtrAccessChain", [Pure]> {
   let summary = [{
     Has the same semantics as OpPtrAccessChain, with the addition that the
     resulting pointer is known to point within the base object.
   }];
 
   let description = [{
 
 
let builders = [
     OpBuilder<(ins "Value":$basePtr,
       CArg<"MemoryAccessAttr", "{}">:$memory_access,
       CArg<"IntegerAttr", "{}">:$alignment)>
   ];
 }
 
 // -----
 
-def SPIRV_PtrAccessChainOp : SPIRV_Op<"PtrAccessChain", [NoSideEffect]> {
+def SPIRV_PtrAccessChainOp : SPIRV_Op<"PtrAccessChain", [Pure]> {
   let summary = [{
     Has the same semantics as OpAccessChain, with the addition of the
     Element operand.
   }];
 
   let description = [{
     Element is used to do an initial dereference of Base: Base is treated as
     the address of an element in an array, and a new element address is

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVMiscOps.td

def SPIRV_KHRAssumeTrueOp : SPIRV_KhrVendorOp<"AssumeTrue", []> {
   let results = (outs);
 
   let hasVerifier = 0;
   let assemblyFormat = "$condition attr-dict";
 }
 
 // -----
 
-def SPIRV_UndefOp : SPIRV_Op<"Undef", [NoSideEffect]> {
+def SPIRV_UndefOp : SPIRV_Op<"Undef", [Pure]> {
   let summary = "Make an intermediate object whose value is undefined.";
 
   let description = [{
     Result Type is the type of object to make.
 
     Each consumption of Result <id> yields an arbitrary, possibly different
     bit pattern or abstract value resulting in possibly different concrete,
     abstract, or opaque values.

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVNonUniformOps.td

def SPIRV_GroupNonUniformBallotOp : SPIRV_Op<"GroupNonUniformBallot", []> {
   let assemblyFormat = [{
     $execution_scope $predicate attr-dict `:` type($result)
   }];
 }
 
 // -----
 
 def SPIRV_GroupNonUniformBroadcastOp : SPIRV_Op<"GroupNonUniformBroadcast",
-  [NoSideEffect, AllTypesMatch<["value", "result"]>]> {
+  [Pure, AllTypesMatch<["value", "result"]>]> {
   let summary = [{
     Result is the Value of the invocation identified by the id Id to all
     active invocations in the group.
   }];
 
   let description = [{
     Result Type  must be a scalar or vector of floating-point type, integer
     type, or Boolean type.
let availability = [
     Extension<[]>,
     Capability<[SPIRV_C_GroupNonUniformArithmetic, SPIRV_C_GroupNonUniformClustered, SPIRV_C_GroupNonUniformPartitionedNV]>
   ];
 }
 
 // -----
 
 def SPIRV_GroupNonUniformShuffleOp : SPIRV_Op<"GroupNonUniformShuffle",
-    [NoSideEffect, AllTypesMatch<["value", "result"]>]> {
+    [Pure, AllTypesMatch<["value", "result"]>]> {
   let summary = [{
     Result is the Value of the invocation identified by the id Id.
   }];
 
   let description = [{
     Result Type  must be a scalar or vector of floating-point type, integer
     type, or Boolean type.
 
def SPIRV_GroupNonUniformShuffleOp : SPIRV_Op<"GroupNonUniformShuffle",
   let assemblyFormat = [{
     $execution_scope operands attr-dict `:` type($value) `,` type($id)
   }];
 }
 
 // -----
 
 def SPIRV_GroupNonUniformShuffleDownOp : SPIRV_Op<"GroupNonUniformShuffleDown",
-    [NoSideEffect, AllTypesMatch<["value", "result"]>]> {
+    [Pure, AllTypesMatch<["value", "result"]>]> {
   let summary = [{
     Result is the Value of the invocation identified by the current
     invocation’s id within the group + Delta.
   }];
 
   let description = [{
     Result Type  must be a scalar or vector of floating-point type, integer
     type, or Boolean type.
def SPIRV_GroupNonUniformShuffleDownOp : SPIRV_Op<"GroupNonUniformShuffleDown",
   let assemblyFormat = [{
     $execution_scope operands attr-dict `:` type($value) `,` type($delta)
   }];
 }
 
 // -----
 
 def SPIRV_GroupNonUniformShuffleUpOp : SPIRV_Op<"GroupNonUniformShuffleUp",
-    [NoSideEffect, AllTypesMatch<["value", "result"]>]> {
+    [Pure, AllTypesMatch<["value", "result"]>]> {
   let summary = [{
     Result is the Value of the invocation identified by the current
     invocation’s id within the group - Delta.
   }];
 
   let description = [{
     Result Type  must be a scalar or vector of floating-point type, integer
     type, or Boolean type.
def SPIRV_GroupNonUniformShuffleUpOp : SPIRV_Op<"GroupNonUniformShuffleUp",
   let assemblyFormat = [{
     $execution_scope operands attr-dict `:` type($value) `,` type($delta)
   }];
 }
 
 // -----
 
 def SPIRV_GroupNonUniformShuffleXorOp : SPIRV_Op<"GroupNonUniformShuffleXor",
-    [NoSideEffect, AllTypesMatch<["value", "result"]>]> {
+    [Pure, AllTypesMatch<["value", "result"]>]> {
   let summary = [{
     Result is the Value of the invocation identified by the current
     invocation’s id within the group xor’ed with Mask.
   }];
 
   let description = [{
     Result Type  must be a scalar or vector of floating-point type, integer
     type, or Boolean type.

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

 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // -----
 
 def SPIRV_AddressOfOp : SPIRV_Op<"mlir.addressof",
     [DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-     InFunctionScope, NoSideEffect]> {
+     InFunctionScope, Pure]> {
   let summary = "Get the address of a global variable.";
 
   let description = [{
     Variables in module scope are defined using symbol names. This op generates
     an SSA value that can be used to refer to the symbol within function scope
     for use in ops that expect an SSA value. This operation has no corresponding
     SPIR-V instruction; it's merely used for modelling purpose in the SPIR-V
     dialect. Since variables in module scope in SPIR-V dialect are of pointer
def SPIRV_AddressOfOp : SPIRV_Op<"mlir.addressof",
   let assemblyFormat = "$variable attr-dict `:` type($pointer)";
 }
 
 // -----
 
 def SPIRV_ConstantOp : SPIRV_Op<"Constant",
     [ConstantLike,
      DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-     NoSideEffect]> {
+     Pure]> {
   let summary = [{
     Declare a new integer-type or floating-point-type scalar constant.
   }];
 
   let description = [{
     This op declares a SPIR-V normal constant. SPIR-V has multiple constant
     instructions covering different constant types:
 
def SPIRV_ModuleOp : SPIRV_Op<"module",
   }];
 
   let hasVerifier = 0;
   let hasRegionVerifier = 1;
 }
 
 // -----
 
-def SPIRV_ReferenceOfOp : SPIRV_Op<"mlir.referenceof", [NoSideEffect]> {
+def SPIRV_ReferenceOfOp : SPIRV_Op<"mlir.referenceof", [Pure]> {
   let summary = "Reference a specialization constant.";
 
   let description = [{
     Specialization constants in module scope are defined using symbol names.
     This op generates an SSA value that can be used to refer to the symbol
     within function scope for use in ops that expect an SSA value.
     This operation has no corresponding SPIR-V instruction; it's merely used
     for modelling purpose in the SPIR-V dialect. This op's return type is
def SPIRV_SpecConstantCompositeOp : SPIRV_Op<"SpecConstantComposite", [
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 }
 
 // -----
 
 def SPIRV_SpecConstantOperationOp : SPIRV_Op<"SpecConstantOperation", [
-       NoSideEffect, InFunctionScope,
+       Pure, InFunctionScope,
        SingleBlockImplicitTerminator<"YieldOp">]> {
   let summary = [{
     Declare a new specialization constant that results from doing an operation.
   }];
 
   let description = [{
     This op declares a SPIR-V specialization constant that results from
     doing an operation on other constants (specialization or otherwise).
def SPIRV_SpecConstantOperationOp : SPIRV_Op<"SpecConstantOperation", [
 
   let hasVerifier = 0;
   let hasRegionVerifier = 1;
 }
 
 // -----
 
 def SPIRV_YieldOp : SPIRV_Op<"mlir.yield", [
-    HasParent<"SpecConstantOperationOp">, NoSideEffect, Terminator]> {
+    HasParent<"SpecConstantOperationOp">, Pure, Terminator]> {
   let summary = [{
     Yields the result computed in `spirv.SpecConstantOperation`'s
     region back to the parent op.
   }];
 
   let description = [{
     This op is a special terminator whose only purpose is to terminate
     an `spirv.SpecConstantOperation`'s enclosed region. It accepts a

mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td

 // Shape op definitions
 //===----------------------------------------------------------------------===//
 
 // Base class for the operation in this dialect
 class Shape_Op<string mnemonic, list<Trait> traits = []> :
     Op<ShapeDialect, mnemonic, traits>;
 
 def Shape_AddOp : Shape_Op<"add",
-    [Commutative, NoSideEffect,
+    [Commutative, Pure,
      DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let summary = "Addition of sizes and indices";
   let description = [{
     Adds two sizes or indices. If either operand is an error it will be
     propagated to the result. The operands can be of type `size` or `index`. If
     at least one of the operands can hold an error, i.e. if it is of type `size`,
     the result must be of type `size`. If error propagation is not possible
     because both operands are of type `index` then the result may be of type
let extraClassDeclaration = [{
     // InferTypeOpInterface
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
-def Shape_BroadcastOp : Shape_Op<"broadcast", [Commutative, NoSideEffect]> {
+def Shape_BroadcastOp : Shape_Op<"broadcast", [Commutative, Pure]> {
   let summary = "Returns the broadcasted output shape of two or more inputs";
   let description = [{
     Returns the broadcasted shape for input shapes or extent tensors. The rest
     of this description is simplified for the 2 input case but can be extended
     to more inputs. Both operands can be of type `shape.shape` or
     `tensor<?xindex>`. The result is of type `shape.shape` and, if both
     operands are tensors, may be of type `tensor<?xindex>`.
 
def Shape_BroadcastOp : Shape_Op<"broadcast", [Commutative, Pure]> {
   ];
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
 }
 
 def Shape_ConstShapeOp : Shape_Op<"const_shape",
-    [ConstantLike, NoSideEffect, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [ConstantLike, Pure, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let summary = "Creates a constant shape or extent tensor";
   let description = [{
     Creates a constant shape or extent tensor. The individual extents are given
     as the `shape` attribute. The number of these values equals the shape's
     rank.
 
     ```mlir
     %0 = shape.const_shape [] : !shape.shape
def Shape_ConstShapeOp : Shape_Op<"const_shape",
   let extraClassDeclaration = [{
     // InferTypeOpInterface:
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 }
 
 def Shape_ConstSizeOp : Shape_Op<"const_size", [
     ConstantLike,
-    NoSideEffect,
+    Pure,
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>
   ]> {
   let summary = "Creates a constant of type `shape.size`";
   let description = [{
     Creates a `shape.size` type representing the constant size given by `value`.
 
     ```mlir
     %x = shape.const_size 10
     ```
   }];
 
   let arguments = (ins IndexAttr:$value);
   let results = (outs Shape_SizeType:$result);
 
   let builders = [OpBuilder<(ins "int64_t":$value)>];
 
   let assemblyFormat = "$value attr-dict";
   let hasFolder = 1;
 }
 
-def Shape_DivOp : Shape_Op<"div", [NoSideEffect,
+def Shape_DivOp : Shape_Op<"div", [Pure,
                            DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let summary = "Division of sizes and indices";
   let description = [{
     Divides two sizes or indices. If either operand is an error it will be
     propagated to the result. The operands can be of type `size` or `index`.
     If at least one of the operands can hold an error, i.e. if it is of type
     `size`, the result must be of type `size`. If error propagation is not
     possible because both operands are of type `index` then the result may be
def Shape_DivOp : Shape_Op<"div", [Pure,
 
   let extraClassDeclaration = [{
     // Returns when two result types are compatible for this op; method used by
     // InferTypeOpInterface
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 }
 
-def Shape_ShapeEqOp : Shape_Op<"shape_eq", [NoSideEffect, Commutative]> {
+def Shape_ShapeEqOp : Shape_Op<"shape_eq", [Pure, Commutative]> {
   let summary = "Returns whether the input shapes or extent tensors are equal";
   let description = [{
     Takes one or more shape or extent tensor operands and determines whether
     they are equal. When extent tensors are compared to shapes they are regarded
     as their equivalent non-error shapes. Error shapes can be tested for
     equality like any other shape value, meaning that the error value is equal
     to itself.
   }];
 
   let arguments = (ins Variadic<Shape_ShapeOrExtentTensorType>:$shapes);
   let results = (outs I1:$result);
 
   // Convenience builder alias for the binary version.
   let builders = [
   OpBuilder<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs),
     [{ build($_builder, $_state, ::llvm::makeArrayRef({lhs, rhs})); }]>,
   ];
 
   let assemblyFormat = "$shapes attr-dict `:` type($shapes)";
   let hasFolder = 1;
 }
 
-def Shape_FromExtentsOp : Shape_Op<"from_extents", [NoSideEffect]> {
+def Shape_FromExtentsOp : Shape_Op<"from_extents", [Pure]> {
   let summary = "Creates a shape from extents";
   let description = [{
     Creates a shape from multiple SSA values representing the extents of
     the shape.
 
     ```mlir
     // Rank 2 shape.
     %s0 = shape.from_extents %a, %b
     // Rank 0 shape.
     %s1 = shape.from_extents
     ```
   }];
   let arguments = (ins Variadic<Shape_SizeOrIndexType>:$extents);
   let results = (outs Shape_ShapeType:$shape);
 
   let assemblyFormat = "$extents attr-dict `:` type($extents)";
 
   let hasFolder = 1;
 }
 
-def Shape_FromExtentTensorOp : Shape_Op<"from_extent_tensor", [NoSideEffect]> {
+def Shape_FromExtentTensorOp : Shape_Op<"from_extent_tensor", [Pure]> {
   let summary = "Creates a shape from a tensor of extents";
   let description = [{
     Creates a shape from a 1D integral tensor of extents. The rank of the
     resulting shape equals the number of elements in the tensor, and the
     extents match the values of the elements.
   }];
 
   let arguments = (ins 1DTensorOf<[Index]>:$input);
def Shape_IsBroadcastableOp : Shape_Op<"is_broadcastable", [Commutative]> {
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
 
   let assemblyFormat = "$shapes attr-dict `:` type($shapes)";
 }
 
 def Shape_RankOp : Shape_Op<"rank",
-    [NoSideEffect, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let summary = "Gets the rank of a shape";
   let description = [{
     Returns the rank of the shape or extent tensor, i.e. the number of extents.
   }];
 
   let arguments = (ins Shape_ShapeOrExtentTensorType:$shape);
   let results = (outs Shape_SizeOrIndexType:$rank);
 
   let assemblyFormat = "$shape attr-dict `:` type($shape) `->` type($rank)";
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     // Returns when two result types are compatible for this op; method used by
     // InferTypeOpInterface
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 }
 
 def Shape_ToExtentTensorOp : Shape_Op<"to_extent_tensor", [
-    DeclareOpInterfaceMethods<CastOpInterface>, NoSideEffect
+    DeclareOpInterfaceMethods<CastOpInterface>, Pure
   ]> {
   let summary = "Creates a dimension tensor from a shape";
   let description = [{
     Converts a shape to a 1D integral tensor of extents. The number of elements
     in the tensor equals the rank of the shape, and the elements equal the
     extents of the shape.
 
     If the shape represents an error, this op's behavior is undefined.
   }];
 
   let arguments = (ins Shape_ShapeOrExtentTensorType:$input);
   let results = (outs IndexTensor:$result);
 
   let assemblyFormat = "$input attr-dict `:` type($input) `->` type($result)";
 
   let hasFolder = 1;
 }
 
 def Shape_DimOp : Shape_Op<"dim",
-    [NoSideEffect, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let summary = "Gets the specified extent from the shape of a shaped input";
   let description = [{
     Gets the extent indexed by `dim` from the shape of the `value` operand. If
     the index is error or out-of-bound then it returns an invalid size if the
     return type carries error information else the behavior is undefined.
 
     This is a convenience op that performs the equivalent of getting the extent
     of a shape (e.g., `dim(x, i) == get_extent(shape_of(x), i)`).
let extraClassDeclaration = [{
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
 def Shape_GetExtentOp : Shape_Op<"get_extent",
-    [NoSideEffect, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let summary = "Gets the specified extent from a shape or extent tensor";
   let description = [{
     Gets the extent indexed by `dim` from the `shape` operand. If the shape is
     an error then it returns an invalid size.
   }];
   let arguments = (ins Shape_ShapeOrExtentTensorType:$shape,
                        Shape_SizeOrIndexType:$dim);
   let results = (outs Shape_SizeOrIndexType:$extent);
let extraClassDeclaration = [{
     /// InferTypeOpInterface
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
-def Shape_IndexToSizeOp : Shape_Op<"index_to_size", [NoSideEffect]> {
+def Shape_IndexToSizeOp : Shape_Op<"index_to_size", [Pure]> {
   let summary = "Converts a standard index to a shape size";
   let description = [{
     Converts a standard index to a `shape.size`. This operation and its
     inverse, `size_to_index`, facilitate index conversion between the standard
     and the shape dialect.
 
     The behavior is undefined for negative indices.
   }];
 
   let arguments = (ins Index:$arg);
   let results = (outs Shape_SizeType:$result);
 
   let assemblyFormat = "$arg attr-dict";
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
 }
 
 def Shape_MaxOp : Shape_Op<"max",
-    [Commutative, NoSideEffect,
+    [Commutative, Pure,
      DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let summary = "Elementwise maximum";
   let description = [{
     Computes the elementwise maximum of two sizes or shapes with equal ranks.
     If either operand is an error, then an error will be propagated to the
     result. If the input types mismatch or the ranks do not match, then the
     result is an error.
   }];
def Shape_MeetOp : Shape_Op<"meet",
   let extraClassDeclaration = [{
     // Returns when two result types are compatible for this op; method used by
     // InferTypeOpInterface
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 }
 
 def Shape_MinOp : Shape_Op<"min",
-    [Commutative, NoSideEffect,
+    [Commutative, Pure,
      DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let summary = "Elementwise minimum";
   let description = [{
     Computes the elementwise minimum of two sizes or shapes with equal ranks.
     If either operand is an error, then an error will be propagated to the
     result. If the input types mismatch or the ranks do not match, then the
     result is an error.
   }];
def Shape_MinOp : Shape_Op<"min",
   let extraClassDeclaration = [{
     // Returns when two result types are compatible for this op; method used by
     // InferTypeOpInterface
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 }
 
 def Shape_MulOp : Shape_Op<"mul",
-    [Commutative, NoSideEffect,
+    [Commutative, Pure,
      DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let summary = "Multiplication of sizes and indices";
   let description = [{
     Multiplies two sizes or indices. If either operand is an error it will be
     propagated to the result. The operands can be of type `size` or `index`. If
     at least one of the operands can hold an error, i.e. if it is of type `size`,
     the result must be of type `size`. If error propagation is not possible
     because both operands are of type `index` then the result may be of type
def Shape_MulOp : Shape_Op<"mul",
   let extraClassDeclaration = [{
     // Returns when two result types are compatible for this op; method used by
     // InferTypeOpInterface
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 }
 
 def Shape_NumElementsOp : Shape_Op<"num_elements",
-    [NoSideEffect, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let summary = "Returns the number of elements for a given shape";
   let description = [{
     Returns the number of elements for a given shape which is the product of its
     extents. If the argument is of type `shape` then the result will be of type
     `size` and potential errors will be propagated. Otherwise, if the argument
     is and extent tensor `tensor<?xindex>` then the result will be of type
     `index`.
   }];
def Shape_ReduceOp : Shape_Op<"reduce",
 
   let builders = [OpBuilder<(ins "Value":$shape, "ValueRange":$initVals)>];
 
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
 def Shape_ShapeOfOp : Shape_Op<"shape_of",
-    [NoSideEffect, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [Pure, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let summary = "Returns shape of a value or shaped type operand";
 
   let description = [{
     The operation takes a value or a shaped operand as an argument and it
     returns a shape or extent tensor.
   }];
 
   let arguments = (ins AnyTypeOf<[AnyShaped, Shape_ValueShapeType]>:$arg);
   let results = (outs Shape_ShapeOrExtentTensorType:$result);
 
   let assemblyFormat = "$arg attr-dict `:` type($arg) `->` type($result)";
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     // Returns when two result types are compatible for this op; method used by
     // InferTypeOpInterface
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 }
 
-def Shape_ValueOfOp : Shape_Op<"value_of", [NoSideEffect]> {
+def Shape_ValueOfOp : Shape_Op<"value_of", [Pure]> {
   let summary = "Returns value of a !shape.value_shape operand";
 
    let description = [{
     The operation takes !shape.value_shape, a.k.a. (value, shape) tuple as an
     argument, and returns its value. The behavior is undefined for unknown and
     invalid arguments.
   }];
 
   let arguments = (ins Shape_ValueShapeType:$arg);
   let results = (outs AnyShaped:$result);
 
   let assemblyFormat = "$arg attr-dict `:` type($result)";
 }
 
 def Shape_SizeToIndexOp : Shape_Op<"size_to_index", [
-    DeclareOpInterfaceMethods<CastOpInterface>, NoSideEffect
+    DeclareOpInterfaceMethods<CastOpInterface>, Pure
   ]> {
   let summary = "Casts between index types of the shape and standard dialect";
   let description = [{
     Converts a `shape.size` to a standard index. This operation and its
     inverse, `index_to_size`, facilitate index conversion between the standard
     and the shape dialect. The behavior is undefined for unknown and invalid
     arguments.
   }];
 
   let arguments = (ins Shape_SizeOrIndexType:$arg);
   let results = (outs Index:$result);
 
   let assemblyFormat = "$arg attr-dict `:` type($arg)";
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
 }
 
-def Shape_ValueAsShapeOp : Shape_Op<"value_as_shape", [NoSideEffect]> {
+def Shape_ValueAsShapeOp : Shape_Op<"value_as_shape", [Pure]> {
   let summary = "Returns value as a shape";
 
   let description = [{
     The operations takes a ValueShape and returns a Shape corresponding to the value.
     If the input value cannot be shape (e.g., not a 1D tensor of integral value
     representing sizes) then this propagages the error shape. E.g.,
 
     ```mlir
     // The following
     %0 = arith.constant dense<[1,2]> : tensor<2xi32>
     %shape = shape.value_as_shape %0 : tensor<2xi32> -> !shape.shape
     // is equivalent to
     %shape' = shape.const_shape [1, 2] : !shape.shape
     ```
 
     This operation is the compliment of `shape_of` wrt ValueShape values.
   }];
 
   let arguments = (ins AnyTypeOf<[1DTensorOf<[AnyInteger, Index]>, Shape_ValueShapeType]>:$arg);
   let results = (outs Shape_ShapeOrExtentTensorType:$result);
 
   let assemblyFormat = "$arg attr-dict `:` type($arg) `->` type($result)";
 }
 
-def Shape_WithOp : Shape_Op<"with_shape", [NoSideEffect]> {
+def Shape_WithOp : Shape_Op<"with_shape", [Pure]> {
   let summary = "Returns ValueShape with given shape";
   let description = [{
     Returns ValueShape with the shape updated to match the shape operand. That
     is a new ValueShape tuple is created with value equal to `operand`'s
     value and shape equal to `shape`. If the ValueShape and given `shape` are
     non-conformant, then the returned ValueShape will represent an error of
     this mismatch. Similarly if either inputs are in an error state, then an
     error is propagated.
let arguments = (ins AnyTypeOf<[AnyShaped, Shape_ValueShapeType]>:$operand,
                        Shape_ShapeOrExtentTensorType:$shape);
   let results = (outs Shape_ValueShapeType:$result);
 
   let assemblyFormat = "operands attr-dict `:` type($operand) `,` type($shape)";
 }
 
 def Shape_YieldOp : Shape_Op<"yield",
     [HasParent<"ReduceOp, FunctionLibraryOp">,
-     NoSideEffect,
+     Pure,
      ReturnLike,
      Terminator]> {
   let summary = "Returns the value to parent op";
 
   let arguments = (ins Variadic<AnyType>:$operands);
 
   let builders = [OpBuilder<(ins),
     [{ build($_builder, $_state, llvm::None); }]>
let description = [{
 
     Note: This is intended for testing and debugging only.
   }];
 
   let arguments = (ins Shape_ShapeOrSizeType:$input);
   let results =  (outs Shape_ShapeOrSizeType:$output);
 }
 
-def Shape_SplitAtOp : Shape_Op<"split_at", [NoSideEffect]> {
+def Shape_SplitAtOp : Shape_Op<"split_at", [Pure]> {
   let summary = "Splits a shape at a given index";
   let description = [{
     Splits a shape at a given dimension `index`, returning two shapes.
     If `index` is negative, it is treated as indexing from the back of the
     shape. This negative-handling behavior is important when handling unranked
     shapes, where the positive index is not necessarily knowable due to a
     dynamic number of leading dimensions. If the result is in extent tensor form
     out of bounds indices result in undefined behavior.
def Shape_SplitAtOp : Shape_Op<"split_at", [Pure]> {
 
   let arguments = (ins Shape_ShapeOrExtentTensorType:$operand,
                        Shape_SizeOrIndexType:$index);
   let results = (outs Shape_ShapeOrExtentTensorType:$head,
                       Shape_ShapeOrExtentTensorType:$tail);
   let hasFolder = 1;
 }
 
-def Shape_ConcatOp : Shape_Op<"concat", [NoSideEffect]> {
+def Shape_ConcatOp : Shape_Op<"concat", [Pure]> {
   let summary = "Concatenates two shapes";
   let description = [{
     Creates a shape whose dimensions consist of first the dimensions from `lhs`
     followed by the dimensions of `rhs`.
 
     Example:
     concat([2,3], [4,5]) -> [2,3,4,5]
     concat([], []) -> []

 }
 
 //===----------------------------------------------------------------------===//
 // Shape constraint related ops.
 //===----------------------------------------------------------------------===//
 
 // TODO: Move the code below and witnesses to a different file.
 def Shape_AnyOp : Shape_Op<"any", [Commutative,
-                                   NoSideEffect]> {
+                                   Pure]> {
   let summary = "Return any combination of the input shapes";
   let description = [{
     This operation takes multiple input shapes or extent tensors and returns
     some combination of their dimensions. This can be best seen with examples
     below.
 
     The result is undefined, but still side-effect free, in cases where the
     inputs have differing ranks or differ in extents of shared dimensions.
 
     Example:
     ```mlir
     %s0 = shape.any [2,?], [?,3] // [2,3]
     %s1 = shape.any [?,?], [1,2] // [1,2]
     ```
   }];
 
   let arguments = (ins Variadic<Shape_ShapeOrExtentTensorType>:$inputs);
   let results = (outs Shape_ShapeOrExtentTensorType:$result);
 
   let assemblyFormat = "$inputs attr-dict `:` type($inputs) `->` type($result)";
 
   let hasFolder = 1;
 }
 
-def Shape_AssumingAllOp : Shape_Op<"assuming_all", [Commutative, NoSideEffect]> {
+def Shape_AssumingAllOp : Shape_Op<"assuming_all", [Commutative, Pure]> {
   let summary = "Return a logical AND of all witnesses";
   let description = [{
     Used to simplify constraints as any single failing precondition is enough
     to prevent execution.
 
     "assuming" operations represent an execution order restriction to the
     compiler, information for dependent code to rely on (by assuming), and
     nothing else. They should not exist after a program is fully lowered and
def Shape_AssumingAllOp : Shape_Op<"assuming_all", [Commutative, Pure]> {
   let hasFolder = 1;
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
 }
 
 def Shape_AssumingOp : Shape_Op<"assuming", [
     SingleBlockImplicitTerminator<"AssumingYieldOp">,
     DeclareOpInterfaceMethods<RegionBranchOpInterface>,
-    RecursiveSideEffects]> {
+    RecursiveMemoryEffects]> {
   let summary = "Execute the region";
   let description = [{
     Executes the region assuming all witnesses are true.
 
     "assuming" operations represent an execution order restriction to the
     compiler, information for dependent code to rely on (by assuming), and
     nothing else. They should not exist after a program is fully lowered and
     ready to execute.
OpBuilder<(ins "Value":$witness,
         CArg<"function_ref<SmallVector<Value, 2>(OpBuilder &, Location)>">)>
   ];
 
   let hasCanonicalizer = 1;
   let hasCustomAssemblyFormat = 1;
 }
 
 def Shape_AssumingYieldOp : Shape_Op<"assuming_yield",
-       [NoSideEffect, ReturnLike, Terminator, HasParent<"AssumingOp">]> {
+       [Pure, ReturnLike, Terminator, HasParent<"AssumingOp">]> {
   let summary = "Yield operation";
   let description = [{
     This yield operation represents a return operation within the
     `shape.assuming` operation region. The operation takes variable number of
     operands and produces no results. The operand number and types must match
     the number and types of parent `shape.assuming` results.
   }];
 
def Shape_CstrEqOp : Shape_Op<"cstr_eq", [Commutative]> {
   let results = (outs Shape_WitnessType:$result);
 
   let assemblyFormat = "$shapes attr-dict `:` type($shapes)";
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 }
 
-def Shape_ConstWitnessOp : Shape_Op<"const_witness", [ConstantLike, NoSideEffect]> {
+def Shape_ConstWitnessOp : Shape_Op<"const_witness", [ConstantLike, Pure]> {
   let summary = "An operation that returns a statically known witness value";
   let description = [{
   This operation represents a statically known witness result. This can be
   often used to canonicalize/fold constraint and assuming code that will always
   pass.
 
   ```mlir
   %0 = shape.const_shape [1,2,3]
let extraClassDeclaration = [{
     //===------------------------------------------------------------------===//
 
     bool isDeclaration() { return isExternal(); }
   }];
   let hasCustomAssemblyFormat = 1;
 }
 
 def Shape_ReturnOp : Shape_Op<"return",
-    [NoSideEffect, HasParent<"FuncOp">, ReturnLike, Terminator]> {
+    [Pure, HasParent<"FuncOp">, ReturnLike, Terminator]> {
   let summary = "Shape function return operation";
   let description = [{
     The `shape.return` operation represents a return operation within a function.
     The operation takes variable number of operands and produces no results.
   }];
 
   let arguments = (ins Variadic<AnyType>:$operands);
 
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
 
   // TODO: Tighten verification.
 }
 
 #endif // SHAPE_OPS

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorOps.td

 
 class SparseTensor_Op<string mnemonic, list<Trait> traits = []>
   : Op<SparseTensor_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // Sparse Tensor Operations.
 //===----------------------------------------------------------------------===//
 
-def SparseTensor_NewOp : SparseTensor_Op<"new", [NoSideEffect]>,
+def SparseTensor_NewOp : SparseTensor_Op<"new", [Pure]>,
     Arguments<(ins AnyType:$source)>,
     Results<(outs AnySparseTensor:$result)> {
   string summary = "Materializes a new sparse tensor from given source";
   string description = [{
     Materializes a sparse tensor with contents taken from an opaque pointer
     provided by `source`. For targets that have access to a file system,
     for example, this pointer may be a filename (or file) of a sparse
     tensor in a particular external storage format. The form of the operation
     is kept deliberately very general to allow for alternative implementations
     in the future, such as pointers to buffers or runnable initialization
     code. The operation is provided as an anchor that materializes a properly
     typed sparse tensor with inital contents into a computation.
 
     Example:
 
     ```mlir
     sparse_tensor.new %source : !Source to tensor<1024x1024xf64, #CSR>
     ```
   }];
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($result)";
 }
 
 def SparseTensor_ConvertOp : SparseTensor_Op<"convert",
-  [NoSideEffect, SameOperandsAndResultElementType]>,
+  [Pure, SameOperandsAndResultElementType]>,
     Arguments<(ins AnyTensor:$source)>,
     Results<(outs AnyTensor:$dest)> {
   string summary = "Converts between different tensor types";
   string description = [{
     Converts one sparse or dense tensor type to another tensor type. The rank
     of the source and destination types must match exactly, and the dimension
     sizes must either match exactly or relax from a static to a dynamic size.
     The sparse encoding of the two types can obviously be completely different.
string description = [{
     ```
 
   }];
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($dest)";
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
-def SparseTensor_ToPointersOp : SparseTensor_Op<"pointers", [NoSideEffect]>,
+def SparseTensor_ToPointersOp : SparseTensor_Op<"pointers", [Pure]>,
     Arguments<(ins AnySparseTensor:$tensor, IndexAttr:$dimension)>,
     Results<(outs AnyStridedMemRefOfRank<1>:$result)> {
   let summary = "Extracts pointers array at given dimension from a tensor";
   let description = [{
     Returns the pointers array of the sparse storage format at the
     given dimension for the given sparse tensor. This is similar to the
     `bufferization.to_memref` operation in the sense that it provides a bridge
     between a tensor world view and a bufferized world view. Unlike the
     `bufferization.to_memref` operation, however, this sparse operation actually
     lowers into code that extracts the pointers array from the sparse storage
     scheme (either by calling a support library or through direct code).
 
     Example:
 
     ```mlir
     %1 = sparse_tensor.pointers %0 { dimension = 1 : index }
        : tensor<64x64xf64, #CSR> to memref<?xindex>
     ```
   }];
   let assemblyFormat = "$tensor attr-dict `:` type($tensor) `to` type($result)";
   let hasVerifier = 1;
 }
 
-def SparseTensor_ToIndicesOp : SparseTensor_Op<"indices", [NoSideEffect]>,
+def SparseTensor_ToIndicesOp : SparseTensor_Op<"indices", [Pure]>,
     Arguments<(ins AnySparseTensor:$tensor, IndexAttr:$dimension)>,
     Results<(outs AnyStridedMemRefOfRank<1>:$result)> {
   let summary = "Extracts indices array at given dimension from a tensor";
   let description = [{
     Returns the indices array of the sparse storage format at the
     given dimension for the given sparse tensor. This is similar to the
     `bufferization.to_memref` operation in the sense that it provides a bridge
     between a tensor world view and a bufferized world view. Unlike the
     `bufferization.to_memref` operation, however, this sparse operation actually
     lowers into code that extracts the indices array from the sparse storage
     scheme (either by calling a support library or through direct code).
 
     Example:
 
     ```mlir
     %1 = sparse_tensor.indices %0 { dimension = 1 : index }
        : tensor<64x64xf64, #CSR> to memref<?xindex>
     ```
   }];
   let assemblyFormat = "$tensor attr-dict `:` type($tensor) `to` type($result)";
   let hasVerifier = 1;
 }
 
-def SparseTensor_ToValuesOp : SparseTensor_Op<"values", [NoSideEffect]>,
+def SparseTensor_ToValuesOp : SparseTensor_Op<"values", [Pure]>,
     Arguments<(ins AnySparseTensor:$tensor)>,
     Results<(outs AnyStridedMemRefOfRank<1>:$result)> {
   let summary = "Extracts numerical values array from a tensor";
   let description = [{
     Returns the values array of the sparse storage format for the given
     sparse tensor, independent of the actual dimension. This is similar to
     the `bufferization.to_memref` operation in the sense that it provides a bridge
     between a tensor world view and a bufferized world view. Unlike the
     `bufferization.to_memref` operation, however, this sparse operation actually
     lowers into code that extracts the values array from the sparse storage
     scheme (either by calling a support library or through direct code).
 
     Example:
 
     ```mlir
     %1 = sparse_tensor.values %0 : tensor<64x64xf64, #CSR> to memref<?xf64>
     ```
   }];
   let assemblyFormat = "$tensor attr-dict `:` type($tensor) `to` type($result)";
   let hasVerifier = 1;
 }
 
-def SparseTensor_ConcatenateOp : SparseTensor_Op<"concatenate", [NoSideEffect]>,
+def SparseTensor_ConcatenateOp : SparseTensor_Op<"concatenate", [Pure]>,
     Arguments<(ins Variadic<AnyRankedTensor>:$inputs, IndexAttr:$dimension)>,
     Results<(outs AnyRankedTensor:$result)> {
 
   let summary = "Concatenates a list of tensors into a single tensor.";
   let description = [{
      Concatenates a list input tensors and the output tensor with the same rank.
      The concatenation happens on the specified `dimension` (0<= dimension < rank).
      The resulting `dimension` size is the sum of all the input dimension sizes,
let assemblyFormat = "(`stable` $stable^)? $n"
                        "`:` type($xs) (`jointly` type($ys)^)?";
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Sparse Tensor Syntax Operations.
 //===----------------------------------------------------------------------===//
 
-def SparseTensor_BinaryOp : SparseTensor_Op<"binary", [NoSideEffect]>,
+def SparseTensor_BinaryOp : SparseTensor_Op<"binary", [Pure]>,
     Arguments<(ins AnyType:$x, AnyType:$y, UnitAttr:$left_identity, UnitAttr:$right_identity)>,
     Results<(outs AnyType:$output)> {
   let summary = "Binary set operation utilized within linalg.generic";
   let description = [{
       Defines a computation within a `linalg.generic` operation that takes two
       operands and executes one of the regions depending on whether both operands
       or either operand is nonzero (i.e. stored explicitly in the sparse storage
       format).
let assemblyFormat = [{
         $x `,` $y `:` attr-dict type($x) `,` type($y) `to` type($output) `\n`
         `overlap` `=` $overlapRegion `\n`
         `left` `=` (`identity` $left_identity^):($leftRegion)? `\n`
         `right` `=` (`identity` $right_identity^):($rightRegion)?
   }];
   let hasVerifier = 1;
 }
 
-def SparseTensor_UnaryOp : SparseTensor_Op<"unary", [NoSideEffect]>,
+def SparseTensor_UnaryOp : SparseTensor_Op<"unary", [Pure]>,
     Arguments<(ins AnyType:$x)>,
     Results<(outs AnyType:$output)> {
   let summary = "Unary set operation utilized within linalg.generic";
   let description = [{
       Defines a computation with a `linalg.generic` operation that takes a single
       operand and executes one of two regions depending on whether the operand is
       nonzero (i.e. stored explicitly in the sparse storage format).
 
def SparseTensor_UnaryOp : SparseTensor_Op<"unary", [Pure]>,
   let assemblyFormat = [{
         $x attr-dict `:` type($x) `to` type($output) `\n`
         `present` `=` $presentRegion `\n`
         `absent` `=` $absentRegion
   }];
   let hasVerifier = 1;
 }
 
-def SparseTensor_ReduceOp : SparseTensor_Op<"reduce", [NoSideEffect, SameOperandsAndResultType]>,
+def SparseTensor_ReduceOp : SparseTensor_Op<"reduce", [Pure, SameOperandsAndResultType]>,
     Arguments<(ins AnyType:$x, AnyType:$y, AnyType:$identity)>,
     Results<(outs AnyType:$output)> {
   let summary = "Custom reduction operation utilized within linalg.generic";
   let description = [{
       Defines a computation with a `linalg.generic` operation that takes two
       operands and an identity value and reduces all values down to a single
       result based on the computation in the region.
 
def SparseTensor_ReduceOp : SparseTensor_Op<"reduce", [Pure, SameOperandsAndResultType]>,
   let regions = (region SizedRegion<1>:$region);
 
   let assemblyFormat = [{
          $x `,` $y `,` $identity attr-dict `:` type($output) $region
   }];
   let hasVerifier = 1;
 }
 
-def SparseTensor_SelectOp : SparseTensor_Op<"select", [NoSideEffect, SameOperandsAndResultType]>,
+def SparseTensor_SelectOp : SparseTensor_Op<"select", [Pure, SameOperandsAndResultType]>,
     Arguments<(ins AnyType:$x)>,
     Results<(outs AnyType:$output)> {
   let summary = "Select operation utilized within linalg.generic";
   let description = [{
       Defines an evaluation within a `linalg.generic` operation that takes a single
       operand and decides whether or not to keep that operand in the output.
 
       A single region must contain exactly one block taking one argument. The block
def SparseTensor_SelectOp : SparseTensor_Op<"select", [Pure, SameOperandsAndResultType]>,
 
   let regions = (region SizedRegion<1>:$region);
   let assemblyFormat = [{
          $x attr-dict `:` type($x) $region
   }];
   let hasVerifier = 1;
 }
 
-def SparseTensor_YieldOp : SparseTensor_Op<"yield", [NoSideEffect, Terminator]>,
+def SparseTensor_YieldOp : SparseTensor_Op<"yield", [Pure, Terminator]>,
     Arguments<(ins Optional<AnyType>:$result)> {
   let summary = "Yield from sparse_tensor set-like operations";
   let description = [{
       Yields a value from within a `binary`, `unary`, `reduce`,
       `select` or `foreach` block.
 
       Example:
 

mlir/include/mlir/Dialect/Tensor/IR/TensorOps.td

 
 //===----------------------------------------------------------------------===//
 // CastOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_CastOp : Tensor_Op<"cast", [
     DeclareOpInterfaceMethods<CastOpInterface>, 
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-    NoSideEffect
+    Pure
   ]> {
   let summary = "tensor cast operation";
   let description = [{
     Convert a tensor from one type to an equivalent type without changing any
     data elements. The source and destination types must both be tensor types
     with the same element type. If both are ranked, then the rank should be the
     same and static dimensions should match. The operation is invalid if
     converting to a mismatching constant dimension.

 }
 
 //===----------------------------------------------------------------------===//
 // DimOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_DimOp : Tensor_Op<"dim", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-    NoSideEffect,
+    Pure,
     ShapedDimOpInterface]> {
   let summary = "dimension index operation";
   let description = [{
     The `tensor.dim` operation takes a tensor and a dimension operand of type
     `index`. It returns the size of the requested dimension of the given
     tensor. If the dimension index is out of bounds, the behavior is undefined.
 
     The specified tensor type is that of the first operand.
def Tensor_DimOp : Tensor_Op<"dim", [
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // EmptyOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_EmptyOp : Tensor_Op<"empty",
-    [NoSideEffect,
+    [Pure,
      DeclareOpInterfaceMethods<ReifyRankedShapedTypeOpInterface>]> {
   let summary = "empty tensor operation";
 
   let description = [{
     `tensor.empty` is an operation that defines a tensor of a particular shape.
     The shape could be dynamic or static. The contents of the tensor are
     unspecified and the only purpose of the op result is to materialize the
     specified shape in IR and make it available to other transformations.

 }
 
 //===----------------------------------------------------------------------===//
 // ExtractOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_ExtractOp : Tensor_Op<"extract", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-    NoSideEffect,
+    Pure,
     TypesMatchWith<"result type matches element type of tensor",
                    "tensor", "result",
                    "$_self.cast<ShapedType>().getElementType()">]> {
   let summary = "element extraction operation";
   let description = [{
     The `tensor.extract` op reads a tensor and returns one
     element from it specified by an index list. The output of the op is a
     new value with the same type as the elements of the tensor. The

 //===----------------------------------------------------------------------===//
 // ExtractSliceOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_ExtractSliceOp : Tensor_OpWithOffsetSizesAndStrides<"extract_slice", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
     DeclareOpInterfaceMethods<ReifyRankedShapedTypeOpInterface>,
     AttrSizedOperandSegments,
-    NoSideEffect, 
+    Pure, 
     OffsetSizeAndStrideOpInterface
   ]> {
   let summary = "extract slice operation";
   let description = [{
     The "extract_slice" operation extract a tensor from another tensor as
     specified by the operation's offsets, sizes and strides arguments.
 
     The extract_slice operation supports the following arguments:

 }
 
 //===----------------------------------------------------------------------===//
 // FromElementsOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_FromElementsOp : Tensor_Op<"from_elements", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-    NoSideEffect,
+    Pure,
     TypesMatchWith<"operand types match result element type",
                    "result", "elements", "SmallVector<Type, 2>("
                    "$_self.cast<ShapedType>().getNumElements(), "
                    "$_self.cast<ShapedType>().getElementType())">
   ]> {
   let summary = "tensor from elements operation.";
   let description = [{
     Create a N-D tensor from a range of same-type arguments. The number of

 }
 
 //===----------------------------------------------------------------------===//
 // GatherOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_GatherOp : Tensor_Op<"gather", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-    NoSideEffect
+    Pure
   ]> {
   let summary = "gather a subset of a tensor at specified indices";
   let description = [{
     The `gather` operation extracts a subset of the elements from a `source`
     tensor at the given indices.
 
     In its most general form, the tensor of indices specifies all the coordinates
     of every element to extract (i.e. COO format, without the payload). 

 }
 
 //===----------------------------------------------------------------------===//
 // GenerateOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_GenerateOp : Tensor_Op<"generate", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-    RecursiveSideEffects,
+    RecursiveMemoryEffects,
     DeclareOpInterfaceMethods<ReifyRankedShapedTypeOpInterface>,
     SingleBlockImplicitTerminator<"mlir::tensor::YieldOp">]> {
   let summary = "Creates a dynamically sized tensor from elements";
   let description = [{
     This operation creates a dynamically sized tensor with elements of any type.
     It expects one index operand per dynamic extent of the result tensor.
 
     The body region defines the tensor's elements. It takes index operands as

 }
 
 //===----------------------------------------------------------------------===//
 // InsertOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_InsertOp : Tensor_Op<"insert", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-    NoSideEffect,
+    Pure,
     TypesMatchWith<"result type matches type of dest",
                    "dest", "result",
                    "$_self.cast<ShapedType>()">,
     TypesMatchWith<"scalar type matches element type of dest",
                    "dest", "scalar",
                    "$_self.cast<ShapedType>().getElementType()">]> {
   let summary = "element insertion operation";
   let description = [{

 //===----------------------------------------------------------------------===//
 // InsertSliceOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_InsertSliceOp : Tensor_OpWithOffsetSizesAndStrides<"insert_slice", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
     DeclareOpInterfaceMethods<ReifyRankedShapedTypeOpInterface>,
     AttrSizedOperandSegments, 
-    NoSideEffect, 
+    Pure, 
     OffsetSizeAndStrideOpInterface,
     TypesMatchWith<"expected result type to match dest type",
                    "dest", "result", "$_self">
   ]> {
   let summary = "insert_slice operation";
   let description = [{
     The "insert_slice" operation insert a tensor `source` into another
     tensor `dest` as specified by the operation's offsets, sizes and strides

 }
 
 //===----------------------------------------------------------------------===//
 // RankOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_RankOp : Tensor_Op<"rank", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "rank operation";
   let description = [{
     The `tensor.rank` operation takes a tensor operand and returns its rank.
 
     Example:
 
     ```mlir
     %0 = tensor.rank %arg0 : tensor<*xf32>

 }
 
 //===----------------------------------------------------------------------===//
 // ReshapeOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_ReshapeOp: Tensor_Op<"reshape", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-    NoSideEffect]>  {
+    Pure]>  {
   let summary = "tensor reshape operation";
   let description = [{
     The `reshape` operation converts a tensor from one type to an equivalent
     type with a provided shape. The source and destination types are compatible
     if both have the same element type, same number of elements. The following
     combinations are possible:
 
     a. Source type is ranked or unranked. Shape argument has static size.

 
 //===----------------------------------------------------------------------===//
 // ExpandShapeOp / CollapseShapeOp
 //===----------------------------------------------------------------------===//
 
 class Tensor_ReassociativeReshapeOp<string mnemonic, list<Trait> traits = []> :
     Tensor_Op<mnemonic, !listconcat(traits, [
       DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-      NoSideEffect])>,
+      Pure])>,
     Arguments<(ins AnyTensor:$src, IndexListArrayAttr:$reassociation)>,
     Results<(outs AnyTensor:$result)> {
 
   code commonExtraClassDeclaration = [{
     static StringRef getReassociationAttrStrName() { return "reassociation"; }
     SmallVector<AffineMap, 4> getReassociationMaps();
     SmallVector<ReassociationExprs, 4> getReassociationExprs();
     SmallVector<ReassociationIndices, 4> getReassociationIndices() {

 
 //===----------------------------------------------------------------------===//
 // PadOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_PadOp : Tensor_Op<"pad", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
     AttrSizedOperandSegments, 
-    NoSideEffect,
+    Pure,
     SingleBlockImplicitTerminator<"mlir::tensor::YieldOp">]> {
   let summary = "tensor pad operation";
   let description = [{
     `tensor.pad` is an operation that pads the `source` tensor
     with given `low` and `high` padding config.
 
     The PadOp operation supports the following arguments:
 
let description = [{
     If an index is updated exactly once, the value contained at that index
     in the resulting tensor will be equal to the value at a corresponding index
     of a slice that was used for the updated. If an index is not updated at all,
     its value will be equal to the one in the original tensor.
 
     This op does not create a new value, which allows maintaining a clean
     separation between the subset and full tensor.
 
-    Note that we cannot mark this operation as pure (NoSideEffects), even
+    Note that we cannot mark this operation as pure (Pures), even
     though it has no side effects, because it will get DCEd during
     canonicalization.
 
     The parallel_insert_slice operation supports the following arguments:
 
     * source: the tensor that is inserted.
     * dest: the tensor into which the source tensor is inserted.
     * offsets: tensor-rank number of offsets into the `dest` tensor into which

 
 
 //===----------------------------------------------------------------------===//
 // ScatterOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_ScatterOp : Tensor_Op<"scatter", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-    NoSideEffect
+    Pure
   ]> {
   let summary = 
     "scatter a tensor into a destination tensor at specified indices";
   let description = [{
     The `scatter` operation inserts a `source` tensor into a `dest` tensor at
     the given indices.
 
     In its most general form, the tensor of indices specifies all the coordinates

 }
 
 //===----------------------------------------------------------------------===//
 // SplatOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_SplatOp : Tensor_Op<"splat", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
-    NoSideEffect,
+    Pure,
     TypesMatchWith<"operand type matches element type of result",
                    "aggregate", "input",
                    "$_self.cast<TensorType>().getElementType()">
   ]> {
   let summary = "tensor splat or broadcast operation";
   let description = [{
     Broadcast the operand to all elements of the result tensor. The operand is
     required to be of integer/index/float type, and the result tensor must be
def Tensor_SplatOp : Tensor_Op<"splat", [
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // YieldOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_YieldOp : Tensor_Op<"yield",
-    [NoSideEffect, ReturnLike, Terminator,
+    [Pure, ReturnLike, Terminator,
      HasParent<"::mlir::tensor::GenerateOp, ::mlir::tensor::PadOp">]> {
   let summary = "Yield a value from a region";
   let description = [{
      This operation is used to yield a single value from a within a region. It
      is used to create dynamically sized tensors
      (see `tensor.generate` and `tensor.pad` ops).
   }];
 

mlir/include/mlir/Dialect/Tosa/IR/TosaOps.td

 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Operator: argmax
 //===----------------------------------------------------------------------===//
 def Tosa_ArgMaxOp : Tosa_Op<"argmax", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Perform argmax on the input.";
 
   let description = [{
     This returns the index with the largest value across the given axis of the
     input tensor.
   }];
 
   let arguments = (ins
     Tosa_Tensor1Dto4D: $input,
     I64Attr: $axis
   );
 
   let results = (outs
     Tosa_TensorUpto4D: $output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: avg_pool2d
 //===----------------------------------------------------------------------===//
 def Tosa_AvgPool2dOp : Tosa_Op<"avg_pool2d", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Performs max pooling on the input.";
 
   let description = [{
     This performs an average pooling over the given input tensor. A sliding
     window of size given by <kernel size> is passed over the input tensor, with
     the mean value being placed in the output tensor.
   }];
 

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: conv2d
 //===----------------------------------------------------------------------===//
 def Tosa_Conv2DOp : Tosa_Op<"conv2d", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "2D Convolution Operator";
 
   let description = [{
     Performs a 2D convolution over the given tensor input, using the weight
     tensor.
   }];
 
   let arguments = (ins

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: conv3d
 //===----------------------------------------------------------------------===//
 def Tosa_Conv3DOp : Tosa_Op<"conv3d", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "3D Convolution operator";
 
   let description = [{
     Performs a 3D convolution over the given input tensor.
   }];
 
   let arguments = (ins
     Tosa_Tensor5D:$input,

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: depthwise_conv2d
 //===----------------------------------------------------------------------===//
 def Tosa_DepthwiseConv2DOp : Tosa_Op<"depthwise_conv2d", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Depthwise 2D Convolution operator";
 
   let description = [{
     Performs 2D convolutions separately over each channel of the given tensor
     input, using the weight tensor.
   }];
 
   let arguments = (ins

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: fully_connected
 //===----------------------------------------------------------------------===//
 def Tosa_FullyConnectedOp : Tosa_Op<"fully_connected", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Fully Connected operator";
 
   let description = [{
     Performs a fully connected network.
   }];
 
   let arguments = (ins
     Tosa_Tensor2D:$input,

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: matmul
 //===----------------------------------------------------------------------===//
 def Tosa_MatMulOp : Tosa_Op<"matmul", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Matrix multiplication with bias";
 
   let description = [{
     Performs a two dimensional matrix multiplication. This allows both inputs to
     be activations, rather than reserving weights as an attribute in the
     FULLY_CONNECTED operator.
   }];
 

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: max_pool2d
 //===----------------------------------------------------------------------===//
 def Tosa_MaxPool2dOp : Tosa_Op<"max_pool2d", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Performs max pooling on the input.";
 
   let description = [{
     This performs a max pooling over the given input tensor. A sliding window of
     size given by <kernel size> is passed over the input tensor, with the
     maximum value being placed in the
     output tensor.
   }];

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: transpose_conv2d
 //===----------------------------------------------------------------------===//
 def Tosa_TransposeConv2DOp : Tosa_Op<"transpose_conv2d", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Transpose 2D Convolution operator.";
 
   let description = [{
     Performs a 2D transposed convolution over the given tensor input, using the
     weights tensor.
   }];
 
   let arguments = (ins

 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Operator: clamp
 //===----------------------------------------------------------------------===//
 def Tosa_ClampOp : Tosa_Op<"clamp", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Computes clamp(features, min, max).";
 
   let description = [{
     Clamp to an arbitrary minimum and maximum value.
     Maximum and minimum values are specified as values in the range of the
     input type.
     No zero point subtraction is done to the values, thus to clamp to the zero
     point value, the zero point itself should be supplied as the minimum value.

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: sigmoid
 //===----------------------------------------------------------------------===//
 def Tosa_SigmoidOp : Tosa_Op<"sigmoid", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Computes elementwise sigmoid of input.";
 
   let description = [{
     Sigmoid function: output = 1 / (1 + exp(-input))
     For quantized integer data types, the TABLE operator should be used instead
     with the following definition.  The sigmoid table has 513 entries each of
     16-bit precision and covering the input range -16.0 to +16.0
     in steps of 1/16.

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: tanh
 //===----------------------------------------------------------------------===//
 def Tosa_TanhOp : Tosa_Op<"tanh", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Computes elementwise hyperbolic tangent of input";
 
   let description = [{
     Parameterized hyperbolic tangent.
     For quantized integer data types, the TABLE operator should be used instead
     with the following definition.  The tanh_table has 513 entries each of
     16-bit precision and covering the input range -8.0 to +8.0 in steps of 1/32.
   }];

 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Operator: add
 //===----------------------------------------------------------------------===//
 def Tosa_AddOp : Tosa_Op<"add", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, NoSideEffect, Commutative]> {
+    ResultsBroadcastableShape, Pure, Commutative]> {
   let summary = "Elementwise addition operator";
 
   let description = [{
     Elementwise addition of input1 and input2. Axis of size 1 will be broadcast,
     as necessary.
   }];
 
   let arguments = (ins

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: arithmetic_right_shift
 //===----------------------------------------------------------------------===//
 def Tosa_ArithmeticRightShiftOp : Tosa_Op<"arithmetic_right_shift", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, NoSideEffect]> {
+    ResultsBroadcastableShape, Pure]> {
   let summary = "Elementwise Arithmetic Right Shift";
 
   let description = [{
     Elementwise arithmetic right shift of input1 by the amount specified in
     input2. Axis of size 1 will be broadcast, as necessary.
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1,
     Tosa_Tensor:$input2,
     BoolAttr:$round
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: bitwise_and
 //===----------------------------------------------------------------------===//
 def Tosa_BitwiseAndOp : Tosa_Op<"bitwise_and", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, NoSideEffect, Commutative]> {
+    ResultsBroadcastableShape, Pure, Commutative]> {
   let summary = "Bitwise AND operator";
 
   let description = [{
     Elementwise bitwise AND of input1 and input2. Axis of size 1
     will be broadcast as necessary.
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1,
     Tosa_Tensor:$input2
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: bitwise_or
 //===----------------------------------------------------------------------===//
 def Tosa_BitwiseOrOp : Tosa_Op<"bitwise_or", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, NoSideEffect, Commutative]> {
+    ResultsBroadcastableShape, Pure, Commutative]> {
   let summary = "Bitwise OR operator";
 
   let description = [{
     Elementwise bitwise OR of input1 and input2. Axis of size 1 will be
     broadcast as necessary.
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1,
     Tosa_Tensor:$input2
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: bitwise_xor
 //===----------------------------------------------------------------------===//
 def Tosa_BitwiseXorOp : Tosa_Op<"bitwise_xor", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, NoSideEffect, Commutative]> {
+    ResultsBroadcastableShape, Pure, Commutative]> {
   let summary = "Bitwise XOR operator";
 
   let description = [{
     Elementwise bitwise XOR of input1 and input2. Axis of size 1 will be
     broadcast as necessary.
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1,
     Tosa_Tensor:$input2
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: div
 //===----------------------------------------------------------------------===//
 def Tosa_DivOp : Tosa_Op<"div", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, NoSideEffect]> {
+    ResultsBroadcastableShape, Pure]> {
   let summary = "Integer divide operator";
 
   let description = [{
     Elementwise integer divide operator of input1 by input2. Axis of size 1
     will be broadcast, as necessary.
   }];
 
   let arguments = (ins

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: logical_and
 //===----------------------------------------------------------------------===//
 def Tosa_LogicalAndOp : Tosa_Op<"logical_and", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, Commutative, NoSideEffect]> {
+    ResultsBroadcastableShape, Commutative, Pure]> {
   let summary = "Returns the truth value of x AND y element-wise.";
 
   let description = [{
     Elementwise logical AND of input1 and input2. Axis of size 1 will be
     broadcast, as necessary.
   }];
 
   let arguments = (ins
     I1Tensor:$input1,
     I1Tensor:$input2
   );
 
   let results = (outs
     I1Tensor:$z
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: logical_left_shift
 //===----------------------------------------------------------------------===//
 def Tosa_LogicalLeftShiftOp : Tosa_Op<"logical_left_shift", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, NoSideEffect]> {
+    ResultsBroadcastableShape, Pure]> {
   let summary = "Elementwise Logical Left Shift";
 
   let description = [{
     Elementwise left shift of input1 and input2. Axis of size 1 will be
     broadcast, as necessary.
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1,
     Tosa_Tensor:$input2
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: logical_right_shift
 //===----------------------------------------------------------------------===//
 def Tosa_LogicalRightShiftOp : Tosa_Op<"logical_right_shift", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, NoSideEffect]> {
+    ResultsBroadcastableShape, Pure]> {
   let summary = "Elementwise Logical Right Shift";
 
   let description = [{
     Elementwise logical right shift of input1 by the amount specified in input2.
     Axis of size 1 will be broadcast, as necessary.
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1,
     Tosa_Tensor:$input2
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: logical_or
 //===----------------------------------------------------------------------===//
 def Tosa_LogicalOrOp : Tosa_Op<"logical_or", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, Commutative, NoSideEffect]> {
+    ResultsBroadcastableShape, Commutative, Pure]> {
   let summary = "Returns the truth value of x OR y element-wise.";
 
   let description = [{
     Elementwise logical OR of input1 and input2. Axis of size 1 will be
     broadcast as necessary.
   }];
 
   let arguments = (ins
     I1Tensor:$input1,
     I1Tensor:$input2
   );
 
   let results = (outs
     I1Tensor:$z
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: logical_xor
 //===----------------------------------------------------------------------===//
 def Tosa_LogicalXorOp : Tosa_Op<"logical_xor", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, Commutative, NoSideEffect]> {
+    ResultsBroadcastableShape, Commutative, Pure]> {
   let summary = "Returns the truth value of x XOR y element-wise.";
 
   let description = [{
     Elementwise logical XOR of input1 and input2.  Axis of size 1 will be
     broadcast as necessary.
   }];
 
   let arguments = (ins
     I1Tensor:$input1,
     I1Tensor:$input2
   );
 
   let results = (outs
     I1Tensor:$z
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: maximum
 //===----------------------------------------------------------------------===//
 def Tosa_MaximumOp : Tosa_Op<"maximum", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, NoSideEffect, Commutative]> {
+    ResultsBroadcastableShape, Pure, Commutative]> {
   let summary = "Elementwise Maximum";
 
   let description = [{
     Elementwise max of input1 and input2. Axis of size 1 will be broadcast, as
     necessary.
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1,
     Tosa_Tensor:$input2
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: minimum
 //===----------------------------------------------------------------------===//
 def Tosa_MinimumOp : Tosa_Op<"minimum", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, NoSideEffect, Commutative]> {
+    ResultsBroadcastableShape, Pure, Commutative]> {
   let summary = "Elementwise Minimum";
 
   let description = [{
     Elementwise minimum of input1 and input2. Axis of size 1
     will be broadcast, as necessary.
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1,
     Tosa_Tensor:$input2
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: mul
 //===----------------------------------------------------------------------===//
 def Tosa_MulOp : Tosa_Op<"mul", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, NoSideEffect, Commutative]> {
+    ResultsBroadcastableShape, Pure, Commutative]> {
   let summary = "Multiplication operator";
 
   let description = [{
     Elementwise multiplication (Hadamard product) of input1 and input2.
     Axis of size 1 will be broadcast, as necessary.
   }];
 
   let arguments = (ins

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: pow
 //===----------------------------------------------------------------------===//
 def Tosa_PowOp : Tosa_Op<"pow", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, NoSideEffect]> {
+    ResultsBroadcastableShape, Pure]> {
   let summary = "Computes the power of one value to another.";
 
   let description = [{
     Elementwise input1 raised to the power of input2.
     Axis of size 1 will be broadcast, as necessary.
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1,
     Tosa_Tensor:$input2
   );
 
   let results = (outs
     Tosa_Tensor:$z
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: sub
 //===----------------------------------------------------------------------===//
 def Tosa_SubOp : Tosa_Op<"sub", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, NoSideEffect]> {
+    ResultsBroadcastableShape, Pure]> {
   let summary = "Elementwise subtraction operator";
 
   let description = [{
     Elementwise subtraction of input1 and input2. Axis of size 1 will be
     broadcast as necessary.
   }];
 
   let arguments = (ins

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: table
 //===----------------------------------------------------------------------===//
 def Tosa_TableOp : Tosa_Op<"table", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Table lookup op";
 
   let description = [{
     Interpolated table lookup operation. Input values are scaled to create a
     fixed-point 9.7 value.    The high 9 bits are used to index into the table.
     The fractional bits are used to interpolate based on the looked up value and
     the index+1 value in the table. The TABLE operator then returns a 16.7
     interpolated value. Note that there must be 513 values to handle the full

 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Operator: abs
 //===----------------------------------------------------------------------===//
 def Tosa_AbsOp : Tosa_Op<"abs", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Elementwise abs op";
 
   let description = [{
     Elementwise absolute value operation
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: bitwise_not
 //===----------------------------------------------------------------------===//
 def Tosa_BitwiseNotOp : Tosa_Op<"bitwise_not", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, NoSideEffect]> {
+    ResultsBroadcastableShape, Pure]> {
   let summary = "Bitwise NOT operator";
 
   let description = [{
     Elementwise bitwise NOT of input tensor.
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: ceil
 //===----------------------------------------------------------------------===//
 def Tosa_CeilOp : Tosa_Op<"ceil", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Elementwise ceil op";
 
   let description = [{
     Elementwise ceiling operation
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: clz
 //===----------------------------------------------------------------------===//
 def Tosa_ClzOp : Tosa_Op<"clz", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Elementwise count leading zero op";
 
   let description = [{
     Elementwise count leading zeros operation
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: exp
 //===----------------------------------------------------------------------===//
 def Tosa_ExpOp : Tosa_Op<"exp", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Elementwise exp op";
 
   let description = [{
     Elementwise e to the x operation
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: floor
 //===----------------------------------------------------------------------===//
 def Tosa_FloorOp : Tosa_Op<"floor", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Elementwise floor op";
 
   let description = [{
     Elementwise floor operation
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: log
 //===----------------------------------------------------------------------===//
 def Tosa_LogOp : Tosa_Op<"log", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Elementwise log op";
 
   let description = [{
     Elementwise natural logarithm operation
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: logical_not
 //===----------------------------------------------------------------------===//
 def Tosa_LogicalNotOp : Tosa_Op<"logical_not", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect, SameOperandsAndResultType]> {
+    Pure, SameOperandsAndResultType]> {
   let summary = "Returns the truth value of NOT x element-wise.";
 
   let description = [{
     Elementwise logical NOT of input.
   }];
 
   let arguments = (ins
     I1Tensor:$input1
   );
 
   let results = (outs
     I1Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: negate
 //===----------------------------------------------------------------------===//
 def Tosa_NegateOp : Tosa_Op<"negate", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Elementwise negate op";
 
   let description = [{
     Elementwise negation operation
   }];
 
   let arguments = (ins
       Tosa_Tensor:$input1,
       OptionalAttr<Tosa_UnaryOpQuantizationAttr>:$quantization_info
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 
   let builders = [Tosa_UnaryOpQuantInfoBuilder];
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: reciprocal
 //===----------------------------------------------------------------------===//
 def Tosa_ReciprocalOp : Tosa_Op<"reciprocal", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Elementwise reciprocal op";
 
   let description = [{
     Elementwise reciprocal operation. For integer operation, a TABLE should be
     used with the appropriate ranges.
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: rsqrt
 //===----------------------------------------------------------------------===//
 def Tosa_RsqrtOp : Tosa_Op<"rsqrt", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Elementwise 1/sqrt op";
 
   let description = [{
     Elementwise reciprocal square root operation. For integer operation, a TABLE
     should be used with the appropriate ranges.
   }];
 
   let arguments = (ins

 // Operator Subclass: Elementwise ternary ops.
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Operator: select
 //===----------------------------------------------------------------------===//
 def Tosa_SelectOp : Tosa_Op<"select", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
-                              ["inferReturnTypeComponents"]>, NoSideEffect]> {
+                              ["inferReturnTypeComponents"]>, Pure]> {
   let summary = "Elementwise select operator";
 
   let description = [{
     Elementwise select of the output based on a condition.
   }];
 
   let arguments = (ins
     I1Tensor:$pred,

 // TOSA Spec Section 2.7
 // Operator Class: Logical Operations.
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Operator: equal
 //===----------------------------------------------------------------------===//
 def Tosa_EqualOp : Tosa_Op<"equal", [InferTensorType, ResultsBroadcastableShape,
-    Commutative, NoSideEffect]> {
+    Commutative, Pure]> {
   let summary = "Returns the truth value of (x == y) element-wise.";
 
   let description = [{
      Elementwise comparison operation
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1,

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: greater
 //===----------------------------------------------------------------------===//
 def Tosa_GreaterOp : Tosa_Op<"greater", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, NoSideEffect]> {
+    ResultsBroadcastableShape, Pure]> {
   let summary = "Returns the truth value of (x > y) element-wise.";
 
   let description = [{
     Elementwise greater than comparison operation
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1,
     Tosa_Tensor:$input2
   );
 
   let results = (outs
     I1Tensor:$output
   );
 
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: greater_equal
 //===----------------------------------------------------------------------===//
 def Tosa_GreaterEqualOp : Tosa_Op<"greater_equal", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    ResultsBroadcastableShape, NoSideEffect]> {
+    ResultsBroadcastableShape, Pure]> {
   let summary = "Returns the truth value of (x >= y) element-wise.";
 
   let description = [{
     Elementwise comparison operation
   }];
 
   let arguments = (ins
     Tosa_Tensor:$input1,

 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Operator: reduce_all
 //===----------------------------------------------------------------------===//
 def Tosa_ReduceAllOp : Tosa_Op<"reduce_all", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Reduce All operator";
 
   let description = [{
     Reduce a tensor along the given axis with a logical AND operation
   }];
 
   let arguments = (ins
     Tosa_Tensor1Dto4D:$input,
     I64Attr:$axis
   );
 
   let results = (outs
     Tosa_Tensor1Dto4D:$output
   );
 
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: reduce_any
 //===----------------------------------------------------------------------===//
 def Tosa_ReduceAnyOp : Tosa_Op<"reduce_any", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Reduce Any operator";
 
   let description = [{
     Reduce a tensor along the given axis with a logical OR operation
   }];
 
   let arguments = (ins
     Tosa_Tensor1Dto4D:$input,
     I64Attr:$axis
   );
 
   let results = (outs
     Tosa_Tensor1Dto4D:$output
   );
 
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: reduce_max
 //===----------------------------------------------------------------------===//
 def Tosa_ReduceMaxOp : Tosa_Op<"reduce_max", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Reduce Max operator";
 
   let description = [{
     Reduce a tensor along the given axis with a maximum operation
   }];
 
   let arguments = (ins
     Tosa_Tensor1Dto4D:$input,
     I64Attr:$axis
   );
 
   let results = (outs
     Tosa_Tensor1Dto4D:$output
   );
 
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: reduce_min
 //===----------------------------------------------------------------------===//
 def Tosa_ReduceMinOp : Tosa_Op<"reduce_min", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Reduce Min operator";
 
   let description = [{
     Reduce a tensor along the given axis with a minimum operation
   }];
 
   let arguments = (ins
     Tosa_Tensor1Dto4D:$input,
     I64Attr:$axis
   );
 
   let results = (outs
     Tosa_Tensor1Dto4D:$output
   );
 
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: reduce_prod
 //===----------------------------------------------------------------------===//
 def Tosa_ReduceProdOp : Tosa_Op<"reduce_prod", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Reduce Prod operator";
 
   let description = [{
     Reduce a tensor along the given axis by computing the product of the axis.
   }];
 
   let arguments = (ins
     Tosa_Tensor1Dto4D:$input,
     I64Attr:$axis
   );
 
   let results = (outs
     Tosa_Tensor1Dto4D:$output
   );
 
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: reduce_sum
 //===----------------------------------------------------------------------===//
 def Tosa_ReduceSumOp : Tosa_Op<"reduce_sum", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Reduce Sum operator";
 
   let description = [{
     Reduce a tensor along the given axis by computing the sum of the axis.
   }];
 
   let arguments = (ins
     Tosa_Tensor1Dto4D:$input,

 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Operator: concat
 //===----------------------------------------------------------------------===//
 def Tosa_ConcatOp : Tosa_Op<"concat", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Concatenates tensors along one dimension.";
 
   let description = [{
     Concatenate a variadic amount of tensors along a given axis. No data
     conversion happens during a concat operation.
   }];
 
   let arguments = (ins

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: pad
 //===----------------------------------------------------------------------===//
 def Tosa_PadOp : Tosa_Op<"pad", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Pads a tensor with value specified.";
 
   let description = [{
     Pads a tensor along borders of each dimension with pad_value.
   }];
 
   let arguments = (ins
     Tosa_RankedTensor:$input1,

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: reshape
 //===----------------------------------------------------------------------===//
 def Tosa_ReshapeOp: Tosa_Op<"reshape", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-    NoSideEffect]> {
+    Pure]> {
   let summary = "Reshape operator";
 
   let description = [{
     Returns a tensor with the same type/values as the input, with a new shape
     specified by the shape argument. Reshape may operate on tensors of any rank.
     No data conversion happens during a reshape operation.
   }];
 
def Tosa_ReshapeOp: Tosa_Op<"reshape", [
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: reverse
 //===----------------------------------------------------------------------===//
 def Tosa_ReverseOp: Tosa_Op<"reverse", [
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
-                              ["inferReturnTypeComponents"]>, NoSideEffect]> {
+                              ["inferReturnTypeComponents"]>, Pure]> {
   let summary = "Reverse operator";
 
   let description = [{
     Returns a tensor with the same type/values as the input, with the data
     reversed along the given axis. No data conversion happens during a reverse
     operation.
   }];
 
def Tosa_ReverseOp: Tosa_Op<"reverse", [
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: slice
 //===----------------------------------------------------------------------===//
 def Tosa_SliceOp: Tosa_Op<"slice", [
       DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
-                              ["inferReturnTypeComponents"]>, NoSideEffect]> {
+                              ["inferReturnTypeComponents"]>, Pure]> {
   let summary = "Slice operator";
 
   let description = [{
     Extracts a slice of the input1 on the given axis, beginning at the
     start coordinates, and extending for size elements in each direction.  No
     data conversion happens during a slice operation.
   }];
 

 }
 
 //===----------------------------------------------------------------------===//
 // Operator: tile
 //===----------------------------------------------------------------------===//
 def Tosa_TileOp: Tosa_Op<"tile", [
       DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-      NoSideEffect]> {
+      Pure]> {
   let summary = "Tile operator";
 
   let description = [{
     Replicates input 0 multiplies times along each dimension.
   }];
 
   let arguments = (ins
     Tosa_Tensor1Dto4D:$input1,
     I64ArrayAttr:$multiples);
 
   let results = (outs
     Tosa_Tensor1Dto4D:$output
   );
 
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: transpose
 //===----------------------------------------------------------------------===//
 def Tosa_TransposeOp : Tosa_Op<"transpose", [
       DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-      NoSideEffect]> {
+      Pure]> {
   let summary = "Transpose operator";
 
   let description = [{
     Permutes the dimensions based on perm.
   }];
 
   let arguments = (ins
     Tosa_Tensor1Dto6D:$input1,

 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Operator: gather
 //===----------------------------------------------------------------------===//
 def Tosa_GatherOp : Tosa_Op<"gather", [
       DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-      NoSideEffect]> {
+      Pure]> {
   let summary = "Gather operation,";
 
   let description = [{
     Generate a tensor for which each element in the output is a slice of the
     values tensor based on the value of indices.
   }];
 
   let arguments = (ins
     Tosa_Tensor3D:$values,
     2DTensorOf<[Tosa_Int32]>:$indices
   );
 
   let results = (outs
     Tosa_Tensor3D:$output
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: scatter
 //===----------------------------------------------------------------------===//
 def Tosa_ScatterOp : Tosa_Op<"scatter", [
       DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-      NoSideEffect]> {
+      Pure]> {
   let summary = "Scatter operation,";
 
   let description = [{
     The values_out tensor is set to the values_in tensor with data modified as follows:
     data from the input tensor is inserted at the positions specified by the indices tensor.
   }];
 
   let arguments = (ins

 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Operator: resize
 //===----------------------------------------------------------------------===//
 def Tosa_ResizeOp : Tosa_Op<"resize", [
       DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>,
-      NoSideEffect]> {
+      Pure]> {
 
   let summary = "Resize operation, supports various resize/upsample modes";
 
   let description = [{
     Resizes a tensor. Resize is only allowed in the H and W dimensions. In
     expected use, The height dimension is scaled by factor (scale_y_n/scale_y_d).
     And the width dimension is scaled by factor (scale_x_n/scale_x_d). Thus the
     output dimensions can be derived from the input dimensions by inverting the

 //===----------------------------------------------------------------------===//
 // TOSA Spec Section 2.12
 // Operator Class: Type Conversion.
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Operator: cast
 //===----------------------------------------------------------------------===//
-def Tosa_CastOp: Tosa_Op<"cast", [NoSideEffect,
+def Tosa_CastOp: Tosa_Op<"cast", [Pure,
       DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>]> {
 
   let summary = "Cast operation";
 
   let description = [{
     Performs a set of permissible cast operations
         Mode                    Input   Output
def Tosa_CastOp: Tosa_Op<"cast", [Pure,
   );
 
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: rescale
 //===----------------------------------------------------------------------===//
-def Tosa_RescaleOp: Tosa_Op<"rescale", [NoSideEffect,
+def Tosa_RescaleOp: Tosa_Op<"rescale", [Pure,
       DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>]> {
   let summary = "Tosa rescale operator";
 
   let description = [{
     Rescale quantized values into a new domain. Supported rescalings are:
     Mode                    Input   Output
     signed 8 to 8           int8    int8

 //===----------------------------------------------------------------------===//
 // TOSA Spec Section 2.13
 // Operator Class: Data Node Ops.
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Operator: const
 //===----------------------------------------------------------------------===//
-def Tosa_ConstOp : Tosa_Op<"const", [ConstantLike, NoSideEffect,
+def Tosa_ConstOp : Tosa_Op<"const", [ConstantLike, Pure,
                                      FirstAttrDerivedResultType]> {
   let summary = "Constant op.";
 
   let description = [{
     A node containing constant data for use as the input to an operation. May
     hold data in any of the supported data formats.
   }];
 
   let arguments = (ins
     ElementsAttr:$value
   );
 
   let results = (outs
     Tosa_Tensor:$output
   );
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: identity
 //===----------------------------------------------------------------------===//
-def Tosa_IdentityOp: Tosa_Op<"identity", [NoSideEffect,
+def Tosa_IdentityOp: Tosa_Op<"identity", [Pure,
       DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                               ["inferReturnTypeComponents"]>]> {
   let summary = "Identity operator";
   let description = [{
     Returns a tensor with the same shape, size, type
     and content as the input.
   }];
 

 //===----------------------------------------------------------------------===//
 //===----------------------------------------------------------------------===//
 // Further described in docs/Rationale/RationaleTOSADialect.md .
 //===----------------------------------------------------------------------===//
 def Tosa_IfOp : Tosa_Op<"cond_if", [
       DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                                 ["inferReturnTypeComponents"]>,
        SingleBlockImplicitTerminator<"YieldOp">,
-       RecursiveSideEffects]> {
+       RecursiveMemoryEffects]> {
   let summary = "Conditional if operator";
 
   let description = [{
     Evaluates a Boolean condition and then takes one of two distinct execution
     paths. This implements the semantic If-then-else structure.
   }];
 
   let arguments = (ins

 //===----------------------------------------------------------------------===//
 // Further described in docs/Rationale/RationaleTOSADialect.md .
 //===----------------------------------------------------------------------===//
 def Tosa_WhileOp : Tosa_Op<"while_loop", [
        DeclareOpInterfaceMethods<LoopLikeOpInterface>,
        DeclareOpInterfaceMethods<InferShapedTypeOpInterface,
                                  ["inferReturnTypeComponents"]>,
        SingleBlockImplicitTerminator<"YieldOp">,
-       RecursiveSideEffects]> {
+       RecursiveMemoryEffects]> {
   let summary = "output = input; While (Cond(output)) {output = Body(output)}";
 
   let description = [{
     Generates and evaluates a Bool condition and either executes a loop body or
     exits to another control point. This action is performed repeatedly after
     updating and re-evaluating the Boolean condition every iteration. This
     implements the semantic foreach or while iterative loop structure.
   }];

mlir/include/mlir/Dialect/Tosa/IR/TosaUtilOps.td

 
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/LoopLikeInterface.td"
 include "mlir/Dialect/Tosa/IR/TosaInterfaces.td"
 
 include "mlir/Dialect/Tosa/IR/TosaTypesBase.td"
 include "mlir/Dialect/Tosa/IR/TosaOpBase.td"
 
-def Tosa_ApplyScaleOp: Tosa_Op<"apply_scale", [NoSideEffect] # ElementwiseMappable.traits> {
+def Tosa_ApplyScaleOp: Tosa_Op<"apply_scale", [Pure] # ElementwiseMappable.traits> {
   let summary = "Rescale scalar operator for Tosa tensor operators";
 
   let description = [{
     Applies rescaling for fixed point values. This behavior is replicated in
     multiple quantized operations (mul, convolution, rescale, matmul, pooling).
 
     The commonplace implementation is to use i64 operations to avoid integer
     overflow with target specific implementations can use native operations to
def Tosa_ApplyScaleOp: Tosa_Op<"apply_scale", [Pure] # ElementwiseMappable.traits> {
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: yield
 //===----------------------------------------------------------------------===//
 def Tosa_YieldOp : Tosa_Op<"yield", [
        Terminator,
-       NoSideEffect]> {
+       Pure]> {
   let summary = "yield operator";
 
   let description = [{
     return operation within the conditional and body of
     structured control flow. Operation takes variadic operands
     but produces no results of its own.
   }];
 
   let arguments = (ins
     Variadic<Tosa_Tensor>:$inputs
   );
 }
 
 #endif // TOSA_UTIL_OPS

mlir/include/mlir/Dialect/Transform/IR/TransformOps.td

let extraClassDeclaration = [{
     static StringRef getDefaultDialect() { return "transform"; }
   }];
 
   let hasVerifier = 1;
 }
 
 def WithPDLPatternsOp : TransformDialectOp<"with_pdl_patterns",
     [DeclareOpInterfaceMethods<TransformOpInterface>, NoTerminator,
-     OpAsmOpInterface, PossibleTopLevelTransformOpTrait, RecursiveSideEffects,
+     OpAsmOpInterface, PossibleTopLevelTransformOpTrait, RecursiveMemoryEffects,
      SymbolTable]> {
   let summary = "Contains PDL patterns available for use in transforms";
   let description = [{
     This op contains a set of named PDL patterns that are available for the
     Transform dialect operations to be used for pattern matching. For example,
     PDLMatchOp can be used to produce a Transform IR value associated with all
     Payload IR operations that match the pattern as follows:
 

mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

 
 def IteratorTypeArrayAttr : TypedArrayAttrBase<IteratorTypeEnum,
     "Iterator type should be an enum.">;
 
 // TODO: Add an attribute to specify a different algebra with operators other
 // than the current set: {*, +}.
 def Vector_ContractionOp :
   Vector_Op<"contract", [
-      NoSideEffect,
+      Pure,
       PredOpTrait<"lhs and rhs have same element type", TCopVTEtIsSameAs<0, 1>>,
       PredOpTrait<"third operand acc and result have same element type",
                   TCresVTEtIsSameAsOpBase<0, 2>>,
       DeclareOpInterfaceMethods<VectorUnrollOpInterface, ["getShapeForUnroll"]>
     ]>,
     Arguments<(ins AnyVector:$lhs, AnyVector:$rhs, AnyType:$acc,
                Variadic<VectorOf<[I1]>>:$masks,
                ArrayAttr:$indexing_maps,
def Vector_ContractionOp :
   }];
 
   let hasCanonicalizer = 1;
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
 def Vector_ReductionOp :
-  Vector_Op<"reduction", [NoSideEffect,
+  Vector_Op<"reduction", [Pure,
      PredOpTrait<"source operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>,
      DeclareOpInterfaceMethods<VectorUnrollOpInterface,
                                ["getShapeForUnroll"]>]>,
     Arguments<(ins Vector_CombiningKindAttr:$kind,
                AnyVectorOfAnyRank:$vector,
                Optional<AnyType>:$acc)>,
     Results<(outs AnyType:$dest)> {
def Vector_ReductionOp :
   // TODO: Migrate to assemblyFormat once `AllTypesMatch` supports optional
   // operands.
   let hasCustomAssemblyFormat = 1;
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
 }
 
 def Vector_MultiDimReductionOp :
-  Vector_Op<"multi_reduction", [NoSideEffect,
+  Vector_Op<"multi_reduction", [Pure,
      AllTypesMatch<["dest", "acc"]>,
      PredOpTrait<"source operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>,
      DeclareOpInterfaceMethods<InferTypeOpInterface>,
      DeclareOpInterfaceMethods<VectorUnrollOpInterface,
                                ["getShapeForUnroll"]>]>,
     Arguments<(ins Vector_CombiningKindAttr:$kind,
                    AnyVector:$source,
def Vector_MultiDimReductionOp :
   let assemblyFormat =
     "$kind `,` $source `,` $acc attr-dict $reduction_dims `:` type($source) `to` type($dest)";
   let hasFolder = 1;
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
 }
 
 def Vector_BroadcastOp :
-  Vector_Op<"broadcast", [NoSideEffect,
+  Vector_Op<"broadcast", [Pure,
      PredOpTrait<"source operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>]>,
     Arguments<(ins AnyType:$source)>,
     Results<(outs AnyVectorOfAnyRank:$vector)> {
   let summary = "broadcast operation";
   let description = [{
     Broadcasts the scalar or k-D vector value in the source operand
     to a n-D result vector such that the broadcast makes sense, i.e.,
def Vector_BroadcastOp :
   }];
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($vector)";
   let hasFolder = 1;
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
 }
 
 def Vector_ShuffleOp :
-  Vector_Op<"shuffle", [NoSideEffect,
+  Vector_Op<"shuffle", [Pure,
      PredOpTrait<"first operand v1 and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>,
      PredOpTrait<"second operand v2 and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 1>>,
      DeclareOpInterfaceMethods<InferTypeOpInterface>]>,
      Arguments<(ins AnyVectorOfAnyRank:$v1, AnyVectorOfAnyRank:$v2,
                     I64ArrayAttr:$mask)>,
      Results<(outs AnyVector:$vector)> {
let extraClassDeclaration = [{
     }
   }];
   let assemblyFormat = "operands $mask attr-dict `:` type(operands)";
   let hasVerifier = 1;
   let hasCanonicalizer = 1;
 }
 
 def Vector_ExtractElementOp :
-  Vector_Op<"extractelement", [NoSideEffect,
+  Vector_Op<"extractelement", [Pure,
      TypesMatchWith<"result type matches element type of vector operand",
                     "vector", "result",
                     "$_self.cast<ShapedType>().getElementType()">]>,
     Arguments<(ins AnyVectorOfAnyRank:$vector,
                    Optional<AnySignlessIntegerOrIndex>:$position)>,
     Results<(outs AnyType:$result)> {
   let summary = "extractelement operation";
   let description = [{
VectorType getVectorType() {
       return getVector().getType().cast<VectorType>();
     }
   }];
   let hasVerifier = 1;
   let hasFolder = 1;
 }
 
 def Vector_ExtractOp :
-  Vector_Op<"extract", [NoSideEffect,
+  Vector_Op<"extract", [Pure,
      PredOpTrait<"operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>,
      DeclareOpInterfaceMethods<InferTypeOpInterface>]>,
     Arguments<(ins AnyVector:$vector, I64ArrayAttr:$position)>,
     Results<(outs AnyType)> {
   let summary = "extract operation";
   let description = [{
     Takes an n-D vector and a k-D position and extracts the (n-k)-D vector at
def Vector_ExtractOp :
   let assemblyFormat = "$vector `` $position attr-dict `:` type($vector)";
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
 def Vector_FMAOp :
   Op<Vector_Dialect, "fma", [
-       NoSideEffect, AllTypesMatch<["lhs", "rhs", "acc", "result"]>,
+       Pure, AllTypesMatch<["lhs", "rhs", "acc", "result"]>,
        DeclareOpInterfaceMethods<VectorUnrollOpInterface, ["getShapeForUnroll"]>
      ] # ElementwiseMappable.traits>,
     Arguments<(ins AnyVectorOfAnyRank:$lhs,
                    AnyVectorOfAnyRank:$rhs,
                    AnyVectorOfAnyRank:$acc)>,
     Results<(outs AnyVectorOfAnyRank:$result)> {
   let summary = "vector fused multiply-add";
   let description = [{
def Vector_FMAOp :
   }];
   let assemblyFormat = "$lhs `,` $rhs `,` $acc attr-dict `:` type($lhs)";
   let extraClassDeclaration = [{
     VectorType getVectorType() { return getLhs().getType().cast<VectorType>(); }
   }];
 }
 
 def Vector_InsertElementOp :
-  Vector_Op<"insertelement", [NoSideEffect,
+  Vector_Op<"insertelement", [Pure,
      TypesMatchWith<"source operand type matches element type of result",
                     "result", "source",
                     "$_self.cast<ShapedType>().getElementType()">,
      AllTypesMatch<["dest", "result"]>]>,
      Arguments<(ins AnyType:$source, AnyVectorOfAnyRank:$dest,
                     Optional<AnySignlessIntegerOrIndex>:$position)>,
      Results<(outs AnyVectorOfAnyRank:$result)> {
   let summary = "insertelement operation";
VectorType getDestVectorType() {
       return getDest().getType().cast<VectorType>();
     }
   }];
   let hasVerifier = 1;
   let hasFolder = 1;
 }
 
 def Vector_InsertOp :
-  Vector_Op<"insert", [NoSideEffect,
+  Vector_Op<"insert", [Pure,
      PredOpTrait<"source operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>,
      AllTypesMatch<["dest", "res"]>]>,
      Arguments<(ins AnyType:$source, AnyVector:$dest, I64ArrayAttr:$position)>,
      Results<(outs AnyVector:$res)> {
   let summary = "insert operation";
   let description = [{
     Takes an n-D source vector, an (n+k)-D destination vector and a k-D position
def Vector_InsertOp :
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
 def Vector_InsertStridedSliceOp :
-  Vector_Op<"insert_strided_slice", [NoSideEffect,
+  Vector_Op<"insert_strided_slice", [Pure,
     PredOpTrait<"operand #0 and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>,
     AllTypesMatch<["dest", "res"]>]>,
     Arguments<(ins AnyVector:$source, AnyVector:$dest, I64ArrayAttr:$offsets,
                I64ArrayAttr:$strides)>,
     Results<(outs AnyVector:$res)> {
   let summary = "strided_slice operation";
   let description = [{
def Vector_InsertStridedSliceOp :
   }];
 
   let hasFolder = 1;
   let hasVerifier = 1;
   let hasCanonicalizer = 1;
 }
 
 def Vector_OuterProductOp :
-  Vector_Op<"outerproduct", [NoSideEffect,
+  Vector_Op<"outerproduct", [Pure,
     PredOpTrait<"lhs operand and result have same element type",
                 TCresVTEtIsSameAsOpBase<0, 0>>,
     PredOpTrait<"rhs operand and result have same element type",
                 TCresVTEtIsSameAsOpBase<0, 1>>]>,
     Arguments<(ins AnyVector:$lhs, AnyType:$rhs,
                Variadic<AnyVector>:$acc,
                DefaultValuedAttr<Vector_CombiningKindAttr, "CombiningKind::ADD">:$kind)>,
     Results<(outs AnyVector)> {
def Vector_OuterProductOp :
   }];
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
 // TODO: Add transformation which decomposes ReshapeOp into an optimized
 // sequence of vector rotate/shuffle/select operations.
 def Vector_ReshapeOp :
-  Vector_Op<"reshape", [AttrSizedOperandSegments, NoSideEffect]>,
+  Vector_Op<"reshape", [AttrSizedOperandSegments, Pure]>,
     Arguments<(ins AnyVector:$vector, Variadic<Index>:$input_shape,
                Variadic<Index>:$output_shape,
                I64ArrayAttr:$fixed_vector_sizes)>,
     Results<(outs AnyVector:$result)> {
   let summary = "vector reshape operation";
   let description = [{
     Reshapes its vector operand from 'input_shape' to 'output_shape' maintaining
     fixed vector dimension 'fixed_vector_sizes' on the innermost vector
def Vector_ReshapeOp :
   let assemblyFormat = [{
     $vector `,` `[` $input_shape `]` `,` `[` $output_shape `]` `,`
     $fixed_vector_sizes attr-dict `:` type($vector) `to` type($result)
   }];
   let hasVerifier = 1;
 }
 
 def Vector_ExtractStridedSliceOp :
-  Vector_Op<"extract_strided_slice", [NoSideEffect,
+  Vector_Op<"extract_strided_slice", [Pure,
     PredOpTrait<"operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>]>,
     Arguments<(ins AnyVector:$vector, I64ArrayAttr:$offsets,
                I64ArrayAttr:$sizes, I64ArrayAttr:$strides)>,
     Results<(outs AnyVector)> {
   let summary = "extract_strided_slice operation";
   let description = [{
     Takes an n-D vector, k-D `offsets` integer array attribute, a k-sized
def Vector_CompressStoreOp :
   let assemblyFormat =
       "$base `[` $indices `]` `,` $mask `,` $valueToStore attr-dict `:` "
       "type($base) `,` type($mask) `,` type($valueToStore)";
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
 }
 
 def Vector_ShapeCastOp :
-  Vector_Op<"shape_cast", [NoSideEffect]>,
+  Vector_Op<"shape_cast", [Pure]>,
     Arguments<(ins AnyVector:$source)>,
     Results<(outs AnyVector:$result)> {
   let summary = "shape_cast casts between vector shapes";
   let description = [{
     The shape_cast operation casts between an n-D source vector shape and
     a k-D result vector shape (the element type remains the same).
 
     If reducing rank (n > k), result dimension sizes must be a product
def Vector_ShapeCastOp :
   }];
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($result)";
   let hasFolder = 1;
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
 }
 
 def Vector_BitCastOp :
-  Vector_Op<"bitcast", [NoSideEffect, AllRanksMatch<["source", "result"]>]>,
+  Vector_Op<"bitcast", [Pure, AllRanksMatch<["source", "result"]>]>,
     Arguments<(ins AnyVectorOfAnyRank:$source)>,
     Results<(outs AnyVectorOfAnyRank:$result)>{
   let summary = "bitcast casts between vectors";
   let description = [{
     The bitcast operation casts between vectors of the same rank, the minor 1-D
     vector size is casted to a vector with a different element type but same
     bitwidth. In case of 0-D vectors, the bitwidth of element types must be
     equal.
let extraClassDeclaration = [{
     }
   }];
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($result)";
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
 def Vector_TypeCastOp :
-  Vector_Op<"type_cast", [NoSideEffect, ViewLikeOpInterface]>,
+  Vector_Op<"type_cast", [Pure, ViewLikeOpInterface]>,
     Arguments<(ins StaticShapeMemRefOf<[AnyType]>:$memref)>,
     Results<(outs AnyMemRef:$result)> {
   let summary = "type_cast op converts a scalar memref to a vector memref";
   let description = [{
     Performs a conversion from a memref with scalar element to a memref with a
     *single* vector element, copying the shape of the memref to the vector. This
     is the minimal viable operation that is required to makeke
     super-vectorization operational. It can be seen as a special case of the
def Vector_TypeCastOp :
 
   let assemblyFormat = [{
     $memref attr-dict `:` type($memref) `to` type($result)
   }];
   let hasVerifier = 1;
 }
 
 def Vector_ConstantMaskOp :
-  Vector_Op<"constant_mask", [NoSideEffect]>,
+  Vector_Op<"constant_mask", [Pure]>,
     Arguments<(ins I64ArrayAttr:$mask_dim_sizes)>,
     Results<(outs VectorOfAnyRankOf<[I1]>)> {
   let summary = "creates a constant vector mask";
   let description = [{
     Creates and returns a vector mask where elements of the result vector
     are set to '0' or '1', based on whether the element indices are contained
     within a hyper-rectangular region specified by the 'mask_dim_sizes'
     array attribute argument. Each element of the 'mask_dim_sizes' array,
def Vector_ConstantMaskOp :
   let extraClassDeclaration = [{
     static StringRef getMaskDimSizesAttrStrName() { return "mask_dim_sizes"; }
   }];
   let assemblyFormat = "$mask_dim_sizes attr-dict `:` type(results)";
   let hasVerifier = 1;
 }
 
 def Vector_CreateMaskOp :
-  Vector_Op<"create_mask", [NoSideEffect]>,
+  Vector_Op<"create_mask", [Pure]>,
     Arguments<(ins Variadic<Index>:$operands)>,
     Results<(outs VectorOfAnyRankOf<[I1]>)> {
   let summary = "creates a vector mask";
   let description = [{
     Creates and returns a vector mask where elements of the result vector
     are set to '0' or '1', based on whether the element indices are contained
     within a hyper-rectangular region specified by the operands. Specifically,
     each operand specifies a range [0, operand-value) for a unique dimension in
def Vector_CreateMaskOp :
   }];
 
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
   let assemblyFormat = "$operands attr-dict `:` type(results)";
 }
 
 def Vector_TransposeOp :
-  Vector_Op<"transpose", [NoSideEffect,
+  Vector_Op<"transpose", [Pure,
     DeclareOpInterfaceMethods<VectorUnrollOpInterface, ["getShapeForUnroll"]>,
     PredOpTrait<"operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>]>,
     Arguments<(ins AnyVectorOfAnyRank:$vector, I64ArrayAttr:$transp)>,
     Results<(outs AnyVectorOfAnyRank:$result)> {
   let summary = "vector transpose operation";
   let description = [{
     Takes a n-D vector and returns the transposed n-D vector defined by

 // to the hardware ISA.
 //===----------------------------------------------------------------------===//
 
 /// Vector dialect matrix multiplication op that operates on flattened 1-D
 /// MLIR vectors. This is the counterpart of llvm.matrix.multiply in MLIR.
 /// This may seem redundant with vector.contract but it serves the purposes of
 /// more progressive lowering and localized type conversion on the path:
 ///   `vector<...x...xf32> -> vector<...xf32> -> !llvm<... x float>`.
-def Vector_MatmulOp : Vector_Op<"matrix_multiply", [NoSideEffect,
+def Vector_MatmulOp : Vector_Op<"matrix_multiply", [Pure,
         PredOpTrait<"lhs operand and result have same element type",
                     TCresVTEtIsSameAsOpBase<0, 0>>,
         PredOpTrait<"rhs operand and result have same element type",
                     TCresVTEtIsSameAsOpBase<0, 1>>]>,
       Arguments<(
         // TODO: tighten vector element types that make sense.
         ins VectorOfRankAndType<[1],
               [AnySignlessInteger, AnySignedInteger, Index, AnyFloat]>:$lhs,
let assemblyFormat = "$lhs `,` $rhs attr-dict "
     "`:` `(` type($lhs) `,` type($rhs) `)` `->` type($res)";
 }
 
 /// Vector dialect matrix tranposition op that operates on flattened 1-D
 /// MLIR vectors. This is the counterpart of llvm.matrix.transpose in MLIR.
 /// This may seem redundant with vector.transpose but it serves the purposes of
 /// more progressive lowering and localized type conversion on the path:
 ///   `vector<...x...xf32> -> vector<...xf32> -> !llvm<... x float>`.
-def Vector_FlatTransposeOp : Vector_Op<"flat_transpose", [NoSideEffect,
+def Vector_FlatTransposeOp : Vector_Op<"flat_transpose", [Pure,
   PredOpTrait<"source operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>]>,
     Arguments<(
       // TODO: tighten vector element types that make sense.
       ins VectorOfRankAndType<[1],
             [AnySignlessInteger, AnySignedInteger, Index, AnyFloat]>:$matrix,
           I32Attr:$rows, I32Attr:$columns)>,
     Results<(
def Vector_FlatTransposeOp : Vector_Op<"flat_transpose", [Pure,
   let assemblyFormat = "$matrix attr-dict `:` type($matrix) `->` type($res)";
 }
 
 //===----------------------------------------------------------------------===//
 // SplatOp
 //===----------------------------------------------------------------------===//
 
 def Vector_SplatOp : Vector_Op<"splat", [
-    NoSideEffect,
+    Pure,
     TypesMatchWith<"operand type matches element type of result",
                    "aggregate", "input",
                    "$_self.cast<VectorType>().getElementType()">
   ]> {
   let summary = "vector splat or broadcast operation";
   let description = [{
     Broadcast the operand to all elements of the result vector. The operand is
     required to be of integer/index/float type.

 //       scales for different dimensions. E.g.: vector<[16]x[16]xf32>, in
 //       which case we might need to add an index to 'vscale' to select one
 //       of them. In order to support GPUs, we might also want to differentiate
 //       between a 'global' scale, a scale that's fixed throughout the
 //       execution, and a 'local' scale that is fixed but might vary with each
 //       call to the function. For that, it might be useful to have a
 //       'vector.scale.global' and a 'vector.scale.local' operation.
 def VectorScaleOp : Vector_Op<"vscale",
-                 [NoSideEffect]> {
+                 [Pure]> {
   let summary = "Load vector scale size";
   let description = [{
     The `vscale` op returns the scale of the scalable vectors, a positive
     integer value that is constant at runtime but unknown at compile-time.
     The scale of the vector indicates the multiplicity of the vectors and
     vector operations. For example, a `vector<[4]xi32>` is equivalent to
     `vscale` consecutive `vector<4xi32>`; and an operation on a
     `vector<[4]xi32>` is equivalent to performing that operation `vscale`
     times, once on each `<4xi32>` segment of the scalable vector. The `vscale`
     op can be used to calculate the step in vector-length agnostic (VLA) loops.
     Right now we only support one contiguous set of scalable dimensions, all of
     them grouped and scaled with the value returned by 'vscale'.
   }];
   let results = (outs Index:$res);
   let assemblyFormat = "attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // VectorScanOp
 //===----------------------------------------------------------------------===//
 
 def Vector_ScanOp :
-  Vector_Op<"scan", [NoSideEffect,
+  Vector_Op<"scan", [Pure,
     AllTypesMatch<["source", "dest"]>,
     AllTypesMatch<["initial_value", "accumulated_value"]> ]>,
     Arguments<(ins Vector_CombiningKindAttr:$kind,
                    AnyVector:$source,
                    AnyVectorOfAnyRank:$initial_value,
                    I64Attr:$reduction_dim,
                    BoolAttr:$inclusive)>,
     Results<(outs AnyVector:$dest,
def Vector_ScanOp :
   }];
   let assemblyFormat =
     "$kind `,` $source `,` $initial_value attr-dict `:` "
     "type($source) `,` type($initial_value) ";
   let hasVerifier = 1;
 }
 
 def Vector_YieldOp : Vector_Op<"yield", [
-    NoSideEffect, ReturnLike, Terminator]> {
+    Pure, ReturnLike, Terminator]> {
   let summary = "Terminates and yields values from vector regions.";
   let description = [{
     "vector.yield" yields an SSA value from the Vector dialect op region and
     terminates the regions. The semantics of how the values are yielded is
     defined by the parent operation.
     If "vector.yield" has any operands, the operands must correspond to the
     parent operation's results.
     If the parent operation defines no value the vector.yield may be omitted
     when printing the region.
   }];
 
   let arguments = (ins Variadic<AnyType>:$operands);
 
   let builders = [
     OpBuilder<(ins), [{ /* nothing to do */ }]>,
   ];
 
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
 }
 
 def Vector_WarpExecuteOnLane0Op : Vector_Op<"warp_execute_on_lane_0",
       [DeclareOpInterfaceMethods<RegionBranchOpInterface, ["areTypesCompatible"]>,
        SingleBlockImplicitTerminator<"vector::YieldOp">,
-       RecursiveSideEffects]> {
+       RecursiveMemoryEffects]> {
   let summary = "Executes operations in the associated region on thread #0 of a"
                 "SPMD program";
   let description = [{
     `warp_execute_on_lane_0` is an operation used to bridge the gap between
     vector programming and SPMD programming model like GPU SIMT. It allows to
     trivially convert a region of vector code meant to run on a multiple threads
     into a valid SPMD region and then allows incremental transformation to
     distribute vector operations on the threads.

mlir/include/mlir/Dialect/X86Vector/X86Vector.td

LLVM_IntrOpBase<X86Vector_Dialect, "avx512.intr." # mnemonic,
                   /*list<int> overloadedResults=*/[0],
                   /*list<int> overloadedOperands=*/[],
                   traits, /*numResults=*/1>;
 
 //----------------------------------------------------------------------------//
 // MaskCompressOp
 //----------------------------------------------------------------------------//
 
-def MaskCompressOp : AVX512_Op<"mask.compress", [NoSideEffect,
+def MaskCompressOp : AVX512_Op<"mask.compress", [Pure,
   // TODO: Support optional arguments in `AllTypesMatch`. "type($src)" could
   // then be removed from assemblyFormat.
   AllTypesMatch<["a", "dst"]>,
   TypesMatchWith<"`k` has the same number of bits as elements in `dst`",
                  "dst", "k",
                  "VectorType::get({$_self.cast<VectorType>().getShape()[0]}, "
                  "IntegerType::get($_self.getContext(), 1))">]> {
   let summary = "Masked compress op";
def MaskCompressOp : AVX512_Op<"mask.compress", [Pure,
   let results = (outs VectorOfLengthAndType<[16, 8],
                                             [F32, I32, F64, I64]>:$dst);
   let assemblyFormat = "$k `,` $a (`,` $src^)? attr-dict"
                        " `:` type($dst) (`,` type($src)^)?";
   let hasVerifier = 1;
 }
 
 def MaskCompressIntrOp : AVX512_IntrOverloadedOp<"mask.compress", [
-  NoSideEffect,
+  Pure,
   AllTypesMatch<["a", "src", "res"]>,
   TypesMatchWith<"`k` has the same number of bits as elements in `res`",
                  "res", "k",
                  "VectorType::get({$_self.cast<VectorType>().getShape()[0]}, "
                  "IntegerType::get($_self.getContext(), 1))">]> {
   let arguments = (ins VectorOfLengthAndType<[16, 8],
                                              [F32, I32, F64, I64]>:$a,
                    VectorOfLengthAndType<[16, 8],
                                          [F32, I32, F64, I64]>:$src,
                    VectorOfLengthAndType<[16, 8],
                                          [I1]>:$k);
 }
 
 //----------------------------------------------------------------------------//
 // MaskRndScaleOp
 //----------------------------------------------------------------------------//
 
-def MaskRndScaleOp : AVX512_Op<"mask.rndscale", [NoSideEffect,
+def MaskRndScaleOp : AVX512_Op<"mask.rndscale", [Pure,
   AllTypesMatch<["src", "a", "dst"]>,
   TypesMatchWith<"imm has the same number of bits as elements in dst",
                  "dst", "imm",
                  "IntegerType::get($_self.getContext(), "
                  "($_self.cast<VectorType>().getShape()[0]))">]> {
   let summary = "Masked roundscale op";
   let description = [{
     The mask.rndscale op is an AVX512 specific op that can lower to the proper
let arguments = (ins VectorOfLengthAndType<[16, 8], [F32, F64]>:$src,
                    I32:$rounding
             );
   let results = (outs VectorOfLengthAndType<[16, 8], [F32, F64]>:$dst);
   let assemblyFormat =
     "$src `,` $k `,` $a `,` $imm `,` $rounding attr-dict `:` type($dst)";
 }
 
 def MaskRndScalePSIntrOp : AVX512_IntrOp<"mask.rndscale.ps.512", 1, [
-  NoSideEffect,
+  Pure,
   AllTypesMatch<["src", "a", "res"]>]> {
   let arguments = (ins VectorOfLengthAndType<[16], [F32]>:$src,
                    I32:$k,
                    VectorOfLengthAndType<[16], [F32]>:$a,
                    I16:$imm,
                    LLVM_Type:$rounding);
 }
 
 def MaskRndScalePDIntrOp : AVX512_IntrOp<"mask.rndscale.pd.512", 1, [
-  NoSideEffect,
+  Pure,
   AllTypesMatch<["src", "a", "res"]>]> {
   let arguments = (ins VectorOfLengthAndType<[8], [F64]>:$src,
                    I32:$k,
                    VectorOfLengthAndType<[8], [F64]>:$a,
                    I8:$imm,
                    LLVM_Type:$rounding);
 }
 
 //----------------------------------------------------------------------------//
 // MaskScaleFOp
 //----------------------------------------------------------------------------//
 
-def MaskScaleFOp : AVX512_Op<"mask.scalef", [NoSideEffect,
+def MaskScaleFOp : AVX512_Op<"mask.scalef", [Pure,
   AllTypesMatch<["src", "a", "b", "dst"]>,
   TypesMatchWith<"k has the same number of bits as elements in dst",
                  "dst", "k",
                  "IntegerType::get($_self.getContext(), "
                  "($_self.cast<VectorType>().getShape()[0]))">]> {
   let summary = "ScaleF op";
   let description = [{
     The `mask.scalef` op is an AVX512 specific op that can lower to the proper
let arguments = (ins VectorOfLengthAndType<[16, 8], [F32, F64]>:$src,
             );
   let results = (outs VectorOfLengthAndType<[16, 8], [F32, F64]>:$dst);
   // Fully specified by traits.
   let assemblyFormat =
     "$src `,` $a `,` $b `,` $k `,` $rounding attr-dict `:` type($dst)";
 }
 
 def MaskScaleFPSIntrOp : AVX512_IntrOp<"mask.scalef.ps.512", 1, [
-  NoSideEffect,
+  Pure,
   AllTypesMatch<["src", "a", "b", "res"]>]> {
   let arguments = (ins VectorOfLengthAndType<[16], [F32]>:$src,
                    VectorOfLengthAndType<[16], [F32]>:$a,
                    VectorOfLengthAndType<[16], [F32]>:$b,
                    I16:$k,
                    LLVM_Type:$rounding);
 }
 
 def MaskScaleFPDIntrOp : AVX512_IntrOp<"mask.scalef.pd.512", 1, [
-  NoSideEffect,
+  Pure,
   AllTypesMatch<["src", "a", "b", "res"]>]> {
   let arguments = (ins VectorOfLengthAndType<[8], [F64]>:$src,
                    VectorOfLengthAndType<[8], [F64]>:$a,
                    VectorOfLengthAndType<[8], [F64]>:$b,
                    I8:$k,
                    LLVM_Type:$rounding);
 }
 
 //----------------------------------------------------------------------------//
 // Vp2IntersectOp
 //----------------------------------------------------------------------------//
 
-def Vp2IntersectOp : AVX512_Op<"vp2intersect", [NoSideEffect,
+def Vp2IntersectOp : AVX512_Op<"vp2intersect", [Pure,
   AllTypesMatch<["a", "b"]>,
   TypesMatchWith<"k1 has the same number of bits as elements in a",
                  "a", "k1",
                  "VectorType::get({$_self.cast<VectorType>().getShape()[0]}, "
                  "IntegerType::get($_self.getContext(), 1))">,
   TypesMatchWith<"k2 has the same number of bits as elements in b",
                  // Should use `b` instead of `a`, but that would require
                  // adding `type($b)` to assemblyFormat.
def Vp2IntersectOp : AVX512_Op<"vp2intersect", [Pure,
   let results = (outs VectorOfLengthAndType<[16, 8], [I1]>:$k1,
                  VectorOfLengthAndType<[16, 8], [I1]>:$k2
                  );
   let assemblyFormat =
     "$a `,` $b attr-dict `:` type($a)";
 }
 
 def Vp2IntersectDIntrOp : AVX512_IntrOp<"vp2intersect.d.512", 2, [
-  NoSideEffect]> {
+  Pure]> {
   let arguments = (ins VectorOfLengthAndType<[16], [I32]>:$a,
                    VectorOfLengthAndType<[16], [I32]>:$b);
 }
 
 def Vp2IntersectQIntrOp : AVX512_IntrOp<"vp2intersect.q.512", 2, [
-  NoSideEffect]> {
+  Pure]> {
   let arguments = (ins VectorOfLengthAndType<[8], [I64]>:$a,
                    VectorOfLengthAndType<[8], [I64]>:$b);
 }
 
 //===----------------------------------------------------------------------===//
 // AVX op definitions
 //===----------------------------------------------------------------------===//
 
class AVX_IntrOp<string mnemonic, int numResults, list<Trait> traits = []> :
   LLVM_IntrOpBase<X86Vector_Dialect, "avx.intr." # mnemonic,
                   "x86_avx_" # !subst(".", "_", mnemonic),
                   [], [], traits, numResults>;
 
 //----------------------------------------------------------------------------//
 // AVX Rsqrt
 //----------------------------------------------------------------------------//
 
-def RsqrtOp : AVX_Op<"rsqrt", [NoSideEffect, SameOperandsAndResultType]> {
+def RsqrtOp : AVX_Op<"rsqrt", [Pure, SameOperandsAndResultType]> {
   let summary = "Rsqrt";
   let arguments = (ins VectorOfLengthAndType<[8], [F32]>:$a);
   let results = (outs VectorOfLengthAndType<[8], [F32]>:$b);
   let assemblyFormat = "$a attr-dict `:` type($a)";
 }
 
-def RsqrtIntrOp : AVX_IntrOp<"rsqrt.ps.256", 1, [NoSideEffect,
+def RsqrtIntrOp : AVX_IntrOp<"rsqrt.ps.256", 1, [Pure,
   SameOperandsAndResultType]> {
   let arguments = (ins VectorOfLengthAndType<[8], [F32]>:$a);
 }
 
 //----------------------------------------------------------------------------//
 // AVX Dot
 //----------------------------------------------------------------------------//
 
-def DotOp : AVX_LowOp<"dot", [NoSideEffect, SameOperandsAndResultType]> {
+def DotOp : AVX_LowOp<"dot", [Pure, SameOperandsAndResultType]> {
   let summary = "Dot";
   let description = [{
     Computes the 4-way dot products of the lower and higher parts of the source
     vectors and broadcasts the two results to the lower and higher elements of
     the destination vector, respectively. Adding one element of the lower part
     to one element of the higher part in the destination vector yields the full
     dot product of the two source vectors.
 
     Example:
 
     ```mlir
     %0 = x86vector.avx.intr.dot %a, %b : vector<8xf32>
     %1 = vector.extractelement %0[%i0 : i32]: vector<8xf32>
     %2 = vector.extractelement %0[%i4 : i32]: vector<8xf32>
     %d = arith.addf %1, %2 : f32
     ```
   }];
   let arguments = (ins VectorOfLengthAndType<[8], [F32]>:$a,
                        VectorOfLengthAndType<[8], [F32]>:$b);
   let results = (outs VectorOfLengthAndType<[8], [F32]>:$res);
   let assemblyFormat = "$a `,` $b attr-dict `:` type($res)";
 }
 
-def DotIntrOp : AVX_IntrOp<"dp.ps.256", 1, [NoSideEffect,
+def DotIntrOp : AVX_IntrOp<"dp.ps.256", 1, [Pure,
     AllTypesMatch<["a", "b", "res"]>]> {
   let arguments = (ins VectorOfLengthAndType<[8], [F32]>:$a,
                        VectorOfLengthAndType<[8], [F32]>:$b, I8:$c);
   let results = (outs VectorOfLengthAndType<[8], [F32]>:$res);
 }
 
 #endif // X86VECTOR_OPS

mlir/include/mlir/IR/BuiltinOps.td

def ModuleOp : Builtin_Op<"module", [
   let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // UnrealizedConversionCastOp
 //===----------------------------------------------------------------------===//
 
 def UnrealizedConversionCastOp : Builtin_Op<"unrealized_conversion_cast", [
-    DeclareOpInterfaceMethods<CastOpInterface>, NoSideEffect
+    DeclareOpInterfaceMethods<CastOpInterface>, Pure
   ]> {
   let summary = "An unrealized conversion from one set of types to another";
   let description = [{
     An `unrealized_conversion_cast` operation represents an unrealized
     conversion from one set of types to another, that is used to enable the
     inter-mixing of different type systems. This operation should not be
     attributed any special representational or execution semantics, and is
     generally only intended to be used to satisfy the temporary intermixing of

mlir/include/mlir/Interfaces/SideEffectInterfaceBase.td

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

mlir/include/mlir/Interfaces/SideEffectInterfaces.h

private:
 
   /// Additional parameters of the effect instance. An attribute is used for
   /// type-safe structured storage and context-based uniquing. Concrete effects
   /// can use this at their convenience. This is optionally null.
   Attribute parameters;
 };
 } // namespace SideEffects
 
+namespace Speculation {
+
+/// This enum is returned from the `isSpeculatable` method in the
+/// `ConditionallySpeculatable` op interface.
+enum class Speculatability {
+
+  /// The Operation in question cannot be speculatively executed.  This could be
+  /// because it may invoke undefined behavior or have other side effects.
+  NotSpeculatable,
+
+  // The Operation in question can be speculatively executed.  It does not have
+  // any side effects or undefined behavior.
+  Speculatable,
+
+  // The Operation in question can be speculatively executed if all the
+  // operations in all attached regions can also be speculatively executed.
+  RecursivelySpeculatable,
+};
+
+constexpr auto NotSpeculatable = Speculatability::NotSpeculatable;
+constexpr auto Speculatable = Speculatability::Speculatable;
+constexpr auto RecursivelySpeculatable =
+    Speculatability::RecursivelySpeculatable;
+} // namespace Speculation
+
 //===----------------------------------------------------------------------===//
 // SideEffect Traits
 //===----------------------------------------------------------------------===//
 
 namespace OpTrait {
-/// This trait indicates that the side effects of an operation includes the
+/// This trait indicates that the memory 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.
+/// memory effects.
+template <typename ConcreteType>
+class HasRecursiveMemoryEffects
+    : public TraitBase<ConcreteType, HasRecursiveMemoryEffects> {};
+
+/// This trait marks an op (which must be tagged as implementing the
+/// ConditionallySpeculatable interface) as being recursively speculatable.
+/// This means that said op can be speculated only if all the instructions in
+/// all the regions attached to the op can be speculated.
+template <typename ConcreteType>
+struct RecursivelySpeculatableImplTrait
+    : public TraitBase<ConcreteType, RecursivelySpeculatableImplTrait> {
+
+  ::mlir::Speculation::Speculatability isSpeculatable() {
+    return ::mlir::Speculation::RecursivelySpeculatable;
+  }
+};
+
+/// This trait marks an op (which must be tagged as implementing the
+/// ConditionallySpeculatable interface) as being always speculatable.
 template <typename ConcreteType>
-class HasRecursiveSideEffects
-    : public TraitBase<ConcreteType, HasRecursiveSideEffects> {};
+struct AlwaysSpeculatableImplTrait
+    : public TraitBase<ConcreteType, AlwaysSpeculatableImplTrait> {
+
+  ::mlir::Speculation::Speculatability isSpeculatable() {
+    return ::mlir::Speculation::Speculatable;
+  }
+};
 } // 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;

mlir/include/mlir/Interfaces/SideEffectInterfaces.td

 class MemWrite<Resource resource>
   : MemoryEffect<"::mlir::MemoryEffects::Write", resource>;
 def MemWrite : MemWrite<DefaultResource>;
 
 //===----------------------------------------------------------------------===//
 // Effect Traits
 //===----------------------------------------------------------------------===//
 
-// Op has no side effect.
-def NoSideEffect : MemoryEffects<[]>;
+// Op has no effect on memory but may have undefined behavior.
+def NoMemoryEffect : MemoryEffects<[]>;
+
 // Op has recursively computed side effects.
-def RecursiveSideEffects : NativeOpTrait<"HasRecursiveSideEffects">;
+def RecursiveMemoryEffects : NativeOpTrait<"HasRecursiveMemoryEffects">;
+
+// Used to inject an implementation of isSpeculatable.  Users should not use
+// this directly.
+def RecursivelySpeculatableImplTrait
+  : NativeOpTrait<"RecursivelySpeculatableImplTrait">;
+
+// Used to inject an implementation of isSpeculatable.  Users should not use
+// this directly.
+def AlwaysSpeculatableImplTrait
+  : NativeOpTrait<"AlwaysSpeculatableImplTrait">;
+
+// This op interface enables Op authors to inject custom logic to determine
+// whether an Operation can be speculatively executed.  Ops that implement this
+// interface need to implement the custom logic in the `isSpeculatable` method.
+// For instance, the `isSpeculatable` for a specific op may check the attributes
+// or input types to determine whether that specific Operation is speculatable.
+def ConditionallySpeculatable : OpInterface<"ConditionallySpeculatable"> {
+  let description = [{
+    An interface used to query information about the speculability of an
+    operation.
+  }];
+  let cppNamespace = "::mlir";
+
+  let methods = [
+    InterfaceMethod<[{
+        Returns value indicating whether the specific operation in question can
+        be speculatively executed.  Please see the documentation on the
+        Speculatability enum to know how to interpret the return value.
+      }],
+      "::mlir::Speculation::Speculatability", "isSpeculatable", (ins), [{
+        return $_op.isSpeculatable();
+      }]>
+  ];
+}
+
+// Marks an Operation as always speculatable.
+def AlwaysSpeculatable : TraitList<[
+    ConditionallySpeculatable, AlwaysSpeculatableImplTrait]>;
+
+// Marks an Operation as speculatable only if all the operations in all attached
+// regions are also speculatable.
+def RecursivelySpeculatable : TraitList<[
+    ConditionallySpeculatable, RecursivelySpeculatableImplTrait]>;
+
+// Always speculatable operation that does not touch memory.  These operations
+// are always legal to hoist or sink.
+def Pure : TraitList<[AlwaysSpeculatable, NoMemoryEffect]>;
 
 #endif // MLIR_INTERFACES_SIDEEFFECTS

mlir/include/mlir/Transforms/SideEffectUtils.h

 //===- SideEffectUtils.h - Side Effect Utils --------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TRANSFORMS_SIDEFFECTUTILS_H
 #define MLIR_TRANSFORMS_SIDEFFECTUTILS_H
 
 namespace mlir {
 
 class Operation;
 
-/// Returns true if the given operation is side-effect free.
+/// Returns true if the given operation is free of memory effects.
 ///
-/// An operation is side-effect free if its implementation of
+/// An operation is free of memory effects if its implementation of
 /// `MemoryEffectOpInterface` indicates that it has no memory effects. For
-/// example, it may implement `NoSideEffect` in ODS. Alternatively, if the
-/// operation `HasRecursiveSideEffects`, then it is side-effect free if all of
-/// its nested operations are side-effect free.
+/// example, it may implement `NoMemoryEffect` in ODS. Alternatively, if the
+/// operation has the `HasRecursiveMemoryEffects` trait, then it is free of
+/// memory effects if all of its nested operations are free of memory effects.
 ///
-/// If the operation has both, then it is side-effect free if both conditions
-/// are satisfied.
-bool isSideEffectFree(Operation *op);
+/// If the operation has both, then it is free of memory effects if both
+/// conditions are satisfied.
+bool isMemoryEffectFree(Operation *op);
+
+/// Returns true if the given operation is speculatable, i.e. has no undefined
+/// behavior or other side effects.
+///
+/// An operation can indicate that it is speculatable by implementing the
+/// isSpeculatable hook in the ConditionallySpeculatable op interface.
+bool isSpeculatable(Operation *op);
 
 } // end namespace mlir
 
 #endif // MLIR_TRANSFORMS_SIDEFFECTUTILS_H

mlir/lib/Analysis/AliasAnalysis/LocalAliasAnalysis.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // LocalAliasAnalysis: getModRef
 //===----------------------------------------------------------------------===//
 
 ModRefResult LocalAliasAnalysis::getModRef(Operation *op, Value location) {
   // Check to see if this operation relies on nested side effects.
-  if (op->hasTrait<OpTrait::HasRecursiveSideEffects>()) {
+  if (op->hasTrait<OpTrait::HasRecursiveMemoryEffects>()) {
     // TODO: To check recursive operations we need to check all of the nested
     // operations, which can result in a quadratic number of queries. We should
     // introduce some caching of some kind to help alleviate this, especially as
     // this caching could be used in other areas of the codebase (e.g. when
     // checking `wouldOpBeTriviallyDead`).
     return ModRefResult::getModAndRef();
   }
 

mlir/lib/Dialect/Affine/Utils/Utils.cpp

if (auto memEffect = dyn_cast<MemoryEffectOpInterface>(op)) {
         // `srcAccess.memref` and `destAccess.memref` don't alias.
       }
       // We have an op with a memory effect and we cannot prove if it
       // intervenes.
       hasSideEffect = true;
       return;
     }
 
-    if (op->hasTrait<OpTrait::HasRecursiveSideEffects>()) {
+    if (op->hasTrait<OpTrait::HasRecursiveMemoryEffects>()) {
       // Recurse into the regions for this op and check whether the internal
       // operations may have the side effect `EffectType` on memOp.
       for (Region &region : op->getRegions())
         for (Block &block : region)
           for (Operation &op : block)
             checkOperation(&op);
       return;
     }

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

 
 /// Given an operation, return whether this op itself could
 /// allocate an AutomaticAllocationScopeResource. Note that
 /// this will not check whether an operation contained within
 /// the op can allocate.
 static bool isOpItselfPotentialAutomaticAllocation(Operation *op) {
   // This op itself doesn't create a stack allocation,
   // the inner allocation should be handled separately.
-  if (op->hasTrait<OpTrait::HasRecursiveSideEffects>())
+  if (op->hasTrait<OpTrait::HasRecursiveMemoryEffects>())
     return false;
   MemoryEffectOpInterface interface = dyn_cast<MemoryEffectOpInterface>(op);
   if (!interface)
     return true;
   for (auto res : op->getResults()) {
     if (auto effect =
             interface.getEffectOnValue<MemoryEffects::Allocate>(res)) {
       if (isa<SideEffects::AutomaticAllocationScopeResource>(

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

rewriter.replaceOp(warpOp,
                      newWarpOp.getResults().take_front(warpOp.getNumResults()));
   return newWarpOp;
 }
 
 /// Helper to know if an op can be hoisted out of the region.
 static bool canBeHoisted(Operation *op,
                          function_ref<bool(Value)> definedOutside) {
   return llvm::all_of(op->getOperands(), definedOutside) &&
-         isSideEffectFree(op) && op->getNumRegions() == 0;
+         isMemoryEffectFree(op) && op->getNumRegions() == 0;
 }
 
 /// Return a value yielded by `warpOp` which statifies the filter lamdba
 /// condition and is not dead.
 static OpOperand *getWarpResult(WarpExecuteOnLane0Op warpOp,
                                 const std::function<bool(Operation *)> &fn) {
   auto yield = cast<vector::YieldOp>(
       warpOp.getBodyRegion().getBlocks().begin()->getTerminator());
LogicalResult matchAndRewrite(vector::TransferWriteOp writeOp,
 
     auto warpOp = dyn_cast<WarpExecuteOnLane0Op>(writeOp->getParentOp());
     if (!warpOp)
       return failure();
 
     // There must be no op with a side effect after writeOp.
     Operation *nextOp = writeOp.getOperation();
     while ((nextOp = nextOp->getNextNode()))
-      if (!isSideEffectFree(nextOp))
+      if (!isMemoryEffectFree(nextOp))
         return failure();
 
     if (!llvm::all_of(writeOp->getOperands(), [&](Value value) {
           return writeOp.getVector() == value ||
                  warpOp.isDefinedOutsideOfRegion(value);
         }))
       return failure();
 

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

while (!users.empty()) {
     Operation *user = users.pop_back_val();
     // If the user has already been processed skip.
     if (!processed.insert(user).second)
       continue;
     if (auto subView = dyn_cast<memref::SubViewOp>(user)) {
       users.append(subView->getUsers().begin(), subView->getUsers().end());
       continue;
     }
-    if (isSideEffectFree(user))
+    if (isMemoryEffectFree(user))
       continue;
     if (user == write.getOperation())
       continue;
     if (auto nextWrite = dyn_cast<vector::TransferWriteOp>(user)) {
       // Check candidate that can override the store.
       if (write.getSource() == nextWrite.getSource() &&
           checkSameValueWAW(nextWrite, write) &&
           postDominators.postDominates(nextWrite, write)) {
while (!users.empty()) {
     Operation *user = users.pop_back_val();
     // If the user has already been processed skip.
     if (!processed.insert(user).second)
       continue;
     if (auto subView = dyn_cast<memref::SubViewOp>(user)) {
       users.append(subView->getUsers().begin(), subView->getUsers().end());
       continue;
     }
-    if (isSideEffectFree(user) || isa<vector::TransferReadOp>(user))
+    if (isMemoryEffectFree(user) || isa<vector::TransferReadOp>(user))
       continue;
     if (auto write = dyn_cast<vector::TransferWriteOp>(user)) {
       // If there is a write, but we can prove that it is disjoint we can ignore
       // the write.
       if (vector::isDisjointTransferSet(
               cast<VectorTransferOpInterface>(write.getOperation()),
               cast<VectorTransferOpInterface>(read.getOperation())))
         continue;

mlir/lib/Interfaces/SideEffectInterfaces.cpp

 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>();
+    bool hasRecursiveEffects =
+        op->hasTrait<OpTrait::HasRecursiveMemoryEffects>();
     if (hasRecursiveEffects) {
       for (Region &region : op->getRegions()) {
         for (auto &block : region) {
           for (auto &nestedOp : block)
             effectingOps.push_back(&nestedOp);
         }
       }
     }

mlir/lib/Transforms/ControlFlowSink.cpp

void ControlFlowSink::runOnOperation() {
   auto &domInfo = getAnalysis<DominanceInfo>();
   getOperation()->walk([&](RegionBranchOpInterface branch) {
     SmallVector<Region *> regionsToSink;
     // Get the regions are that known to be executed at most once.
     getSinglyExecutedRegionsToSink(branch, regionsToSink);
     // Sink side-effect free operations.
     numSunk = controlFlowSink(
         regionsToSink, domInfo,
-        [](Operation *op, Region *) { return isSideEffectFree(op); },
+        [](Operation *op, Region *) { return isMemoryEffectFree(op); },
         [](Operation *op, Region *region) {
           // Move the operation to the beginning of the region's entry block.
           // This guarantees the preservation of SSA dominance of all of the
           // operation's uses are in the region.
           op->moveBefore(&region->front(), region->front().begin());
         });
   });
 }
 
 std::unique_ptr<Pass> mlir::createControlFlowSinkPass() {
   return std::make_unique<ControlFlowSink>();
 }

mlir/lib/Transforms/Utils/LoopInvariantCodeMotionUtils.cpp

 }
 
 size_t mlir::moveLoopInvariantCode(LoopLikeOpInterface loopLike) {
   return moveLoopInvariantCode(
       &loopLike.getLoopBody(),
       [&](Value value, Region *) {
         return loopLike.isDefinedOutsideOfLoop(value);
       },
-      [&](Operation *op, Region *) { return isSideEffectFree(op); },
+      [&](Operation *op, Region *) {
+        return isMemoryEffectFree(op) && isSpeculatable(op);
+      },
       [&](Operation *op, Region *) { loopLike.moveOutOfLoop(op); });
 }

mlir/lib/Transforms/Utils/SideEffectUtils.cpp

 //===- SideEffectUtils.cpp - Side Effect Utils ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Transforms/SideEffectUtils.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 using namespace mlir;
 
-bool mlir::isSideEffectFree(Operation *op) {
+bool mlir::isMemoryEffectFree(Operation *op) {
   if (auto memInterface = dyn_cast<MemoryEffectOpInterface>(op)) {
     // If the op has side-effects, it cannot be moved.
     if (!memInterface.hasNoEffect())
       return false;
     // If the op does not have recursive side effects, then it can be moved.
-    if (!op->hasTrait<OpTrait::HasRecursiveSideEffects>())
+    if (!op->hasTrait<OpTrait::HasRecursiveMemoryEffects>())
       return true;
-  } else if (!op->hasTrait<OpTrait::HasRecursiveSideEffects>()) {
+  } else if (!op->hasTrait<OpTrait::HasRecursiveMemoryEffects>()) {
     // Otherwise, if the op does not implement the memory effect interface and
     // it does not have recursive side effects, then it cannot be known that the
     // op is moveable.
     return false;
   }
 
   // Recurse into the regions and ensure that all nested ops can also be moved.
   for (Region &region : op->getRegions())
     for (Operation &op : region.getOps())
-      if (!isSideEffectFree(&op))
+      if (!isMemoryEffectFree(&op))
         return false;
   return true;
 }
+
+bool mlir::isSpeculatable(Operation *op) {
+  auto conditionallySpeculatable = dyn_cast<ConditionallySpeculatable>(op);
+  if (!conditionallySpeculatable)
+    return false;
+
+  switch (conditionallySpeculatable.isSpeculatable()) {
+  case Speculation::RecursivelySpeculatable:
+    for (Region &region : op->getRegions()) {
+      for (Operation &op : region.getOps())
+        if (!isSpeculatable(&op))
+          return false;
+    }
+    return true;
+
+  case Speculation::Speculatable:
+    return true;
+
+  case Speculation::NotSpeculatable:
+    return false;
+  }
+}

mlir/test/Transforms/loop-invariant-code-motion.mlir

test.graph_loop {
     // CHECK-NEXT: %[[B]] = "test.b"(%[[A]]) :
     // CHECK-NEXT: test.region_yield %[[A]]
     %a = "test.a"(%b) : (i32) -> i32
     %b = "test.b"(%a) : (i32) -> i32
     test.region_yield %a : i32
   } : () -> ()
   return
 }
+
+// -----
+
+// CHECK-LABEL: test_always_speculatable_op
+func.func @test_always_speculatable_op(%lb: index, %ub: index, %step: index) {
+  // CHECK: test.always_speculatable_op
+  // CHECK-NEXT: scf.for
+  scf.for %i = %lb to %ub step %step {
+    %val = "test.always_speculatable_op"() : () -> i32
+  }
+
+  return
+}
+
+// CHECK-LABEL: test_never_speculatable_op
+func.func @test_never_speculatable_op(%lb: index, %ub: index, %step: index) {
+  // CHECK: scf.for
+  // CHECK-NEXT: test.never_speculatable_op
+  scf.for %i = %lb to %ub step %step {
+    %val = "test.never_speculatable_op"() : () -> i32
+  }
+
+  return
+}
+
+// CHECK-LABEL: test_conditionally_speculatable_op_success
+func.func @test_conditionally_speculatable_op_success(%lb: index, %ub: index, %step: index) {
+  // CHECK: test.conditionally_speculatable_op
+  // CHECK-NEXT: scf.for
+  scf.for %i = %lb to %ub step %step {
+    %const_val = arith.constant 5 : i32
+    %val = "test.conditionally_speculatable_op"(%const_val) : (i32) -> i32
+  }
+
+  return
+}
+
+// CHECK-LABEL: test_conditionally_speculatable_op_failure
+func.func @test_conditionally_speculatable_op_failure(%lb: index, %ub: index, %step: index, %arg: i32) {
+  // CHECK: scf.for
+  // CHECK-NEXT: test.conditionally_speculatable_op
+  %const_5 = arith.constant 5 : i32
+  %non_const = arith.addi %arg, %const_5 : i32
+  scf.for %i = %lb to %ub step %step {
+    %val = "test.conditionally_speculatable_op"(%non_const) : (i32) -> i32
+  }
+
+  return
+}
+
+// CHECK-LABEL: test_recursively_speculatable_op_success
+func.func @test_recursively_speculatable_op_success(%lb: index, %ub: index, %step: index, %arg: i32) {
+  // CHECK: test.recursively_speculatable_op
+  // CHECK: scf.for
+  scf.for %i = %lb to %ub step %step {
+    %val = "test.recursively_speculatable_op"()({
+      %result = arith.addi %arg, %arg : i32
+      test.region_yield %result : i32
+    }) : () -> i32
+  }
+
+  return
+}
+
+// CHECK-LABEL: test_recursively_speculatable_op_failure
+func.func @test_recursively_speculatable_op_failure(%lb: index, %ub: index, %step: index, %arg: i32) {
+  // CHECK: scf.for
+  // CHECK-NEXT: test.recursively_speculatable_op
+  scf.for %i = %lb to %ub step %step {
+    %val = "test.recursively_speculatable_op"()({
+      %result = "test.never_speculatable_op"() : () -> i32
+      test.region_yield %result : i32
+    }) : () -> i32
+  }
+
+  return
+}

mlir/test/lib/Dialect/Test/TestOps.td

def : Pat<(OpAllAttrConstraint1
           (OpAllAttrConstraint2 $attr)>;
 
 // Op for testing RewritePattern removing op with inner ops.
 def TestOpWithRegionPattern : TEST_Op<"op_with_region_pattern"> {
   let regions = (region SizedRegion<1>:$region);
   let hasCanonicalizer = 1;
 }
 
-def TestOpConstant : TEST_Op<"constant", [ConstantLike, NoSideEffect]> {
+def TestOpConstant : TEST_Op<"constant", [ConstantLike, NoMemoryEffect]> {
   let arguments = (ins AnyAttr:$value);
   let results = (outs AnyType);
 
   let hasFolder = 1;
 }
 
 def OpR : TEST_Op<"op_r">, Arguments<(ins AnyInteger, AnyInteger)>, Results<(outs AnyInteger)>;
 def OpS : TEST_Op<"op_s">, Arguments<(ins AnyInteger, AnyAttr:$value)>, Results<(outs AnyInteger)>;
 
 def : Pat<(OpR $input1, (ConstantLikeMatcher I32Attr:$input2)),
           (OpS:$unused $input1, $input2)>;
 
 // Op for testing trivial removal via folding of op with inner ops and no uses.
-def TestOpWithRegionFoldNoSideEffect : TEST_Op<
-    "op_with_region_fold_no_side_effect", [NoSideEffect]> {
+def TestOpWithRegionFoldNoMemoryEffect : TEST_Op<
+    "op_with_region_fold_no_side_effect", [NoMemoryEffect]> {
   let regions = (region SizedRegion<1>:$region);
 }
 
 // Op for testing folding of outer op with inner ops.
 def TestOpWithRegionFold : TEST_Op<"op_with_region_fold"> {
   let arguments = (ins I32:$operand);
   let results = (outs I32);
   let regions = (region SizedRegion<1>:$region);

 
 def TestCommutative2Op : TEST_Op<"op_commutative2", [Commutative]> {
   let arguments = (ins I32:$op1, I32:$op2);
   let results = (outs I32);
 }
 
 def TestIdempotentTraitOp
  : TEST_Op<"op_idempotent_trait",
-           [SameOperandsAndResultType, NoSideEffect, Idempotent]> {
+           [SameOperandsAndResultType, NoMemoryEffect, Idempotent]> {
   let arguments = (ins I32:$op1);
   let results = (outs I32);
 }
 
 def TestIdempotentTraitBinaryOp
     : TEST_Op<"op_idempotent_trait_binary",
-              [SameOperandsAndResultType, NoSideEffect, Idempotent]> {
+              [SameOperandsAndResultType, NoMemoryEffect, Idempotent]> {
   let arguments = (ins I32:$op1, I32:$op2);
   let results = (outs I32);
 }
 
 def TestInvolutionTraitNoOperationFolderOp
  : TEST_Op<"op_involution_trait_no_operation_fold",
-           [SameOperandsAndResultType, NoSideEffect, Involution]> {
+           [SameOperandsAndResultType, NoMemoryEffect, Involution]> {
   let arguments = (ins I32:$op1);
   let results = (outs I32);
 }
 
 def TestInvolutionTraitFailingOperationFolderOp
  : TEST_Op<"op_involution_trait_failing_operation_fold",
-           [SameOperandsAndResultType, NoSideEffect, Involution]> {
+           [SameOperandsAndResultType, NoMemoryEffect, Involution]> {
   let arguments = (ins I32:$op1);
   let results = (outs I32);
   let hasFolder = 1;
 }
 
 def TestInvolutionTraitSuccesfulOperationFolderOp
  : TEST_Op<"op_involution_trait_succesful_operation_fold",
-           [SameOperandsAndResultType, NoSideEffect, Involution]> {
+           [SameOperandsAndResultType, NoMemoryEffect, Involution]> {
   let arguments = (ins I32:$op1);
   let results = (outs I32);
   let hasFolder = 1;
 }
 
 def TestOpInPlaceFoldAnchor : TEST_Op<"op_in_place_fold_anchor"> {
   let arguments = (ins I32);
   let results = (outs I32);
def CopyOp : TEST_Op<"copy", [CopyOpInterface]> {
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // Test Buffer/Tensor
 //===----------------------------------------------------------------------===//
 
 def RegionYieldOp : TEST_Op<"region_yield",
-      [NoSideEffect, ReturnLike, Terminator]> {
+      [Pure, ReturnLike, Terminator]> {
   let description = [{
     This operation is used in a region and yields the corresponding type for
     that operation.
   }];
   let arguments = (ins AnyType:$result);
   let assemblyFormat = [{
     $result `:` type($result) attr-dict
   }];
def TensorBasedOp : TEST_Op<"tensor_based", []> {
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // Test RegionBranchOpInterface
 //===----------------------------------------------------------------------===//
 
 def RegionIfYieldOp : TEST_Op<"region_if_yield",
-      [NoSideEffect, ReturnLike, Terminator]> {
+      [NoMemoryEffect, ReturnLike, Terminator]> {
   let arguments = (ins Variadic<AnyType>:$results);
   let assemblyFormat = [{
     $results `:` type($results) attr-dict
   }];
 }
 
 def RegionIfOp : TEST_Op<"region_if",
       [DeclareOpInterfaceMethods<RegionBranchOpInterface,
                                  ["getRegionInvocationBounds"]>,
        SingleBlockImplicitTerminator<"RegionIfYieldOp">,
-       RecursiveSideEffects]> {
+       RecursiveMemoryEffects]> {
   let description =[{
     Represents an abstract if-then-else-join pattern. In this context, the then
     and else regions jump to the join region, which finally returns to its
     parent op.
   }];
 
   let arguments = (ins Variadic<AnyType>);
   let results = (outs Variadic<AnyType>:$results);
::mlir::OperandRange getSuccessorEntryOperands(
         ::llvm::Optional<unsigned> index);
   }];
   let hasCustomAssemblyFormat = 1;
 }
 
 def AnyCondOp : TEST_Op<"any_cond",
       [DeclareOpInterfaceMethods<RegionBranchOpInterface,
                                  ["getRegionInvocationBounds"]>,
-       RecursiveSideEffects]> {
+       RecursiveMemoryEffects]> {
   let results = (outs Variadic<AnyType>:$results);
   let regions = (region AnyRegion:$region);
 }
 
 //===----------------------------------------------------------------------===//
 // Test TableGen generated build() methods
 //===----------------------------------------------------------------------===//
 

 }
 
 //===----------------------------------------------------------------------===//
 // Test Loop Op with a graph region
 //===----------------------------------------------------------------------===//
 
 // Test loop op with a graph region.
 def TestGraphLoopOp : TEST_Op<"graph_loop",
-                         [LoopLikeOpInterface, NoSideEffect,
-                          RecursiveSideEffects, SingleBlock,
+                         [LoopLikeOpInterface, NoMemoryEffect,
+                          RecursivelySpeculatable, SingleBlock,
                           RegionKindInterface, HasOnlyGraphRegion]> {
   let arguments = (ins Variadic<AnyType>:$args);
   let results = (outs Variadic<AnyType>:$rets);
   let regions = (region SizedRegion<1>:$body);
 
   let assemblyFormat = [{
     $args $body attr-dict `:` functional-type(operands, results)
   }];
 
   let extraClassDeclaration = [{
     mlir::Region &getLoopBody() { return getBody(); }
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // Test InferIntRangeInterface
 //===----------------------------------------------------------------------===//
 def TestWithBoundsOp : TEST_Op<"with_bounds",
                           [DeclareOpInterfaceMethods<InferIntRangeInterface>,
-                           NoSideEffect]> {
+                           NoMemoryEffect]> {
   let arguments = (ins IndexAttr:$umin,
                        IndexAttr:$umax,
                        IndexAttr:$smin,
                        IndexAttr:$smax);
   let results = (outs Index:$fakeVal);
 
   let assemblyFormat = "attr-dict";
 }
 
 def TestWithBoundsRegionOp : TEST_Op<"with_bounds_region",
                           [DeclareOpInterfaceMethods<InferIntRangeInterface>,
                            SingleBlock, NoTerminator]> {
   let arguments = (ins IndexAttr:$umin,
                        IndexAttr:$umax,
                        IndexAttr:$smin,
                        IndexAttr:$smax);
   // The region has one argument of index type
   let regions = (region SizedRegion<1>:$region);
   let hasCustomAssemblyFormat = 1;
 }
 
 def TestIncrementOp : TEST_Op<"increment",
                          [DeclareOpInterfaceMethods<InferIntRangeInterface>,
-                         NoSideEffect]> {
+                         NoMemoryEffect]> {
   let arguments = (ins Index:$value);
   let results = (outs Index:$result);
 
   let assemblyFormat = "attr-dict $value";
 }
 
 def TestReflectBoundsOp : TEST_Op<"reflect_bounds",
                          [DeclareOpInterfaceMethods<InferIntRangeInterface>]> {
   let arguments = (ins Index:$value,
                        OptionalAttr<IndexAttr>:$umin,
                        OptionalAttr<IndexAttr>:$umax,
                        OptionalAttr<IndexAttr>:$smin,
                        OptionalAttr<IndexAttr>:$smax);
   let results = (outs Index:$result);
 
   let assemblyFormat = "attr-dict $value";
 }
+
+//===----------------------------------------------------------------------===//
+// Test ConditionallySpeculatable
+//===----------------------------------------------------------------------===//
+
+def ConditionallySpeculatableOp : TEST_Op<"conditionally_speculatable_op",
+    [ConditionallySpeculatable, NoMemoryEffect]> {
+  let description = [{
+    Op used to test conditional speculation.  This op can be speculatively
+    executed if the input to it is an `arith.constant`.
+  }];
+
+  let arguments = (ins I32:$input);
+  let results = (outs I32:$result);
+
+  let extraClassDeclaration = [{
+    ::mlir::Speculation::Speculatability isSpeculatable();
+  }];
+
+  let extraClassDefinition = [{
+    ::mlir::Speculation::Speculatability
+    ConditionallySpeculatableOp::isSpeculatable() {
+      Operation* definingOp = getInput().getDefiningOp();
+      return definingOp && isa<::mlir::arith::ConstantOp>(definingOp) ?
+          ::mlir::Speculation::Speculatable : ::mlir::Speculation::NotSpeculatable;
+    }
+  }];
+}
+
+def PureOp : TEST_Op<"always_speculatable_op", [Pure]> {
+  let description = [{
+    Op used to test conditional speculation.  This op can always be
+    speculatively executed.
+  }];
+  let results = (outs I32:$result);
+}
+
+def NeverSpeculatableOp : TEST_Op<"never_speculatable_op", [ConditionallySpeculatable]> {
+  let description = [{
+    Op used to test conditional speculation.  This op can never be
+    speculatively executed.
+  }];
+  let results = (outs I32:$result);
+
+  let extraClassDeclaration = [{
+    ::mlir::Speculation::Speculatability isSpeculatable() {
+      return ::mlir::Speculation::NotSpeculatable;
+    }
+  }];
+}
+
+def RecursivelySpeculatableOp : TEST_Op<"recursively_speculatable_op", [
+    RecursivelySpeculatable, RecursiveMemoryEffects]> {
+  let description = [{
+    Op used to test conditional speculation.  This op can be speculatively
+    executed only if all the ops in the attached region can be.
+  }];
+  let results = (outs I32:$result);
+  let regions = (region SizedRegion<1>:$body);
+}
+
 #endif // TEST_OPS

mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.td

let arguments = (ins
     StrAttr:$message);
   let assemblyFormat = "$operand `,` $message attr-dict";
   let cppNamespace = "::mlir::test";
 }
 
 def TestAddTestExtensionOp
   : Op<Transform_Dialect, "test_add_test_extension",
        [DeclareOpInterfaceMethods<TransformOpInterface>,
-        NoSideEffect]> {
+        NoMemoryEffect]> {
   let arguments = (ins StrAttr:$message);
   let assemblyFormat = "$message attr-dict";
   let cppNamespace = "::mlir::test";
 }
 
 def TestCheckIfTestExtensionPresentOp
   : Op<Transform_Dialect, "test_check_if_test_extension_present",
        [DeclareOpInterfaceMethods<TransformOpInterface>]> {
Arg<PDL_Operation, "",
         [TransformMappingRead, TransformMappingWrite, PayloadIRRead]>:$operand);
   let assemblyFormat = "$operand attr-dict";
   let cppNamespace = "::mlir::test";
 }
 
 def TestRemoveTestExtensionOp
   : Op<Transform_Dialect, "test_remove_test_extension",
        [DeclareOpInterfaceMethods<TransformOpInterface>,
-        NoSideEffect]> {
+        NoMemoryEffect]> {
   let assemblyFormat = "attr-dict";
   let cppNamespace = "::mlir::test";
 }
 
 def TestReversePayloadOpsOp
   : Op<Transform_Dialect, "test_reverse_payload_ops",
     [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
      DeclareOpInterfaceMethods<TransformOpInterface>]> {

mlir/test/mlir-tblgen/gen-dialect-doc.td

 // RUN: mlir-tblgen -gen-dialect-doc -I %S/../../include -dialect=test %s | FileCheck %s
 // RUN: mlir-tblgen -gen-dialect-doc -I %S/../../include -dialect=test_toc %s | FileCheck %s --check-prefix=CHECK_TOC
 
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
   let summary = "Dialect of ops to test";
   let description = [{
     Dialect without a [TOC] here.
     TOC added by tool.
   }];
   let cppNamespace = "NS";
 }
-def AOp : Op<Test_Dialect, "a", [NoSideEffect, SingleBlockImplicitTerminator<"YieldOp">]>;
+def AOp : Op<Test_Dialect, "a", [NoMemoryEffect, SingleBlockImplicitTerminator<"YieldOp">]>;
 
 def TestAttr : DialectAttr<Test_Dialect, CPred<"true">> {
   let summary = "attribute summary";
   let description = "attribute description";
 }
 
 def TestType : DialectType<Test_Dialect, CPred<"true">> {
   let summary = "type summary";
   let description = "type description";
 }
 
 // CHECK: Dialect without a [TOC] here.
 // CHECK: TOC added by tool.
 // CHECK: [TOC]
 
 // CHECK-NOT: [TOC]
 // CHECK: Traits: SingleBlockImplicitTerminator<YieldOp>
-// CHECK: Interfaces: NoSideEffect (MemoryEffectOpInterface)
+// CHECK: Interfaces: NoMemoryEffect (MemoryEffectOpInterface)
 // CHECK: Effects: MemoryEffects::Effect{}
 
 // CHECK: ## Attribute constraint definition
 // CHECK: ### attribute summary
 // CHECK: attribute description
 
 // CHECK: ## Type constraint definition
 // CHECK: ### type summary

mlir/test/mlir-tblgen/llvm-intrinsics.td

 // CHECK-LABEL: def LLVM_ptrmask
 // CHECK: LLVM_IntrOp<"ptrmask
 // The result of this intrinsic result is overloadable.
 // CHECK: [0]
 // The second operand is overloadable, but the first operand needs to
 // match the result type.
 // CHECK: [1]
 // It has no side effects.
-// CHECK: [NoSideEffect]
+// CHECK: [NoMemoryEffect]
 // It has a result.
 // CHECK: 1,
 // It does not require an access group.
 // CHECK: 0,
 // It does not require alias scopes.
 // CHECK: 0>
 // CHECK: Arguments<(ins LLVM_Type, LLVM_Type
 
 //---------------------------------------------------------------------------//
 
 // This checks that we can define an op that takes in an access group metadata.
 //
 // RUN: cat %S/../../../llvm/include/llvm/IR/Intrinsics.td \
 // RUN: | grep -v "llvm/IR/Intrinsics" \
 // RUN: | mlir-tblgen -gen-llvmir-intrinsics -I %S/../../../llvm/include/ --llvmir-intrinsics-filter=ptrmask --llvmir-intrinsics-access-group-regexp=ptrmask \
 // RUN: | FileCheck --check-prefix=GROUPS %s
 
 // GROUPS-LABEL: def LLVM_ptrmask
 // GROUPS: LLVM_IntrOp<"ptrmask
 // It has no side effects.
-// GROUPS: [NoSideEffect]
+// GROUPS: [NoMemoryEffect]
 // It has a result.
 // GROUPS: 1,
 // It requires generation of an access group LLVM metadata.
 // GROUPS: 1,
 // It does not require alias scopes.
 // GROUPS: 0>
 // It has an access group attribute.
 // GROUPS: OptionalAttr<SymbolRefArrayAttr>:$access_groups
 
 //---------------------------------------------------------------------------//
 
 // This checks that we can define an op that takes in alias scopes metadata.
 //
 // RUN: cat %S/../../../llvm/include/llvm/IR/Intrinsics.td \
 // RUN: | grep -v "llvm/IR/Intrinsics" \
 // RUN: | mlir-tblgen -gen-llvmir-intrinsics -I %S/../../../llvm/include/ --llvmir-intrinsics-filter=ptrmask --llvmir-intrinsics-alias-scopes-regexp=ptrmask \
 // RUN: | FileCheck --check-prefix=ALIAS %s
 
 // ALIAS-LABEL: def LLVM_ptrmask
 // ALIAS: LLVM_IntrOp<"ptrmask
 // It has no side effects.
-// ALIAS: [NoSideEffect]
+// ALIAS: [NoMemoryEffect]
 // It has a result.
 // ALIAS: 1,
 // It does not require an access group.
 // ALIAS: 0,
 // It requires generation of alias scopes LLVM metadata.
 // ALIAS: 1>
 // It has alias scopes and noalias.
 // ALIAS: OptionalAttr<SymbolRefArrayAttr>:$alias_scopes

mlir/tools/mlir-tblgen/LLVMIRIntrinsicGen.cpp

static bool emitIntrinsic(const llvm::Record &record, llvm::raw_ostream &os) {
   bool requiresAliasScopes =
       !aliasScopesRegexp.empty() && aliasScopesMatcher.match(record.getName());
 
   // Prepare strings for traits, if any.
   llvm::SmallVector<llvm::StringRef, 2> traits;
   if (intr.isCommutative())
     traits.push_back("Commutative");
   if (!intr.hasSideEffects())
-    traits.push_back("NoSideEffect");
+    traits.push_back("NoMemoryEffect");
 
   // Prepare strings for operands.
   llvm::SmallVector<llvm::StringRef, 8> operands(intr.getNumOperands(),
                                                  "LLVM_Type");
   if (requiresAccessGroup)
     operands.push_back("OptionalAttr<SymbolRefArrayAttr>:$access_groups");
   if (requiresAliasScopes) {
     operands.push_back("OptionalAttr<SymbolRefArrayAttr>:$alias_scopes");