SIL: add a utility function to check if a terminator exits a function. NFC

Author: eeckstein

include/swift/SIL/SILInstruction.h

@@ -3787,6 +3787,12 @@ class TermInst : public SILInstruction {
 
   bool isBranch() const { return !getSuccessors().empty(); }
 
+  /// Returns true if this terminator exits the function.
+  bool isFunctionExiting() const {
+    return getKind() == ValueKind::ThrowInst ||
+           getKind() == ValueKind::ReturnInst;
+  }
+
   TermKind getTermKind() const { return ValueKindAsTermKind(getKind()); }
 };
 

lib/SIL/SILVerifier.cpp

@@ -2975,11 +2975,11 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
                   "stack dealloc does not match most recent stack alloc");
           stack.pop_back();
         }
-        if (isa<ReturnInst>(&i) || isa<ThrowInst>(&i)) {
-          require(stack.empty(),
-                  "return with stack allocs that haven't been deallocated");
-        }
         if (auto term = dyn_cast<TermInst>(&i)) {
+          if (term->isFunctionExiting()) {
+            require(stack.empty(),
+                    "return with stack allocs that haven't been deallocated");
+          }
           for (auto &successor : term->getSuccessors()) {
             SILBasicBlock *SuccBB = successor.getBB();
             auto found = visitedBBs.find(SuccBB);

lib/SILOptimizer/IPO/EagerSpecializer.cpp

@@ -44,7 +44,7 @@ llvm::cl::opt<bool> EagerSpecializeFlag(
 /// for new return or error values.
 static bool isTrivialReturnBlock(SILBasicBlock *RetBB) {
   auto *RetInst = RetBB->getTerminator();
-  assert(isa<ReturnInst>(RetInst) || isa<ThrowInst>(RetInst) &&
+  assert(RetInst->isFunctionExiting() &&
          "expected a properly terminated return or throw block");
 
   auto RetOperand = RetInst->getOperand(0);
@@ -87,7 +87,7 @@ static void addReturnValueImpl(SILBasicBlock *RetBB, SILBasicBlock *NewRetBB,
   SILLocation Loc = F->getLocation();
 
   auto *RetInst = RetBB->getTerminator();
-  assert(isa<ReturnInst>(RetInst) || isa<ThrowInst>(RetInst) &&
+  assert(RetInst->isFunctionExiting() &&
          "expected a properly terminated return or throw block");
   assert(RetInst->getOperand(0)->getType() == NewRetVal->getType() &&
          "Mismatched return type");

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -1874,7 +1874,7 @@ SILValue LifetimeChecker::handleConditionalInitAssign() {
   // before the return.
   for (auto &BB : TheMemory.getFunction()) {
     auto *Term = BB.getTerminator();
-    if (isa<ReturnInst>(Term) || isa<ThrowInst>(Term)) {
+    if (Term->isFunctionExiting()) {
       B.setInsertionPoint(Term);
       B.createDeallocStack(Loc, ControlVariableBox);
     }

lib/SILOptimizer/Mandatory/InOutDeshadowing.cpp

@@ -94,7 +94,7 @@ class StackSlotState {
     // We need to see a store back to the inout on every exit path.
     for (auto &bb : *F) {
       auto term = bb.getTerminator();
-      if (isa<ReturnInst>(term) || isa<ThrowInst>(term)) {
+      if (term->isFunctionExiting()) {
         DEBUG(llvm::dbgs() << "     need load from stack slot on exit " << &bb
                            << '\n');
         ExitBBs.insert(&bb);
@@ -224,7 +224,7 @@ static void analyzeUseOfInOut(Operand *UI, StackSlotState &state) {
     if (isa<UnreachableInst>(term))
       return;
 
-    if (!isa<ReturnInst>(term) && !isa<ThrowInst>(term))
+    if (!term->isFunctionExiting())
       // Any copy from the inout outside of an exit block fails the analysis.
       // We don't need full flow-sensitive analysis for SILGen-ed code.
       return state.setFailed("inout is stored outside of an exit block");

lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp

@@ -219,10 +219,10 @@ bool PartialApplyCombiner::allocateTemporaries() {
 
 /// Emit dealloc_stack for all temporaries.
 void PartialApplyCombiner::deallocateTemporaries() {
-  // Insert dealloc_stack instructions.
+  // Insert dealloc_stack instructions at all function exit points.
   for (SILBasicBlock &BB : *PAI->getFunction()) {
     TermInst *Term = BB.getTerminator();
-    if (!isa<ReturnInst>(Term) && !isa<ThrowInst>(Term))
+    if (!Term->isFunctionExiting())
       continue;
 
     for (auto Op : Tmps) {

lib/SILOptimizer/Transforms/AllocBoxToStack.cpp

@@ -837,7 +837,7 @@ class AllocBoxToStack : public SILFunctionTransform {
 
     for (auto &BB : *getFunction()) {
       auto *Term = BB.getTerminator();
-      if (isa<ReturnInst>(Term) || isa<ThrowInst>(Term))
+      if (Term->isFunctionExiting())
         Returns.push_back(Term);
 
       for (auto &I : BB)