[mlir][NFC] Add inlineRegion overloads that take a block iterator insert position

[rriddle]

Summary

This allows for inlining into an empty block or to the beginning of a block. NFC as the existing implementations now foward to this overload.

mlir/include/mlir/Transforms/InliningUtils.h

 /// information. 'shouldCloneInlinedRegion' corresponds to whether the source
 /// region should be cloned into the 'inlinePoint' or spliced directly.
 LogicalResult inlineRegion(InlinerInterface &interface, Region *src,
                            Operation *inlinePoint, BlockAndValueMapping &mapper,
                            ValueRange resultsToReplace,
                            TypeRange regionResultTypes,
                            Optional<Location> inlineLoc = llvm::None,
                            bool shouldCloneInlinedRegion = true);
+LogicalResult inlineRegion(InlinerInterface &interface, Region *src,
+                           Block *inlineBlock, Block::iterator inlinePoint,
+                           BlockAndValueMapping &mapper,
+                           ValueRange resultsToReplace,
+                           TypeRange regionResultTypes,
+                           Optional<Location> inlineLoc = llvm::None,
+                           bool shouldCloneInlinedRegion = true);
 
 /// This function is an overload of the above 'inlineRegion' that allows for
 /// providing the set of operands ('inlinedOperands') that should be used
 /// in-favor of the region arguments when inlining.
 LogicalResult inlineRegion(InlinerInterface &interface, Region *src,
                            Operation *inlinePoint, ValueRange inlinedOperands,
                            ValueRange resultsToReplace,
                            Optional<Location> inlineLoc = llvm::None,
                            bool shouldCloneInlinedRegion = true);
+LogicalResult inlineRegion(InlinerInterface &interface, Region *src,
+                           Block *inlineBlock, Block::iterator inlinePoint,
+                           ValueRange inlinedOperands,
+                           ValueRange resultsToReplace,
+                           Optional<Location> inlineLoc = llvm::None,
+                           bool shouldCloneInlinedRegion = true);
 
 /// This function inlines a given region, 'src', of a callable operation,
 /// 'callable', into the location defined by the given call operation. This
 /// function returns failure if inlining is not possible, success otherwise. On
 /// failure, no changes are made to the module. 'shouldCloneInlinedRegion'
 /// corresponds to whether the source region should be cloned into the 'call' or
 /// spliced directly.
 LogicalResult inlineCall(InlinerInterface &interface, CallOpInterface call,
                          CallableOpInterface callable, Region *src,
                          bool shouldCloneInlinedRegion = true);
 
 } // end namespace mlir
 
 #endif // MLIR_TRANSFORMS_INLINING_UTILS_H

mlir/lib/Transforms/Utils/InliningUtils.cpp

static bool isLegalToInline(InlinerInterface &interface, Region *src,
   return true;
 }
 
 //===----------------------------------------------------------------------===//
 // Inline Methods
 //===----------------------------------------------------------------------===//
 
 static LogicalResult
-inlineRegionImpl(InlinerInterface &interface, Region *src,
-                 Operation *inlinePoint, BlockAndValueMapping &mapper,
+inlineRegionImpl(InlinerInterface &interface, Region *src, Block *inlineBlock,
+                 Block::iterator inlinePoint, BlockAndValueMapping &mapper,
                  ValueRange resultsToReplace, TypeRange regionResultTypes,
                  Optional<Location> inlineLoc, bool shouldCloneInlinedRegion,
-                 Operation *call) {
+                 Operation *call = nullptr) {
   assert(resultsToReplace.size() == regionResultTypes.size());
   // We expect the region to have at least one block.
   if (src->empty())
     return failure();
 
   // Check that all of the region arguments have been mapped.
   auto *srcEntryBlock = &src->front();
   if (llvm::any_of(srcEntryBlock->getArguments(),
                    [&](BlockArgument arg) { return !mapper.contains(arg); }))
     return failure();
 
-  // The insertion point must be within a block.
-  Block *insertBlock = inlinePoint->getBlock();
-  if (!insertBlock)
-    return failure();
-  Region *insertRegion = insertBlock->getParent();
+  Region *insertRegion = inlineBlock->getParent();
 
   // Check that the operations within the source region are valid to inline.
   if (!interface.isLegalToInline(insertRegion, src, shouldCloneInlinedRegion,
                                  mapper) ||
       !isLegalToInline(interface, src, insertRegion, shouldCloneInlinedRegion,
                        mapper))
     return failure();
 
-  // Split the insertion block.
-  Block *postInsertBlock =
-      insertBlock->splitBlock(++inlinePoint->getIterator());
-
   // Check to see if the region is being cloned, or moved inline. In either
   // case, move the new blocks after the 'insertBlock' to improve IR
   // readability.
+  Block *postInsertBlock = inlineBlock->splitBlock(inlinePoint);
   if (shouldCloneInlinedRegion)
     src->cloneInto(insertRegion, postInsertBlock->getIterator(), mapper);
   else
     insertRegion->getBlocks().splice(postInsertBlock->getIterator(),
                                      src->getBlocks(), src->begin(),
                                      src->end());
 
   // Get the range of newly inserted blocks.
-  auto newBlocks = llvm::make_range(std::next(insertBlock->getIterator()),
+  auto newBlocks = llvm::make_range(std::next(inlineBlock->getIterator()),
                                     postInsertBlock->getIterator());
   Block *firstNewBlock = &*newBlocks.begin();
 
   // Remap the locations of the inlined operations if a valid source location
   // was provided.
   if (inlineLoc && !inlineLoc->isa<UnknownLoc>())
     remapInlinedLocations(newBlocks, *inlineLoc);
 
if (std::next(newBlocks.begin()) == newBlocks.end()) {
     }
 
     /// Handle the terminators for each of the new blocks.
     for (auto &newBlock : newBlocks)
       interface.handleTerminator(newBlock.getTerminator(), postInsertBlock);
   }
 
   // Splice the instructions of the inlined entry block into the insert block.
-  insertBlock->getOperations().splice(insertBlock->end(),
+  inlineBlock->getOperations().splice(inlineBlock->end(),
                                       firstNewBlock->getOperations());
   firstNewBlock->erase();
   return success();
 }
 
 static LogicalResult
-inlineRegionImpl(InlinerInterface &interface, Region *src,
-                 Operation *inlinePoint, ValueRange inlinedOperands,
+inlineRegionImpl(InlinerInterface &interface, Region *src, Block *inlineBlock,
+                 Block::iterator inlinePoint, ValueRange inlinedOperands,
                  ValueRange resultsToReplace, Optional<Location> inlineLoc,
-                 bool shouldCloneInlinedRegion, Operation *call) {
+                 bool shouldCloneInlinedRegion, Operation *call = nullptr) {
   // We expect the region to have at least one block.
   if (src->empty())
     return failure();
 
   auto *entryBlock = &src->front();
   if (inlinedOperands.size() != entryBlock->getNumArguments())
     return failure();
 
   // Map the provided call operands to the arguments of the region.
   BlockAndValueMapping mapper;
   for (unsigned i = 0, e = inlinedOperands.size(); i != e; ++i) {
     // Verify that the types of the provided values match the function argument
     // types.
     BlockArgument regionArg = entryBlock->getArgument(i);
     if (inlinedOperands[i].getType() != regionArg.getType())
       return failure();
     mapper.map(regionArg, inlinedOperands[i]);
   }
 
   // Call into the main region inliner function.
-  return inlineRegionImpl(interface, src, inlinePoint, mapper, resultsToReplace,
-                          resultsToReplace.getTypes(), inlineLoc,
-                          shouldCloneInlinedRegion, call);
+  return inlineRegionImpl(interface, src, inlineBlock, inlinePoint, mapper,
+                          resultsToReplace, resultsToReplace.getTypes(),
+                          inlineLoc, shouldCloneInlinedRegion, call);
 }
 
 LogicalResult mlir::inlineRegion(InlinerInterface &interface, Region *src,
                                  Operation *inlinePoint,
                                  BlockAndValueMapping &mapper,
                                  ValueRange resultsToReplace,
                                  TypeRange regionResultTypes,
                                  Optional<Location> inlineLoc,
                                  bool shouldCloneInlinedRegion) {
-  return inlineRegionImpl(interface, src, inlinePoint, mapper, resultsToReplace,
-                          regionResultTypes, inlineLoc,
-                          shouldCloneInlinedRegion,
-                          /*call=*/nullptr);
+  return inlineRegion(interface, src, inlinePoint->getBlock(),
+                      ++inlinePoint->getIterator(), mapper, resultsToReplace,
+                      regionResultTypes, inlineLoc, shouldCloneInlinedRegion);
+}
+LogicalResult
+mlir::inlineRegion(InlinerInterface &interface, Region *src, Block *inlineBlock,
+                   Block::iterator inlinePoint, BlockAndValueMapping &mapper,
+                   ValueRange resultsToReplace, TypeRange regionResultTypes,
+                   Optional<Location> inlineLoc,
+                   bool shouldCloneInlinedRegion) {
+  return inlineRegionImpl(interface, src, inlineBlock, inlinePoint, mapper,
+                          resultsToReplace, regionResultTypes, inlineLoc,
+                          shouldCloneInlinedRegion);
 }
 
 LogicalResult mlir::inlineRegion(InlinerInterface &interface, Region *src,
                                  Operation *inlinePoint,
                                  ValueRange inlinedOperands,
                                  ValueRange resultsToReplace,
                                  Optional<Location> inlineLoc,
                                  bool shouldCloneInlinedRegion) {
-  return inlineRegionImpl(interface, src, inlinePoint, inlinedOperands,
-                          resultsToReplace, inlineLoc, shouldCloneInlinedRegion,
-                          /*call=*/nullptr);
+  return inlineRegion(interface, src, inlinePoint->getBlock(),
+                      ++inlinePoint->getIterator(), inlinedOperands,
+                      resultsToReplace, inlineLoc, shouldCloneInlinedRegion);
+}
+LogicalResult
+mlir::inlineRegion(InlinerInterface &interface, Region *src, Block *inlineBlock,
+                   Block::iterator inlinePoint, ValueRange inlinedOperands,
+                   ValueRange resultsToReplace, Optional<Location> inlineLoc,
+                   bool shouldCloneInlinedRegion) {
+  return inlineRegionImpl(interface, src, inlineBlock, inlinePoint,
+                          inlinedOperands, resultsToReplace, inlineLoc,
+                          shouldCloneInlinedRegion);
 }
 
 /// Utility function used to generate a cast operation from the given interface,
 /// or return nullptr if a cast could not be generated.
 static Value materializeConversion(const DialectInlinerInterface *interface,
                                    SmallVectorImpl<Operation *> &castOps,
                                    OpBuilder &castBuilder, Value arg, Type type,
                                    Location conversionLoc) {
for (unsigned i = 0, e = callResults.size(); i != e; ++i) {
     castResult.getDefiningOp()->replaceUsesOfWith(castResult, callResult);
   }
 
   // Check that it is legal to inline the callable into the call.
   if (!interface.isLegalToInline(call, callable, shouldCloneInlinedRegion))
     return cleanupState();
 
   // Attempt to inline the call.
-  if (failed(inlineRegionImpl(interface, src, call, mapper, callResults,
+  if (failed(inlineRegionImpl(interface, src, call->getBlock(),
+                              ++call->getIterator(), mapper, callResults,
                               callableResultTypes, call.getLoc(),
                               shouldCloneInlinedRegion, call)))
     return cleanupState();
   return success();
 }