SIL: move all the block-list modifying APIs to SILFunction.

... and remove SILFunction::getBlocks().

It's just a cleanup, NFC.

Author: eeckstein

include/swift/SIL/SILBasicBlock.h

@@ -56,7 +56,7 @@ public llvm::ilist_node<SILBasicBlock>, public SILAllocated<SILBasicBlock> {
 
   void operator delete(void *Ptr, size_t) = delete;
 
-  SILBasicBlock(SILFunction *F, SILBasicBlock *relativeToBB, bool after);
+  SILBasicBlock(SILFunction *parent) : Parent(parent), PredList(nullptr) { }
 
 public:
   ~SILBasicBlock();
@@ -143,12 +143,6 @@ public llvm::ilist_node<SILBasicBlock>, public SILAllocated<SILBasicBlock> {
   /// without a terminator.
   SILBasicBlock *split(iterator I);
 
-  /// Move the basic block to after the specified basic block in the IR.
-  ///
-  /// Assumes that the basic blocks must reside in the same function. In asserts
-  /// builds, an assert verifies that this is true.
-  void moveAfter(SILBasicBlock *After);
-
   /// Moves the instruction to the iterator in this basic block.
   void moveTo(SILBasicBlock::iterator To, SILInstruction *I);
 

include/swift/SIL/SILBuilder.h

@@ -354,25 +354,6 @@ class SILBuilder {
   // CFG Manipulation
   //===--------------------------------------------------------------------===//
 
-  /// moveBlockTo - Move a block to immediately before the given iterator.
-  void moveBlockTo(SILBasicBlock *BB, SILFunction::iterator IP) {
-    assert(SILFunction::iterator(BB) != IP && "moving block before itself?");
-    SILFunction *F = BB->getParent();
-    auto &Blocks = F->getBlocks();
-    Blocks.remove(BB);
-    Blocks.insert(IP, BB);
-  }
-
-  /// moveBlockTo - Move \p BB to immediately before \p Before.
-  void moveBlockTo(SILBasicBlock *BB, SILBasicBlock *Before) {
-    moveBlockTo(BB, Before->getIterator());
-  }
-
-  /// moveBlockToEnd - Reorder a block to the end of its containing function.
-  void moveBlockToEnd(SILBasicBlock *BB) {
-    moveBlockTo(BB, BB->getParent()->end());
-  }
-
   /// Move the insertion point to the end of the given block.
   ///
   /// Assumes that no insertion point is currently active.

include/swift/SIL/SILFunction.h

@@ -959,7 +959,12 @@ class SILFunction
   SILType mapTypeIntoContext(SILType type) const;
 
   /// Converts the given function definition to a declaration.
-  void convertToDeclaration();
+  void convertToDeclaration() {
+    assert(isDefinition() && "Can only convert definitions to declarations");
+    clear();
+  }
+
+  void clear();
 
   /// Return the identity substitutions necessary to forward this call if it is
   /// generic.
@@ -969,9 +974,6 @@ class SILFunction
   // Block List Access
   //===--------------------------------------------------------------------===//
 
-  BlockListType &getBlocks() { return BlockList; }
-  const BlockListType &getBlocks() const { return BlockList; }
-
   using iterator = BlockListType::iterator;
   using reverse_iterator = BlockListType::reverse_iterator;
   using const_iterator = BlockListType::const_iterator;
@@ -995,9 +997,38 @@ class SILFunction
   SILBasicBlock *createBasicBlockAfter(SILBasicBlock *afterBB);
   SILBasicBlock *createBasicBlockBefore(SILBasicBlock *beforeBB);
 
-  /// Splice the body of \p F into this function at end.
-  void spliceBody(SILFunction *F) {
-    getBlocks().splice(begin(), F->getBlocks());
+  /// Removes and destroys \p BB;
+  void eraseBlock(SILBasicBlock *BB) {
+    assert(BB->getParent() == this);
+    BlockList.erase(BB);
+  }
+
+  /// Transfer all blocks of \p F into this function, at the begin of the block
+  /// list.
+  void moveAllBlocksFromOtherFunction(SILFunction *F) {
+    BlockList.splice(begin(), F->BlockList);
+  }
+  
+  /// Transfer \p blockInOtherFunction of another function into this function,
+  /// before \p insertPointInThisFunction.
+  void moveBlockFromOtherFunction(SILBasicBlock *blockInOtherFunction,
+                                  iterator insertPointInThisFunction) {
+    SILFunction *otherFunc = blockInOtherFunction->getParent();
+    assert(otherFunc != this);
+    BlockList.splice(insertPointInThisFunction, otherFunc->BlockList,
+                     blockInOtherFunction);
+  }
+
+  /// Move block \p BB to immediately before the iterator \p IP.
+  ///
+  /// The block must be part of this function.
+  void moveBlockBefore(SILBasicBlock *BB, SILFunction::iterator IP);
+
+  /// Move block \p BB to immediately after block \p After.
+  ///
+  /// The block must be part of this function.
+  void moveBlockAfter(SILBasicBlock *BB, SILBasicBlock *After) {
+    moveBlockBefore(BB, std::next(After->getIterator()));
   }
 
   /// Return the unique basic block containing a return inst if it

include/swift/SILOptimizer/Utils/PerformanceInlinerUtils.h

@@ -460,7 +460,7 @@ class ShortestPathAnalysis {
       analyzeLoopsRecursively(Loop, 1);
     }
     // Compute the distances for the function itself.
-    solveDataFlow(F->getBlocks(), 0);
+    solveDataFlow(*F, 0);
   }
 
   /// Returns the length of the shortest path of the block \p BB in the loop

lib/SIL/IR/SILBasicBlock.cpp

@@ -31,17 +31,6 @@ using namespace swift;
 // SILBasicBlock Implementation
 //===----------------------------------------------------------------------===//
 
-SILBasicBlock::SILBasicBlock(SILFunction *parent, SILBasicBlock *relativeToBB,
-                             bool after)
-    : Parent(parent), PredList(nullptr) {
-  if (!relativeToBB) {
-    parent->getBlocks().push_back(this);
-  } else if (after) {
-    parent->getBlocks().insertAfter(relativeToBB->getIterator(), this);
-  } else {
-    parent->getBlocks().insert(relativeToBB->getIterator(), this);
-  }
-}
 SILBasicBlock::~SILBasicBlock() {
   if (!getParent()) {
     assert(ArgumentList.empty() &&
@@ -134,7 +123,7 @@ SILBasicBlock::iterator SILBasicBlock::erase(SILInstruction *I) {
 
 /// This method unlinks 'self' from the containing SILFunction and deletes it.
 void SILBasicBlock::eraseFromParent() {
-  getParent()->getBlocks().erase(this);
+  getParent()->eraseBlock(this);
 }
 
 void SILBasicBlock::cloneArgumentList(SILBasicBlock *Other) {
@@ -289,23 +278,13 @@ void SILBasicBlock::eraseArgument(int Index) {
 /// stay as part of the original basic block. The old basic block is left
 /// without a terminator.
 SILBasicBlock *SILBasicBlock::split(iterator I) {
-  SILBasicBlock *New =
-    new (Parent->getModule()) SILBasicBlock(Parent, this, /*after*/true);
+  SILBasicBlock *New = Parent->createBasicBlockAfter(this);
   // Move all of the specified instructions from the original basic block into
   // the new basic block.
   New->InstList.splice(New->end(), InstList, I, end());
   return New;
 }
 
-/// Move the basic block to after the specified basic block in the IR.
-void SILBasicBlock::moveAfter(SILBasicBlock *After) {
-  assert(getParent() && getParent() == After->getParent() &&
-         "Blocks must be in the same function");
-  auto InsertPt = std::next(SILFunction::iterator(After));
-  auto &BlkList = getParent()->getBlocks();
-  BlkList.splice(InsertPt, BlkList, this);
-}
-
 void SILBasicBlock::moveTo(SILBasicBlock::iterator To, SILInstruction *I) {
   assert(I->getParent() != this && "Must move from different basic block");
   InstList.splice(To, I->getParent()->InstList, I);

lib/SIL/IR/SILFunction.cpp

@@ -357,17 +357,29 @@ bool SILFunction::isWeakImported() const {
 }
 
 SILBasicBlock *SILFunction::createBasicBlock() {
-  return new (getModule()) SILBasicBlock(this, nullptr, false);
+  SILBasicBlock *newBlock = new (getModule()) SILBasicBlock(this);
+  BlockList.push_back(newBlock);
+  return newBlock;
 }
 
 SILBasicBlock *SILFunction::createBasicBlockAfter(SILBasicBlock *afterBB) {
-  assert(afterBB);
-  return new (getModule()) SILBasicBlock(this, afterBB, /*after*/ true);
+  SILBasicBlock *newBlock = new (getModule()) SILBasicBlock(this);
+  BlockList.insertAfter(afterBB->getIterator(), newBlock);
+  return newBlock;
 }
 
 SILBasicBlock *SILFunction::createBasicBlockBefore(SILBasicBlock *beforeBB) {
-  assert(beforeBB);
-  return new (getModule()) SILBasicBlock(this, beforeBB, /*after*/ false);
+  SILBasicBlock *newBlock = new (getModule()) SILBasicBlock(this);
+  BlockList.insert(beforeBB->getIterator(), newBlock);
+  return newBlock;
+}
+
+void SILFunction::moveBlockBefore(SILBasicBlock *BB, SILFunction::iterator IP) {
+  assert(BB->getParent() == this);
+  if (SILFunction::iterator(BB) == IP)
+    return;
+  BlockList.remove(BB);
+  BlockList.insert(IP, BB);
 }
 
 //===----------------------------------------------------------------------===//
@@ -642,10 +654,9 @@ bool SILFunction::isExternallyUsedSymbol() const {
                                          getModule().isWholeModule());
 }
 
-void SILFunction::convertToDeclaration() {
-  assert(isDefinition() && "Can only convert definitions to declarations");
+void SILFunction::clear() {
   dropAllReferences();
-  getBlocks().clear();
+  BlockList.clear();
 }
 
 SubstitutionMap SILFunction::getForwardingSubstitutionMap() {

lib/SIL/IR/SILModule.cpp

@@ -511,9 +511,8 @@ void SILModule::eraseFunction(SILFunction *F) {
 
   // This opens dead-function-removal opportunities for called functions.
   // (References are not needed anymore.)
-  F->dropAllReferences();
+  F->clear();
   F->dropDynamicallyReplacedFunction();
-  F->getBlocks().clear();
   // Drop references for any _specialize(target:) functions.
   F->clearSpecializeAttrs();
 }

lib/SIL/Parser/ParseSIL.cpp

@@ -5714,8 +5714,7 @@ bool SILParser::parseSILBasicBlock(SILBuilder &B) {
 
   // Make sure the block is at the end of the function so that forward
   // references don't affect block layout.
-  F->getBlocks().remove(BB);
-  F->getBlocks().push_back(BB);
+  F->moveBlockBefore(BB, F->end());
 
   B.setInsertionPoint(BB);
   do {

lib/SIL/Verifier/SILVerifier.cpp

@@ -5528,7 +5528,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     }
 
     // Otherwise, verify the body of the function.
-    verifyEntryBlock(&*F->getBlocks().begin());
+    verifyEntryBlock(F->getEntryBlock());
     verifyEpilogBlocks(F);
     verifyFlowSensitiveRules(F);
     verifyBranches(F);

lib/SILGen/SILGenEpilog.cpp

@@ -146,7 +146,7 @@ prepareForEpilogBlockEmission(SILGenFunction &SGF, SILLocation topLevel,
 
   // Move the epilog block to the end of the ordinary section.
   auto endOfOrdinarySection = SGF.StartOfPostmatter;
-  SGF.B.moveBlockTo(epilogBB, endOfOrdinarySection);
+  SGF.F.moveBlockBefore(epilogBB, endOfOrdinarySection);
 
   // Emit the epilog into the epilog bb. Its arguments are the
   // direct results.
@@ -282,7 +282,7 @@ static bool prepareExtraEpilog(SILGenFunction &SGF, JumpDest &dest,
   // Reposition the block to the end of the postmatter section
   // unless we're emitting into a single predecessor.
   if (reposition) {
-    SGF.B.moveBlockTo(epilogBB, SGF.F.end());
+    SGF.F.moveBlockBefore(epilogBB, SGF.F.end());
   }
 
   SGF.B.setInsertionPoint(epilogBB);