[mlir] Expose region utils functions

[clementval]

Summary

As discussed in D109579, this patch exposes runRegionDCE and
eraseUnreachableBlocks so they can be used as separate utilities in
other passes.

mlir/include/mlir/Transforms/RegionUtils.h

 /// Run a set of structural simplifications over the given regions. This
 /// 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. The provided rewriter is
 /// used to notify callers of operation and block deletion.
 LogicalResult simplifyRegions(RewriterBase &rewriter,
                               MutableArrayRef<Region> regions);
 
+/// Erase the unreachable blocks within the provided regions. Returns success
+/// if any blocks were erased, failure otherwise.
+LogicalResult eraseUnreachableBlocks(RewriterBase &rewriter,
+                                     MutableArrayRef<Region> regions);
+
+/// This function returns success if any operations or arguments were deleted,
+/// failure otherwise.
+LogicalResult runRegionDCE(RewriterBase &rewriter,
+                           MutableArrayRef<Region> regions);
+
 } // namespace mlir
 
 #endif // MLIR_TRANSFORMS_REGIONUTILS_H_

mlir/lib/Transforms/Utils/RegionUtils.cpp

 
 //===----------------------------------------------------------------------===//
 // Unreachable Block Elimination
 //===----------------------------------------------------------------------===//
 
 /// 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(RewriterBase &rewriter,
-                                            MutableArrayRef<Region> regions) {
+LogicalResult mlir::eraseUnreachableBlocks(RewriterBase &rewriter,
   // 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.
   bool erasedDeadBlocks = false;
 
   SmallVector<Region *, 1> worklist;
   worklist.reserve(regions.size());
   for (Region &region : regions)

 // This is a simple fixed-point dataflow analysis algorithm on a lattice
 // {Dead,Alive}. Because liveness flows backward, we generally try to
 // iterate everything backward to speed up convergence to the fixed-point. This
 // allows for being able to delete recursively dead cycles of the use-def graph,
 // including block arguments.
 //
 // This function returns success if any operations or arguments were deleted,
 // failure otherwise.
-static LogicalResult runRegionDCE(RewriterBase &rewriter,
-                                  MutableArrayRef<Region> regions) {
+LogicalResult mlir::runRegionDCE(RewriterBase &rewriter,
   LiveMap liveMap;
   do {
     liveMap.resetChanged();
 
     for (Region &region : regions)
       propagateLiveness(region, liveMap);
   } while (liveMap.hasChanged());