Merge OpFolderDialectInterface with DialectFoldInterface (NFC)

[rriddle]

mlir/docs/Canonicalization.md

91

Can you add that a fallback can be provided by the dialect via the fold interface?

[mehdi_amini]

Add mention of the fallback in the doc

mlir/docs/Canonicalization.md

*   Constant folding - e.g. "(addi 1, 2)" to "3". Constant folding hooks are
     specified by operations.
 
 *   Move constant operands to commutative operators to the right side - e.g.
     "(addi 4, x)" to "(addi x, 4)".
 
 *   `constant-like` operations are uniqued and hoisted into the entry block of
     the first parent barrier region. This is a region that is either isolated
     from above, e.g. the entry block of a function, or one marked as a barrier
-    via the `shouldMaterializeInto` method on the `OpFolderDialectInterface`.
+    via the `shouldMaterializeInto` method on the `DialectFoldInterface`.
 
 ## Defining Canonicalizations
 
 Two mechanisms are available with which to define canonicalizations;
 `getCanonicalizationPatterns` and `fold`.
 
 ### Canonicalizing with `getCanonicalizationPatterns`
 
void MyOp::getCanonicalizationPatterns(OwningRewritePatternList &patterns,
                                        MLIRContext *context) {
   patterns.insert<...>(...);
 }
 ```
 
 See the [quickstart guide](Tutorials/QuickstartRewrites.md) for information on
 defining operation rewrites.
 
 ### Canonicalizing with `fold`
 
 The `fold` mechanism is an intentionally limited, but powerful mechanism that
 allows for applying canonicalizations in many places throughout the compiler.
 For example, outside of the canonicalizer pass, `fold` is used within the
 [dialect conversion infrastructure](#DialectConversion.md) as a legalization
 mechanism, and can be invoked directly anywhere with an `OpBuilder` via
 `OpBuilder::createOrFold`.
 

 Also above, is the use of `OpFoldResult`. This class represents the possible
 result of folding an operation result: either an SSA `Value`, or an
 `Attribute`(for a constant result). If an SSA `Value` is provided, it *must*
 correspond to an existing value. The `fold` methods are not permitted to
 generate new `Value`s. There are no specific restrictions on the form of the
 `Attribute` value returned, but it is important to ensure that the `Attribute`
 representation of a specific `Type` is consistent.
 
+When the `fold` hook on an operation is not successful, the dialect can
+provide a fallback by implementing the `DialectFoldInterface` and overriding
+the fold hook.
+
 #### Generating Constants from Attributes
 
 When a `fold` method returns an `Attribute` as the result, it signifies that
 this result is "constant". The `Attribute` is the constant representation of the
 value. Users of the `fold` method, such as the canonicalizer pass, will take
 these `Attribute`s and materialize constant operations in the IR to represent
 them. To enable this materialization, the dialect of the operation must
 implement the `materializeConstant` hook. This hook takes in an `Attribute`

mlir/include/mlir/Interfaces/FoldInterfaces.h

 
 #include "mlir/IR/DialectInterface.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/SmallVector.h"
 
 namespace mlir {
 class Attribute;
 class OpFoldResult;
+class Region;
 
-/// Define a fold interface to allow for dialects to opt-in specific
-/// folding for operations they define.
+/// Define a fold interface to allow for dialects to control specific aspects
+/// of the folding behavior for operations they define.
 class DialectFoldInterface
     : public DialectInterface::Base<DialectFoldInterface> {
 public:
   DialectFoldInterface(Dialect *dialect) : Base(dialect) {}
 
   /// Registered fallback fold for the dialect. Like the fold hook of each
   /// operation, it attempts to fold the operation with the specified constant
   /// operand values - the elements in "operands" will correspond directly to
   /// the operands of the operation, but may be null if non-constant.  If
   /// folding is successful, this fills in the `results` vector.  If not, this
   /// returns failure and `results` is unspecified.
   virtual LogicalResult Fold(Operation *op, ArrayRef<Attribute> operands,
                              SmallVectorImpl<OpFoldResult> &results) const {
     return failure();
   }
+
+  /// Registered hook to check if the given region, which is attached to an
+  /// operation that is *not* isolated from above, should be used when
+  /// materializing constants. The folder will generally materialize constants
+  /// into the top-level isolated region, this allows for materializing into a
+  /// lower level ancestor region if it is more profitable/correct.
+  virtual bool shouldMaterializeInto(Region *region) const { return false; }
 };
 
 } // end namespace mlir
 
 #endif // MLIR_INTERFACES_FOLDINTERFACES_H_

mlir/include/mlir/Transforms/FoldUtils.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TRANSFORMS_FOLDUTILS_H
 #define MLIR_TRANSFORMS_FOLDUTILS_H
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectInterface.h"
+#include "mlir/Interfaces/FoldInterfaces.h"
 
 namespace mlir {
 class Operation;
 class Value;
 
-//===--------------------------------------------------------------------===//
-// Operation Folding Interface
-//===--------------------------------------------------------------------===//
-
-/// This class defines a dialect interface used to assist the operation folder.
-/// It provides hooks for materializing and folding operations.
-class OpFolderDialectInterface
-    : public DialectInterface::Base<OpFolderDialectInterface> {
-public:
-  OpFolderDialectInterface(Dialect *dialect) : Base(dialect) {}
-
-  /// Registered hook to check if the given region, which is attached to an
-  /// operation that is *not* isolated from above, should be used when
-  /// materializing constants. The folder will generally materialize constants
-  /// into the top-level isolated region, this allows for materializing into a
-  /// lower level ancestor region if it is more profitable/correct.
-  virtual bool shouldMaterializeInto(Region *region) const { return false; }
-};
 
 //===--------------------------------------------------------------------===//
 // OperationFolder
 //===--------------------------------------------------------------------===//
 
 /// A utility class for folding operations, and unifying duplicated constants
 /// generated along the way.
 class OperationFolder {
private:
   /// created within it.
   DenseMap<Region *, ConstantMap> foldScopes;
 
   /// This map tracks all of the dialects that an operation is referenced by;
   /// given that many dialects may generate the same constant.
   DenseMap<Operation *, SmallVector<Dialect *, 2>> referencedDialects;
 
   /// A collection of dialect folder interfaces.
-  DialectInterfaceCollection<OpFolderDialectInterface> interfaces;
+  DialectInterfaceCollection<DialectFoldInterface> interfaces;
 };
 
 } // end namespace mlir
 
 #endif // MLIR_TRANSFORMS_FOLDUTILS_H

mlir/lib/Transforms/Utils/FoldUtils.cpp

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/Operation.h"
 
 using namespace mlir;
 
 /// Given an operation, find the parent region that folded constants should be
 /// inserted into.
-static Region *getInsertionRegion(
-    DialectInterfaceCollection<OpFolderDialectInterface> &interfaces,
+static Region *
+getInsertionRegion(DialectInterfaceCollection<DialectFoldInterface> &interfaces,
                    Block *insertionBlock) {
   while (Region *region = insertionBlock->getParent()) {
     // Insert in this region for any of the following scenarios:
     //  * The parent is unregistered, or is known to be isolated from above.
     //  * The parent is a top-level operation.
     auto *parentOp = region->getParentOp();
     if (!parentOp->isRegistered() || parentOp->isKnownIsolatedFromAbove() ||
         !parentOp->getBlock())
       return region;

mlir/test/lib/Dialect/Test/TestDialect.cpp

void getAsmBlockArgumentNames(Block *block,
     auto e = std::min(arrayAttr.size(), args.size());
     for (unsigned i = 0; i < e; ++i) {
       if (auto strAttr = arrayAttr[i].dyn_cast<StringAttr>())
         setNameFn(args[i], strAttr.getValue());
     }
   }
 };
 
-struct TestOpFolderDialectInterface : public OpFolderDialectInterface {
-  using OpFolderDialectInterface::OpFolderDialectInterface;
+struct TestDialectFoldInterface : public DialectFoldInterface {
+  using DialectFoldInterface::DialectFoldInterface;
 
   /// Registered hook to check if the given region, which is attached to an
   /// operation that is *not* isolated from above, should be used when
   /// materializing constants.
   bool shouldMaterializeInto(Region *region) const final {
     // If this is a one region operation, then insert into it.
     return isa<OneRegionOp>(region->getParentOp());
   }

 // TestDialect
 //===----------------------------------------------------------------------===//
 
 void TestDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "TestOps.cpp.inc"
       >();
-  addInterfaces<TestOpAsmInterface, TestOpFolderDialectInterface,
+  addInterfaces<TestOpAsmInterface, TestDialectFoldInterface,
                 TestInlinerInterface>();
   addTypes<TestType, TestRecursiveType>();
   allowUnknownOperations();
 }
 
 static Type parseTestType(DialectAsmParser &parser,
                           llvm::SetVector<Type> &stack) {
   StringRef typeTag;