* `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
`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
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:
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
#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
DenseMap<Operation *, SmallVector<Dialect *, 2>> referencedDialects;
/// A collection of dialect folder interfaces.
- DialectInterfaceCollection<OpFolderDialectInterface> interfaces;
+ DialectInterfaceCollection<DialectFoldInterface> interfaces;
};
} // end namespace mlir
/// Given an operation, find the parent region that folded constants should be
/// inserted into.
-static Region *getInsertionRegion(
- DialectInterfaceCollection<OpFolderDialectInterface> &interfaces,
- Block *insertionBlock) {
+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.
}
};
-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
#define GET_OP_LIST
#include "TestOps.cpp.inc"
>();
- addInterfaces<TestOpAsmInterface, TestOpFolderDialectInterface,
+ addInterfaces<TestOpAsmInterface, TestDialectFoldInterface,
TestInlinerInterface>();
addTypes<TestType, TestRecursiveType>();
allowUnknownOperations();