[pdl] Remove `NoSideEffect` from all PDL ops

[Mogball]

Summary

This trait results in PDL ops being erroneously CSE'd. These ops are side-effect free in the rewriter but not in the matcher (where unused values aren't allowed anyways). These ops should have a more nuanced side-effect modeling, this is fixing a bug introduced by a previous change.

[rriddle]

This isn't what we want though. These ops are no side effecting in some cases, and we want to preserve that.

[rriddle]

The commit description is also only assuming the use of the ops inside of the the match portion of a pattern.

[Mogball]

Oh, yeah. I was just reversing https://reviews.llvm.org/D117826 because that's what introduced the bug...

But we can probably have more nuanced side-effects, like these are allocating only inside matchers.

[rriddle]

Right, I'm fine with reverting the ones that are conservatively broken, just want to make sure the description holds and we aren't treating this as what the ideal end state should be.

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

503

Are Result operations ever side effecting? AFAICT they always produce the same result based on the given input.

[Mogball]

Yeah, I updated the description

[Mogball]

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

503

Oh yeah they aren't.

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

 //===- PDLOps.td - Pattern descriptor operations -----------*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the Pattern Descriptor Language dialect operations.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_PDL_IR_PDLOPS
 #define MLIR_DIALECT_PDL_IR_PDLOPS
 
 include "mlir/Dialect/PDL/IR/PDLTypes.td"
-include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/IR/OpAsmInterface.td"
 include "mlir/IR/SymbolInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // PDL Ops
 //===----------------------------------------------------------------------===//
 
 class PDL_Op<string mnemonic, list<Trait> traits = []>
def PDL_ApplyNativeRewriteOp
   }];
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::AttributeOp
 //===----------------------------------------------------------------------===//
 
-def PDL_AttributeOp : PDL_Op<"attribute", [NoSideEffect]> {
+def PDL_AttributeOp : PDL_Op<"attribute"> {
   let summary = "Define an input attribute in a pattern";
   let description = [{
     `pdl.attribute` operations capture named attribute edges into an operation.
     Instances of this operation define, and partially constrain, attributes of a
     given operation. A `pdl.attribute` may partially constrain the input by
     specifying an expected attribute value type (via a `pdl.type` operation), or
     a constant value for the attribute (via `val`). Only one of these may be set
     for a given input, as the type of the constant value provides the type. When
def PDL_EraseOp : PDL_Op<"erase", [HasParent<"pdl::RewriteOp">]> {
   let assemblyFormat = "$operation attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::OperandOp
 //===----------------------------------------------------------------------===//
 
 def PDL_OperandOp
-    : PDL_Op<"operand", [HasParent<"pdl::PatternOp">, NoSideEffect]> {
+    : PDL_Op<"operand", [HasParent<"pdl::PatternOp">]> {
   let summary = "Define an external input operand in a pattern";
   let description = [{
     `pdl.operand` operations capture external operand edges into an operation
     node that originate from operations or block arguments not otherwise
     specified within the pattern (i.e. via `pdl.result` or `pdl.results`). These
     operations define individual operands of a given operation. A `pdl.operand`
     may partially constrain an operand by specifying an expected value type
     (via a `pdl.type` operation).
def PDL_OperandOp
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::OperandsOp
 //===----------------------------------------------------------------------===//
 
 def PDL_OperandsOp
-    : PDL_Op<"operands", [HasParent<"pdl::PatternOp">, NoSideEffect]> {
+    : PDL_Op<"operands", [HasParent<"pdl::PatternOp">]> {
   let summary = "Define a range of input operands in a pattern";
   let description = [{
     `pdl.operands` operations capture external operand range edges into an
     operation node that originate from operations or block arguments not
     otherwise specified within the pattern (i.e. via `pdl.result` or
     `pdl.results`). These operations define groups of input operands into a
     given operation. A `pdl.operands` may partially constrain a set of input
     operands by specifying expected value types (via `pdl.types` operations).
def PDL_ReplaceOp : PDL_Op<"replace", [
   }];
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ResultOp
 //===----------------------------------------------------------------------===//
 
-def PDL_ResultOp : PDL_Op<"result", [NoSideEffect]> {
+def PDL_ResultOp : PDL_Op<"result"> {
   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"> {
   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"> {
   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
def PDL_RewriteOp : PDL_Op<"rewrite", [
   }];
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypeOp
 //===----------------------------------------------------------------------===//
 
-def PDL_TypeOp : PDL_Op<"type", [NoSideEffect]> {
+def PDL_TypeOp : PDL_Op<"type"> {
   let summary = "Define a type handle within a pattern";
   let description = [{
     `pdl.type` operations capture result type constraints of `Attributes`,
     `Values`, and `Operations`. Instances of this operation define, and
     partially constrain, results types of a given entity. A `pdl.type` may
     partially constrain the result by specifying a constant `Type`.
 
     Example:
def PDL_TypeOp : PDL_Op<"type"> {
   let assemblyFormat = "attr-dict (`:` $type^)?";
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypesOp
 //===----------------------------------------------------------------------===//
 
-def PDL_TypesOp : PDL_Op<"types", [NoSideEffect]> {
+def PDL_TypesOp : PDL_Op<"types"> {
   let summary = "Define a range of type handles within a pattern";
   let description = [{
     `pdl.types` operations capture result type constraints of `Value`s, and
     `Operation`s. Instances of this operation define results types of a given
     entity. A `pdl.types` may partially constrain the results by specifying
     an array of `Type`s.
 
     Example: