[NFC] Changed function name.

Because lexical borrows are already avoided for store_borrows of lexical
values, the function is already misnamed: it's not that Mem2Reg should
necessarily _add_ a lexical lifetime, but rather that it should ensure
that there is one.  Considering that we should do the same for owned
lexical values, the renaming will remain appropriate later.  Finally,
name it so that it can switch from being a boolean to returning a
tristate (none, guaranteed, owned) when that becomes necessary (as it
will when we need to distinguish among the states to determine what phis
look like).

Author: nate-chandler

lib/SILOptimizer/Transforms/SILMem2Reg.cpp

@@ -54,7 +54,7 @@ STATISTIC(NumAllocStackFound,    "Number of AllocStack found");
 STATISTIC(NumAllocStackCaptured, "Number of AllocStack captured");
 STATISTIC(NumInstRemoved,        "Number of Instructions removed");
 
-static bool shouldAddLexicalLifetime(AllocStackInst *asi);
+static bool lexicalLifetimeEnsured(AllocStackInst *asi);
 static bool isGuaranteedLexicalValue(SILValue src);
 
 namespace {
@@ -83,15 +83,15 @@ struct LiveValues {
   /// usages will be replaced with usages of the stored field.  The
   /// implementation constructs an instance to match those requirements.
   static LiveValues toReplace(AllocStackInst *asi, SILValue replacement) {
-    if (shouldAddLexicalLifetime(asi))
+    if (lexicalLifetimeEnsured(asi))
       return {SILValue(), SILValue(), replacement};
     return {replacement, SILValue(), SILValue()};
   };
 
   /// The value with which usages of the provided AllocStackInst should be
   /// replaced.
   SILValue replacement(AllocStackInst *asi, SILInstruction *toReplace) {
-    if (!shouldAddLexicalLifetime(asi)) {
+    if (!lexicalLifetimeEnsured(asi)) {
       return stored;
     }
     // For lexical AllocStackInsts, which are store_borrow locations, we may
@@ -301,7 +301,7 @@ replaceLoad(SILInstruction *inst, SILValue newValue, AllocStackInst *asi,
   op = inst->getOperand(0);
 
   if (auto *lbi = dyn_cast<LoadBorrowInst>(inst)) {
-    if (shouldAddLexicalLifetime(asi)) {
+    if (lexicalLifetimeEnsured(asi)) {
       assert(newValue->getOwnershipKind() == OwnershipKind::Guaranteed);
       SmallVector<SILInstruction *, 4> endBorrows;
       for (auto *ebi : lbi->getUsersOfType<EndBorrowInst>()) {
@@ -311,8 +311,7 @@ replaceLoad(SILInstruction *inst, SILValue newValue, AllocStackInst *asi,
         prepareForDeletion(ebi, instructionsToDelete);
       }
       lbi->replaceAllUsesWith(newValue);
-    }
-    else {
+    } else {
       auto *borrow = SILBuilderWithScope(lbi, ctx).createBeginBorrow(
           lbi->getLoc(), newValue, asi->isLexical());
       lbi->replaceAllUsesWith(borrow);
@@ -367,7 +366,7 @@ static SILValue createValueForEmptyTuple(SILType ty,
 
 /// Whether lexical lifetimes should be added for the values stored into the
 /// alloc_stack.
-static bool shouldAddLexicalLifetime(AllocStackInst *asi) {
+static bool lexicalLifetimeEnsured(AllocStackInst *asi) {
   return asi->getFunction()->hasOwnership() &&
          asi->getFunction()
                  ->getModule()
@@ -412,7 +411,7 @@ static bool canEndLexicalLifetime(LiveValues values) { return values.borrow; }
 static StorageStateTracking<LiveValues>
 beginLexicalLifetimeAfterStore(AllocStackInst *asi, SILInstruction *inst) {
   assert(isa<StoreInst>(inst) || isa<StoreBorrowInst>(inst));
-  assert(shouldAddLexicalLifetime(asi));
+  assert(lexicalLifetimeEnsured(asi));
   SILValue stored = inst->getOperand(CopyLikeInstruction::Src);
   SILLocation loc = RegularLocation::getAutoGeneratedLocation(inst->getLoc());
 
@@ -452,7 +451,7 @@ static void endOwnedLexicalLifetimeBeforeInst(AllocStackInst *asi,
                                               SILInstruction *beforeInstruction,
                                               SILBuilderContext &ctx,
                                               LiveValues values) {
-  assert(shouldAddLexicalLifetime(asi));
+  assert(lexicalLifetimeEnsured(asi));
   assert(beforeInstruction);
 
   auto builder = SILBuilderWithScope(beforeInstruction, ctx);
@@ -467,7 +466,7 @@ static void endOwnedLexicalLifetimeBeforeInst(AllocStackInst *asi,
 static void endGuaranteedLexicalLifetimeBeforeInst(
     AllocStackInst *asi, SILInstruction *beforeInstruction,
     SILBuilderContext &ctx, LiveValues values) {
-  assert(shouldAddLexicalLifetime(asi));
+  assert(lexicalLifetimeEnsured(asi));
   assert(beforeInstruction);
   assert(values.borrow);
 
@@ -667,7 +666,7 @@ SILInstruction *StackAllocationPromoter::promoteAllocationInBlock(
       assert(!runningVals || runningVals->isStorageValid);
       auto *li = dyn_cast<LoadInst>(inst);
       if (li && li->getOwnershipQualifier() == LoadOwnershipQualifier::Take) {
-        if (shouldAddLexicalLifetime(asi)) {
+        if (lexicalLifetimeEnsured(asi)) {
           // End the lexical lifetime at a load [take].  The storage is no
           // longer keeping the value alive.
           if (runningVals && canEndLexicalLifetime(runningVals->value)) {
@@ -723,7 +722,7 @@ SILInstruction *StackAllocationPromoter::promoteAllocationInBlock(
           auto *newLoad = localBuilder.createLoad(si->getLoc(), asi,
                                                   LoadOwnershipQualifier::Take);
           localBuilder.createDestroyValue(si->getLoc(), newLoad);
-          if (shouldAddLexicalLifetime(asi)) {
+          if (lexicalLifetimeEnsured(asi)) {
             assert(!deinitializationPoints[blockPromotingWithin]);
             deinitializationPoints[blockPromotingWithin] = si;
           }
@@ -750,7 +749,7 @@ SILInstruction *StackAllocationPromoter::promoteAllocationInBlock(
       // The current store is now the lastStoreInst (until we see
       // another).
       lastStoreInst = inst;
-      if (shouldAddLexicalLifetime(asi)) {
+      if (lexicalLifetimeEnsured(asi)) {
         if (oldRunningVals && oldRunningVals->isStorageValid &&
             canEndLexicalLifetime(oldRunningVals->value)) {
           endOwnedLexicalLifetimeBeforeInst(asi, /*beforeInstruction=*/inst,
@@ -778,15 +777,15 @@ SILInstruction *StackAllocationPromoter::promoteAllocationInBlock(
                      /*isStorageValid=*/true};
       // The current store is now the lastStoreInst.
       lastStoreInst = inst;
-      if (shouldAddLexicalLifetime(asi)) {
+      if (lexicalLifetimeEnsured(asi)) {
         runningVals = beginLexicalLifetimeAfterStore(asi, inst);
       }
       continue;
     }
 
     // End the lexical lifetime of the store_borrow source.
     if (auto *ebi = dyn_cast<EndBorrowInst>(inst)) {
-      if (!shouldAddLexicalLifetime(asi)) {
+      if (!lexicalLifetimeEnsured(asi)) {
         continue;
       }
       auto *sbi = dyn_cast<StoreBorrowInst>(ebi->getOperand());
@@ -833,7 +832,7 @@ SILInstruction *StackAllocationPromoter::promoteAllocationInBlock(
       if (runningVals) {
         replaceDestroy(dai, runningVals->value.replacement(asi, dai), ctx,
                        deleter, instructionsToDelete);
-        if (shouldAddLexicalLifetime(asi)) {
+        if (lexicalLifetimeEnsured(asi)) {
           endOwnedLexicalLifetimeBeforeInst(asi, /*beforeInstruction=*/dai, ctx,
                                             runningVals->value);
         }
@@ -873,7 +872,7 @@ void StackAllocationPromoter::addBlockArguments(BlockSetVector &phiBlocks) {
   for (auto *block : phiBlocks) {
     // The stored value.
     block->createPhiArgument(asi->getElementType(), OwnershipKind::Owned);
-    if (shouldAddLexicalLifetime(asi)) {
+    if (lexicalLifetimeEnsured(asi)) {
       // The borrow scope.
       block->createPhiArgument(asi->getElementType(),
                                OwnershipKind::Guaranteed);
@@ -901,7 +900,7 @@ StackAllocationPromoter::getLiveOutValues(BlockSetVector &phiBlocks,
       SILValue stored = inst->getOperand(CopyLikeInstruction::Src);
       LLVM_DEBUG(llvm::dbgs() << "*** Found Store def " << stored);
 
-      if (!shouldAddLexicalLifetime(asi)) {
+      if (!lexicalLifetimeEnsured(asi)) {
         LiveValues values = {stored, SILValue(), SILValue()};
         return values;
       }
@@ -927,7 +926,7 @@ StackAllocationPromoter::getLiveOutValues(BlockSetVector &phiBlocks,
       SILValue original;
       SILValue borrow;
       SILValue copy;
-      if (shouldAddLexicalLifetime(asi)) {
+      if (lexicalLifetimeEnsured(asi)) {
         original = domBlock->getArgument(domBlock->getNumArguments() - 3);
         borrow = domBlock->getArgument(domBlock->getNumArguments() - 2);
         copy = domBlock->getArgument(domBlock->getNumArguments() - 1);
@@ -970,7 +969,7 @@ StackAllocationPromoter::getLiveInValues(BlockSetVector &phiBlocks,
     SILValue original;
     SILValue borrow;
     SILValue copy;
-    if (shouldAddLexicalLifetime(asi)) {
+    if (lexicalLifetimeEnsured(asi)) {
       original = block->getArgument(block->getNumArguments() - 3);
       borrow = block->getArgument(block->getNumArguments() - 2);
       copy = block->getArgument(block->getNumArguments() - 1);
@@ -1017,7 +1016,7 @@ void StackAllocationPromoter::fixPhiPredBlock(BlockSetVector &phiBlocks,
 
   SmallVector<SILValue> vals;
   vals.push_back(def.stored);
-  if (shouldAddLexicalLifetime(asi)) {
+  if (lexicalLifetimeEnsured(asi)) {
     vals.push_back(def.borrow);
     vals.push_back(def.copy);
   }
@@ -1185,7 +1184,7 @@ void StackAllocationPromoter::fixBranchesAndUses(BlockSetVector &phiBlocks,
           block->getArgument(block->getNumArguments() - 1));
       if (!livePhis.contains(proactivePhi)) {
         eraseLastPhiFromBlock(block);
-        if (shouldAddLexicalLifetime(asi)) {
+        if (lexicalLifetimeEnsured(asi)) {
           eraseLastPhiFromBlock(block);
           eraseLastPhiFromBlock(block);
         }
@@ -1231,7 +1230,7 @@ void StackAllocationPromoter::fixBranchesAndUses(BlockSetVector &phiBlocks,
 ///       This can only happen if the successor is a CFG merge and all paths
 ///       from here lead to unreachable.
 void StackAllocationPromoter::endLexicalLifetime(BlockSetVector &phiBlocks) {
-  if (!shouldAddLexicalLifetime(asi))
+  if (!lexicalLifetimeEnsured(asi))
     return;
 
   // We need to separately consider and visit incoming unopened borrow scopes
@@ -1350,9 +1349,9 @@ void StackAllocationPromoter::pruneAllocStackUsage() {
 
   for (auto block : functionBlocks)
     if (auto si = promoteAllocationInBlock(block)) {
-      // There was a final storee instruction which was not followed by an
-      // instruction that deinitializes the memory.  Record it as a cross-block
-      // initialization point.
+      // There was a final store/store_borrow instruction which was not
+      // followed by an instruction that deinitializes the memory.  Record it
+      // as a cross-block initialization point.
       initializationPoints[block] = si;
     }
 
@@ -1768,7 +1767,7 @@ void MemoryToRegisters::removeSingleBlockAllocation(AllocStackInst *asi) {
       auto *loadInst = dyn_cast<LoadInst>(inst);
       if (loadInst &&
           loadInst->getOwnershipQualifier() == LoadOwnershipQualifier::Take) {
-        if (shouldAddLexicalLifetime(asi)) {
+        if (lexicalLifetimeEnsured(asi)) {
           // End the lexical lifetime at a load [take].  The storage is no
           // longer keeping the value alive.
           endOwnedLexicalLifetimeBeforeInst(asi, /*beforeInstruction=*/inst,
@@ -1796,7 +1795,7 @@ void MemoryToRegisters::removeSingleBlockAllocation(AllocStackInst *asi) {
       auto oldRunningVals = runningVals;
       runningVals = {LiveValues::toReplace(asi, /*replacement=*/si->getSrc()),
                      /*isStorageValid=*/true};
-      if (shouldAddLexicalLifetime(asi)) {
+      if (lexicalLifetimeEnsured(asi)) {
         if (oldRunningVals && oldRunningVals->isStorageValid) {
           endOwnedLexicalLifetimeBeforeInst(asi, /*beforeInstruction=*/si, ctx,
                                             oldRunningVals->value);
@@ -1814,7 +1813,7 @@ void MemoryToRegisters::removeSingleBlockAllocation(AllocStackInst *asi) {
       }
       runningVals = {LiveValues::toReplace(asi, /*replacement=*/sbi->getSrc()),
                      /*isStorageValid=*/true};
-      if (shouldAddLexicalLifetime(asi)) {
+      if (lexicalLifetimeEnsured(asi)) {
         runningVals = beginLexicalLifetimeAfterStore(asi, inst);
       }
       continue;
@@ -1866,7 +1865,7 @@ void MemoryToRegisters::removeSingleBlockAllocation(AllocStackInst *asi) {
         assert(runningVals && runningVals->isStorageValid);
         replaceDestroy(dai, runningVals->value.replacement(asi, dai), ctx,
                        deleter, instructionsToDelete);
-        if (shouldAddLexicalLifetime(asi)) {
+        if (lexicalLifetimeEnsured(asi)) {
           endOwnedLexicalLifetimeBeforeInst(asi, /*beforeInstruction=*/dai, ctx,
                                             runningVals->value);
         }
@@ -1898,7 +1897,7 @@ void MemoryToRegisters::removeSingleBlockAllocation(AllocStackInst *asi) {
     }
   }
 
-  if (shouldAddLexicalLifetime(asi) && runningVals &&
+  if (lexicalLifetimeEnsured(asi) && runningVals &&
       runningVals->isStorageValid &&
       runningVals->value.stored->getOwnershipKind().isCompatibleWith(
           OwnershipKind::Owned)) {
@@ -1941,7 +1940,7 @@ bool MemoryToRegisters::promoteSingleAllocation(AllocStackInst *alloc) {
   }
 
   // Remove write-only AllocStacks.
-  if (isWriteOnlyAllocation(alloc) && !shouldAddLexicalLifetime(alloc)) {
+  if (isWriteOnlyAllocation(alloc) && !lexicalLifetimeEnsured(alloc)) {
     LLVM_DEBUG(llvm::dbgs() << "*** Deleting store-only AllocStack: "<< *alloc);
     deleter.forceDeleteWithUsers(alloc);
     return true;