#include "mlir/Transforms/RegionUtils.h"
#include "mlir/IR/Block.h"
#include "mlir/IR/Operation.h"
+#include "mlir/IR/PatternMatch.h"
#include "mlir/IR/RegionGraphTraits.h"
#include "mlir/IR/Value.h"
#include "mlir/Interfaces/ControlFlowInterfaces.h"
/// Erase the unreachable blocks within the provided regions. Returns success
/// if any blocks were erased, failure otherwise.
// TODO: We could likely merge this with the DCE algorithm below.
-static LogicalResult eraseUnreachableBlocks(MutableArrayRef<Region> regions) {
+static LogicalResult eraseUnreachableBlocks(RewriterBase &rewriter,
+ MutableArrayRef<Region> regions) {
// Set of blocks found to be reachable within a given region.
llvm::df_iterator_default_set<Block *, 16> reachable;
// If any blocks were found to be dead.
for (Block &block : llvm::make_early_inc_range(*region)) {
if (!reachable.count(&block)) {
block.dropAllDefinedValueUses();
- block.erase();
+ rewriter.eraseBlock(&block);
erasedDeadBlocks = true;
continue;
}
}
}
-static LogicalResult deleteDeadness(MutableArrayRef<Region> regions,
+static LogicalResult deleteDeadness(RewriterBase &rewriter,
+ MutableArrayRef<Region> regions,
LiveMap &liveMap) {
bool erasedAnything = false;
for (Region ®ion : regions) {
if (!liveMap.wasProvenLive(&childOp)) {
erasedAnything = true;
childOp.dropAllUses();
- childOp.erase();
+ rewriter.eraseOp(&childOp);
} else {
- erasedAnything |=
- succeeded(deleteDeadness(childOp.getRegions(), liveMap));
+ erasedAnything |= succeeded(
+ deleteDeadness(rewriter, childOp.getRegions(), liveMap));
}
}
}
//
// This function returns success if any operations or arguments were deleted,
// failure otherwise.
-static LogicalResult runRegionDCE(MutableArrayRef<Region> regions) {
+static LogicalResult runRegionDCE(RewriterBase &rewriter,
+ MutableArrayRef<Region> regions) {
LiveMap liveMap;
do {
liveMap.resetChanged();
propagateLiveness(region, liveMap);
} while (liveMap.hasChanged());
- return deleteDeadness(regions, liveMap);
+ return deleteDeadness(rewriter, regions, liveMap);
}
//===----------------------------------------------------------------------===//
LogicalResult addToCluster(BlockEquivalenceData &blockData);
/// Try to merge all of the blocks within this cluster into the leader block.
- LogicalResult merge();
+ LogicalResult merge(RewriterBase &rewriter);
private:
/// The equivalence data for the leader of the cluster.
return true;
}
-LogicalResult BlockMergeCluster::merge() {
+LogicalResult BlockMergeCluster::merge(RewriterBase &rewriter) {
// Don't consider clusters that don't have blocks to merge.
if (blocksToMerge.empty())
return failure();
// Replace all uses of the merged blocks with the leader and erase them.
for (Block *block : blocksToMerge) {
block->replaceAllUsesWith(leaderBlock);
- block->erase();
+ rewriter.eraseBlock(block);
}
return success();
}
/// Identify identical blocks within the given region and merge them, inserting
/// new block arguments as necessary. Returns success if any blocks were merged,
/// failure otherwise.
-static LogicalResult mergeIdenticalBlocks(Region ®ion) {
+static LogicalResult mergeIdenticalBlocks(RewriterBase &rewriter,
+ Region ®ion) {
if (region.empty() || llvm::hasSingleElement(region))
return failure();
clusters.emplace_back(std::move(data));
}
for (auto &cluster : clusters)
- mergedAnyBlocks |= succeeded(cluster.merge());
+ mergedAnyBlocks |= succeeded(cluster.merge(rewriter));
}
return success(mergedAnyBlocks);
/// Identify identical blocks within the given regions and merge them, inserting
/// new block arguments as necessary.
-static LogicalResult mergeIdenticalBlocks(MutableArrayRef<Region> regions) {
+static LogicalResult mergeIdenticalBlocks(RewriterBase &rewriter,
+ MutableArrayRef<Region> regions) {
llvm::SmallSetVector<Region *, 1> worklist;
for (auto ®ion : regions)
worklist.insert(®ion);
bool anyChanged = false;
while (!worklist.empty()) {
Region *region = worklist.pop_back_val();
- if (succeeded(mergeIdenticalBlocks(*region))) {
+ if (succeeded(mergeIdenticalBlocks(rewriter, *region))) {
worklist.insert(region);
anyChanged = true;
}
/// includes transformations like unreachable block elimination, dead argument
/// elimination, as well as some other DCE. This function returns success if any
/// of the regions were simplified, failure otherwise.
-LogicalResult mlir::simplifyRegions(MutableArrayRef<Region> regions) {
- bool eliminatedBlocks = succeeded(eraseUnreachableBlocks(regions));
- bool eliminatedOpsOrArgs = succeeded(runRegionDCE(regions));
- bool mergedIdenticalBlocks = succeeded(mergeIdenticalBlocks(regions));
+LogicalResult mlir::simplifyRegions(RewriterBase &rewriter,
+ MutableArrayRef<Region> regions) {
+ bool eliminatedBlocks = succeeded(eraseUnreachableBlocks(rewriter, regions));
+ bool eliminatedOpsOrArgs = succeeded(runRegionDCE(rewriter, regions));
+ bool mergedIdenticalBlocks =
+ succeeded(mergeIdenticalBlocks(rewriter, regions));
return success(eliminatedBlocks || eliminatedOpsOrArgs ||
mergedIdenticalBlocks);
}