Revert "[MLIR] Introduce op trait PolyhedralScope"

This reverts commit dd2c639. It broke a
few things -- the explanation will be posted to the review thread.

Author: gribozavr

mlir/docs/Dialects/Affine.md

@@ -60,26 +60,20 @@ Example:
 ### Restrictions on Dimensions and Symbols
 
 The affine dialect imposes certain restrictions on dimension and symbolic
-identifiers to enable powerful analysis and transformation. An SSA value's use
-can be bound to a symbolic identifier if that SSA value is either
-1. a region argument for an op with trait `PolyhedralScope` (eg. `FuncOp`),
-2. a value defined at the top level of a `PolyhedralScope` op (i.e., immediately
-enclosed by the latter),
-3. a value that dominates the `PolyhedralScope` op enclosing the value's use,
-4. the result of a [`constant` operation](Standard.md#constant-operation),
-5. the result of an [`affine.apply`
-operation](#affineapply-operation) that recursively takes as arguments any valid
-symbolic identifiers, or
-6. the result of a [`dim` operation](Standard.md#dim-operation) on either a
-memref that is an argument to a `PolyhedralScope` op or a memref where the
-corresponding dimension is either static or a dynamic one in turn bound to a
-valid symbol.
-
-Note that as a result of rule (3) above, symbol validity is sensitive to the
-location of the SSA use.  Dimensions may be bound not only to anything that a
-symbol is bound to, but also to induction variables of enclosing
-[`affine.for`](#affinefor-operation) and
-[`affine.parallel`](#affineparallel-operation) operations, and the result of an
+identifiers to enable powerful analysis and transformation. A symbolic
+identifier can be bound to an SSA value that is either an argument to the
+function, a value defined at the top level of that function (outside of all
+loops and if operations), the result of a
+[`constant` operation](Standard.md#constant-operation), or the result of an
+[`affine.apply` operation](#affineapply-operation) that recursively takes as
+arguments any symbolic identifiers, or the result of a [`dim`
+operation](Standard.md#dim-operation) on either a memref that is a function
+argument or a memref where the corresponding dimension is either static or a
+dynamic one in turn bound to a symbolic identifier.  Dimensions may be bound not
+only to anything that a symbol is bound to, but also to induction variables of
+enclosing [`affine.for`](#affinefor-affineforop) and
+[`afffine.parallel`](#affineparallel-affineparallelop) operations, and the
+result of an
 [`affine.apply` operation](#affineapply-operation) (which recursively may use
 other dimensions and symbols).
 

mlir/docs/Traits.md

@@ -219,22 +219,6 @@ foo.region_op {
 This trait is an important structural property of the IR, and enables operations
 to have [passes](PassManagement.md) scheduled under them.
 
-
-### PolyhedralScope
-
-*   `OpTrait::PolyhedralScope` -- `PolyhedralScope`
-
-This trait is carried by region holding operations that define a new scope for
-the purposes of polyhedral optimization and the affine dialect in particular.
-Any SSA values of 'index' type that either dominate such operations, or are
-defined at the top-level of such operations, or appear as region arguments for
-such operations automatically become valid symbols for the polyhedral scope
-defined by that operation. As a result, such SSA values could be used as the
-operands or index operands of various affine dialect operations like affine.for,
-affine.load, and affine.store.  The polyhedral scope defined by an operation
-with this trait includes all operations in its region excluding operations that
-are nested inside of other operations that themselves have this trait.
-
 ### Single Block with Implicit Terminator
 
 *   `OpTrait::SingleBlockImplicitTerminator<typename TerminatorOpType>` :

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

@@ -31,10 +31,9 @@ class AffineTerminatorOp;
 class FlatAffineConstraints;
 class OpBuilder;
 
-/// A utility function to check if a value is defined at the top level of an
-/// op with trait `PolyhedralScope` or is a region argument for such an op. A
-/// value of index type defined at the top level is always a valid symbol for
-/// all its uses.
+/// A utility function to check if a value is defined at the top level of a
+/// function. A value of index type defined at the top level is always a valid
+/// symbol.
 bool isTopLevelValue(Value value);
 
 /// AffineDmaStartOp starts a non-blocking DMA operation that transfers data
@@ -458,22 +457,12 @@ class AffineStoreOp : public Op<AffineStoreOp, OpTrait::ZeroResult,
                      SmallVectorImpl<OpFoldResult> &results);
 };
 
-/// Returns true if the given Value can be used as a dimension id in the region
-/// of the closest surrounding op that has the trait `PolyhedralScope`.
+/// Returns true if the given Value can be used as a dimension id.
 bool isValidDim(Value value);
 
-/// Returns true if the given Value can be used as a dimension id in `region`,
-/// i.e., for all its uses in `region`.
-bool isValidDim(Value value, Region *region);
-
-/// Returns true if the given value can be used as a symbol in the region of the
-/// closest surrounding op that has the trait `PolyhedralScope`.
+/// Returns true if the given Value can be used as a symbol.
 bool isValidSymbol(Value value);
 
-/// Returns true if the given Value can be used as a symbol for `region`, i.e.,
-/// for all its uses in `region`.
-bool isValidSymbol(Value value, Region *region);
-
 /// Modifies both `map` and `operands` in-place so as to:
 /// 1. drop duplicate operands
 /// 2. drop unused dims and symbols from map

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

@@ -83,22 +83,12 @@ def AffineApplyOp : Affine_Op<"apply", [NoSideEffect]> {
     /// Returns the affine value map computed from this operation.
     AffineValueMap getAffineValueMap();
 
-    /// Returns true if the result of this operation can be used as dimension id
-    /// in the region of the closest surrounding op with trait PolyhedralScope.
+    /// Returns true if the result of this operation can be used as dimension id.
     bool isValidDim();
 
-    /// Returns true if the result of this operation can be used as dimension id
-    /// within 'region', i.e., for all its uses with `region`.
-    bool isValidDim(Region *region);
-
-    /// Returns true if the result of this operation is a symbol in the region
-    /// of the closest surrounding op that has the trait PolyhedralScope.
+    /// Returns true if the result of this operation is a symbol.
     bool isValidSymbol();
 
-    /// Returns true if the result of this operation is a symbol for all its
-    /// uses in `region`.
-    bool isValidSymbol(Region *region);
-
     operand_range getMapOperands() { return getOperands(); }
   }];
 

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

@@ -29,11 +29,4 @@ def AffineMapArrayAttr : TypedArrayAttrBase<AffineMapAttr,
   let constBuilderCall = "$_builder.getAffineMapArrayAttr($0)";
 }
 
-//===----------------------------------------------------------------------===//
-// OpTrait definitions
-//===----------------------------------------------------------------------===//
-
-// Op defines a polyhedral scope.
-def PolyhedralScope : NativeOpTrait<"PolyhedralScope">;
-
 #endif // AFFINE_OPS_BASE

mlir/include/mlir/Dialect/Affine/Traits.h

@@ -13,7 +13,6 @@
 #ifndef MLIR_IR_FUNCTION_H
 #define MLIR_IR_FUNCTION_H
 
-#include "mlir/Dialect/Affine/Traits.h"
 #include "mlir/IR/Block.h"
 #include "mlir/IR/FunctionSupport.h"
 #include "mlir/IR/OpDefinition.h"
@@ -31,11 +30,10 @@ namespace mlir {
 /// implicitly capture global values, and all external references must use
 /// Function arguments or attributes that establish a symbolic connection(e.g.
 /// symbols referenced by name via a string attribute).
-class FuncOp
-    : public Op<FuncOp, OpTrait::ZeroOperands, OpTrait::ZeroResult,
-                OpTrait::IsIsolatedFromAbove, OpTrait::FunctionLike,
-                OpTrait::AutomaticAllocationScope, OpTrait::PolyhedralScope,
-                CallableOpInterface::Trait, SymbolOpInterface::Trait> {
+class FuncOp : public Op<FuncOp, OpTrait::ZeroOperands, OpTrait::ZeroResult,
+                         OpTrait::IsIsolatedFromAbove, OpTrait::FunctionLike,
+                         OpTrait::AutomaticAllocationScope,
+                         CallableOpInterface::Trait, SymbolOpInterface::Trait> {
 public:
   using Op::Op;
   using Op::print;