[Mem2Reg] NFC: Split up lexical lifetime starts.

Split the beginning of lexical lifetimes up according to whether the
lifetimes (and alloc_stacks) are owned or guaranteed.

Author: nate-chandler

lib/SILOptimizer/Transforms/SILMem2Reg.cpp

@@ -517,25 +517,14 @@ static bool canEndLexicalLifetime(LiveValues values) {
 ///
 /// The beginning of the scope looks like
 ///
-///     %lifetime = begin_borrow %original
+///     %lifetime = begin_borrow [lexical] %original
 ///     %copy = copy_value %lifetime
-/// For a StoreBorrowInst, begin a lexical borrow scope only if the stored value
-/// is non-lexical.
 static StorageStateTracking<LiveValues>
-beginLexicalLifetimeAfterStore(AllocStackInst *asi, SILInstruction *inst) {
-  assert(isa<StoreInst>(inst) || isa<StoreBorrowInst>(inst));
+beginOwnedLexicalLifetimeAfterStore(AllocStackInst *asi, StoreInst *inst) {
   assert(lexicalLifetimeEnsured(asi));
   SILValue stored = inst->getOperand(CopyLikeInstruction::Src);
   SILLocation loc = RegularLocation::getAutoGeneratedLocation(inst->getLoc());
 
-  if (isa<StoreBorrowInst>(inst)) {
-    if (isGuaranteedLexicalValue(stored)) {
-      return {LiveValues::forGuaranteed(stored, {}), /*isStorageValid*/ true};
-    }
-    auto *borrow = SILBuilderWithScope(inst->getNextInstruction())
-                       .createBeginBorrow(loc, stored, /*isLexical*/ true);
-    return {LiveValues::forGuaranteed(stored, borrow), /*isStorageValid*/ true};
-  }
   BeginBorrowInst *bbi = nullptr;
   CopyValueInst *cvi = nullptr;
   SILBuilderWithScope::insertAfter(inst, [&](SILBuilder &builder) {
@@ -548,6 +537,24 @@ beginLexicalLifetimeAfterStore(AllocStackInst *asi, SILInstruction *inst) {
   return vals;
 }
 
+/// Begin a lexical borrow scope for the value stored via the provided
+/// StoreBorrowInst after that instruction.  Only do so if the stored value is
+/// non-lexical.
+static StorageStateTracking<LiveValues>
+beginGuaranteedLexicalLifetimeAfterStore(AllocStackInst *asi,
+                                         StoreBorrowInst *inst) {
+  assert(lexicalLifetimeEnsured(asi));
+  SILValue stored = inst->getOperand(CopyLikeInstruction::Src);
+  SILLocation loc = RegularLocation::getAutoGeneratedLocation(inst->getLoc());
+
+  if (isGuaranteedLexicalValue(stored)) {
+    return {LiveValues::forGuaranteed(stored, {}), /*isStorageValid*/ true};
+  }
+  auto *borrow = SILBuilderWithScope(inst->getNextInstruction())
+                     .createBeginBorrow(loc, stored, /*isLexical*/ true);
+  return {LiveValues::forGuaranteed(stored, borrow), /*isStorageValid*/ true};
+}
+
 /// End the lexical borrow scope for an @owned stored value described by the
 /// provided LiveValues struct before the specified instruction.
 ///
@@ -869,15 +876,14 @@ SILInstruction *StackAllocationPromoter::promoteAllocationInBlock(
                      /*isStorageValid=*/true};
       // The current store is now the lastStoreInst (until we see
       // another).
-      lastStoreInst = inst;
+      lastStoreInst = si;
       if (lexicalLifetimeEnsured(asi)) {
         if (oldRunningVals && oldRunningVals->isStorageValid &&
             canEndLexicalLifetime(oldRunningVals->value)) {
-          endOwnedLexicalLifetimeBeforeInst(asi, /*beforeInstruction=*/inst,
-                                            ctx,
+          endOwnedLexicalLifetimeBeforeInst(asi, /*beforeInstruction=*/si, ctx,
                                             oldRunningVals->value.getOwned());
         }
-        runningVals = beginLexicalLifetimeAfterStore(asi, inst);
+        runningVals = beginOwnedLexicalLifetimeAfterStore(asi, si);
       }
       continue;
     }
@@ -898,9 +904,9 @@ SILInstruction *StackAllocationPromoter::promoteAllocationInBlock(
       runningVals = {LiveValues::toReplace(asi, sbi->getSrc()),
                      /*isStorageValid=*/true};
       // The current store is now the lastStoreInst.
-      lastStoreInst = inst;
+      lastStoreInst = sbi;
       if (lexicalLifetimeEnsured(asi)) {
-        runningVals = beginLexicalLifetimeAfterStore(asi, inst);
+        runningVals = beginGuaranteedLexicalLifetimeAfterStore(asi, sbi);
       }
       continue;
     }
@@ -1930,9 +1936,9 @@ void MemoryToRegisters::removeSingleBlockAllocation(AllocStackInst *asi) {
           endOwnedLexicalLifetimeBeforeInst(asi, /*beforeInstruction=*/si, ctx,
                                             oldRunningVals->value.getOwned());
         }
-        runningVals = beginLexicalLifetimeAfterStore(asi, si);
+        runningVals = beginOwnedLexicalLifetimeAfterStore(asi, si);
       }
-      deleter.forceDelete(inst);
+      deleter.forceDelete(si);
       ++NumInstRemoved;
       continue;
     }
@@ -1944,7 +1950,7 @@ void MemoryToRegisters::removeSingleBlockAllocation(AllocStackInst *asi) {
       runningVals = {LiveValues::toReplace(asi, /*replacement=*/sbi->getSrc()),
                      /*isStorageValid=*/true};
       if (lexicalLifetimeEnsured(asi)) {
-        runningVals = beginLexicalLifetimeAfterStore(asi, inst);
+        runningVals = beginGuaranteedLexicalLifetimeAfterStore(asi, sbi);
       }
       continue;
     }