edc6c0ecb9
The current implementation is quite clunky; OperationName stores either an Identifier or an AbstractOperation that corresponds to an operation. This has several problems: * OperationNames created before and after an operation are registered are different * Accessing the identifier name/dialect/etc. from an OperationName are overly branchy - they need to dyn_cast a PointerUnion to check the state This commit refactors this such that we create a single information struct for every operation name, even operations that aren't registered yet. When an OperationName is created for an unregistered operation, we only populate the name field. When the operation is registered, we populate the remaining fields. With this we now have two new classes: OperationName and RegisteredOperationName. These both point to the same underlying operation information struct, but only RegisteredOperationName can assume that the operation is actually registered. This leads to a much cleaner API, and we can also move some AbstractOperation functionality directly to OperationName. Differential Revision: https://reviews.llvm.org/D114049
67 lines
2.4 KiB
C++
67 lines
2.4 KiB
C++
//===- Canonicalizer.cpp - Canonicalize MLIR operations -------------------===//
|
|
//
|
|
// 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 transformation pass converts operations into their canonical forms by
|
|
// folding constants, applying operation identity transformations etc.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "PassDetail.h"
|
|
#include "mlir/Pass/Pass.h"
|
|
#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
|
|
#include "mlir/Transforms/Passes.h"
|
|
|
|
using namespace mlir;
|
|
|
|
namespace {
|
|
/// Canonicalize operations in nested regions.
|
|
struct Canonicalizer : public CanonicalizerBase<Canonicalizer> {
|
|
Canonicalizer(const GreedyRewriteConfig &config) : config(config) {}
|
|
|
|
Canonicalizer() {
|
|
// Default constructed Canonicalizer takes its settings from command line
|
|
// options.
|
|
config.useTopDownTraversal = topDownProcessingEnabled;
|
|
config.enableRegionSimplification = enableRegionSimplification;
|
|
config.maxIterations = maxIterations;
|
|
}
|
|
|
|
/// Initialize the canonicalizer by building the set of patterns used during
|
|
/// execution.
|
|
LogicalResult initialize(MLIRContext *context) override {
|
|
RewritePatternSet owningPatterns(context);
|
|
for (auto *dialect : context->getLoadedDialects())
|
|
dialect->getCanonicalizationPatterns(owningPatterns);
|
|
for (RegisteredOperationName op : context->getRegisteredOperations())
|
|
op.getCanonicalizationPatterns(owningPatterns, context);
|
|
|
|
patterns = FrozenRewritePatternSet(std::move(owningPatterns),
|
|
disabledPatterns, enabledPatterns);
|
|
return success();
|
|
}
|
|
void runOnOperation() override {
|
|
(void)applyPatternsAndFoldGreedily(getOperation()->getRegions(), patterns,
|
|
config);
|
|
}
|
|
|
|
GreedyRewriteConfig config;
|
|
FrozenRewritePatternSet patterns;
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
/// Create a Canonicalizer pass.
|
|
std::unique_ptr<Pass> mlir::createCanonicalizerPass() {
|
|
return std::make_unique<Canonicalizer>();
|
|
}
|
|
|
|
/// Creates an instance of the Canonicalizer pass with the specified config.
|
|
std::unique_ptr<Pass>
|
|
mlir::createCanonicalizerPass(const GreedyRewriteConfig &config) {
|
|
return std::make_unique<Canonicalizer>(config);
|
|
}
|