Merge pull request #65143 from apple/revert-65022-rdar99160718

Revert "[Mem2Reg] Omit lexical moves for lexical values."

Author: swift-ci

lib/SILOptimizer/Transforms/SILMem2Reg.cpp

@@ -57,7 +57,6 @@ STATISTIC(NumInstRemoved,        "Number of Instructions removed");
 
 static bool lexicalLifetimeEnsured(AllocStackInst *asi);
 static bool isGuaranteedLexicalValue(SILValue src);
-static bool isOwnedLexicalValue(SILValue src);
 
 namespace {
 
@@ -97,11 +96,9 @@ class LiveValues {
       if (!lexicalLifetimeEnsured(asi)) {
         return stored;
       }
-      auto storedIsLexical = stored && isOwnedLexicalValue(stored);
-      // If the value was already lexical, we use it directly.  Otherwise, a new
-      // move_value [lexical] is used.
-      assert(storedIsLexical || move);
-      return storedIsLexical ? stored : move;
+      // We should have created a move of the @owned stored value.
+      assert(move);
+      return move;
     }
 
     bool canEndLexicalLifetime() {
@@ -110,8 +107,7 @@ class LiveValues {
       // to end a lexical lifetime. In that case, the lifetime end will be
       // added later, when we have enough information, namely the live in
       // values, to end it.
-      auto storedIsLexical = stored && isOwnedLexicalValue(stored);
-      return storedIsLexical ? stored : move;
+      return move;
     }
   };
   struct Guaranteed {
@@ -225,7 +221,6 @@ class LiveValues {
     return guaranteed.stored;
   }
 
-  /// Whether it's possible and appropriate to end the lifetime.
   bool canEndLexicalLifetime() {
     if (auto *owned = storage.dyn_cast<Owned>()) {
       return owned->canEndLexicalLifetime();
@@ -526,15 +521,16 @@ static bool lexicalLifetimeEnsured(AllocStackInst *asi) {
          !asi->getElementType().isTrivial(*asi->getFunction());
 }
 
-static bool isOwnedLexicalValue(SILValue src) {
-  return src->getOwnershipKind() == OwnershipKind::Owned && src->isLexical();
-}
-
 static bool isGuaranteedLexicalValue(SILValue src) {
   return src->getOwnershipKind() == OwnershipKind::Guaranteed &&
          src->isLexical();
 }
 
+/// Returns true if we have enough information to end the lifetime.
+static bool canEndLexicalLifetime(LiveValues values) {
+  return values.canEndLexicalLifetime();
+}
+
 /// Begin a lexical borrow scope for the value stored into the provided
 /// StoreInst after that instruction.
 ///
@@ -550,9 +546,6 @@ beginOwnedLexicalLifetimeAfterStore(AllocStackInst *asi, StoreInst *inst) {
   SILValue stored = inst->getOperand(CopyLikeInstruction::Src);
   SILLocation loc = RegularLocation::getAutoGeneratedLocation(inst->getLoc());
 
-  if (isOwnedLexicalValue(stored)) {
-    return {LiveValues::forOwned(stored, {}), /*isStorageValid*/ true};
-  }
   MoveValueInst *mvi = nullptr;
   SILBuilderWithScope::insertAfter(inst, [&](SILBuilder &builder) {
     mvi = builder.createMoveValue(loc, stored, /*isLexical*/ true);
@@ -832,7 +825,7 @@ SILInstruction *StackAllocationPromoter::promoteAllocationInBlock(
         if (lexicalLifetimeEnsured(asi)) {
           // End the lexical lifetime at a load [take].  The storage is no
           // longer keeping the value alive.
-          if (runningVals && runningVals->value.canEndLexicalLifetime()) {
+          if (runningVals && canEndLexicalLifetime(runningVals->value)) {
             // End it right now if we have enough information.
             endOwnedLexicalLifetimeBeforeInst(asi, /*beforeInstruction=*/li,
                                               ctx,
@@ -915,7 +908,7 @@ SILInstruction *StackAllocationPromoter::promoteAllocationInBlock(
       lastStoreInst = si;
       if (lexicalLifetimeEnsured(asi)) {
         if (oldRunningVals && oldRunningVals->isStorageValid &&
-            oldRunningVals->value.canEndLexicalLifetime()) {
+            canEndLexicalLifetime(oldRunningVals->value)) {
           endOwnedLexicalLifetimeBeforeInst(asi, /*beforeInstruction=*/si, ctx,
                                             oldRunningVals->value.getOwned());
         }
@@ -972,7 +965,7 @@ SILInstruction *StackAllocationPromoter::promoteAllocationInBlock(
       }
       // Mark storage as invalid and mark end_borrow as a deinit point.
       runningVals->isStorageValid = false;
-      if (!runningVals->value.canEndLexicalLifetime()) {
+      if (!canEndLexicalLifetime(runningVals->value)) {
         continue;
       }
       endGuaranteedLexicalLifetimeBeforeInst(
@@ -1074,10 +1067,6 @@ StackAllocationPromoter::getLiveOutValues(BlockSetVector &phiBlocks,
         auto values = LiveValues::forGuaranteed(stored, borrow);
         return values;
       }
-      if (isOwnedLexicalValue(stored)) {
-        auto values = LiveValues::forOwned(stored, {});
-        return values;
-      }
       auto move = cast<MoveValueInst>(inst->getNextInstruction());
       auto values = LiveValues::forOwned(stored, move);
       return values;
@@ -1433,7 +1422,7 @@ void StackAllocationPromoter::endLexicalLifetime(BlockSetVector &phiBlocks) {
         if (isa<EndBorrowInst>(inst)) {
           // Not all store_borrows will have a begin_borrow [lexical] that needs
           // to be ended. If the source is already lexical, we don't create it.
-          if (!values->canEndLexicalLifetime()) {
+          if (!canEndLexicalLifetime(*values)) {
             continue;
           }
           endGuaranteedLexicalLifetimeBeforeInst(
@@ -1456,7 +1445,7 @@ void StackAllocationPromoter::endLexicalLifetime(BlockSetVector &phiBlocks) {
       if (terminatesInUnreachable || uniqueSuccessorLacksLiveInValues()) {
         auto values = getLiveOutValues(phiBlocks, bb);
         if (values->isGuaranteed()) {
-          if (!values->canEndLexicalLifetime()) {
+          if (!canEndLexicalLifetime(*values)) {
             continue;
           }
           endGuaranteedLexicalLifetimeBeforeInst(
@@ -1982,7 +1971,7 @@ void MemoryToRegisters::removeSingleBlockAllocation(AllocStackInst *asi) {
         continue;
       }
       runningVals->isStorageValid = false;
-      if (!runningVals->value.canEndLexicalLifetime()) {
+      if (!canEndLexicalLifetime(runningVals->value)) {
         continue;
       }
       endGuaranteedLexicalLifetimeBeforeInst(