Merge pull request #66905 from nate-chandler/cherrypick/release/5.9/rdar111221183

5.9: [MoveOnlyAddressChecker] Fixed two use-before-def handlings.

Author: nate-chandler

include/swift/SIL/FieldSensitivePrunedLiveness.h

@@ -571,19 +571,22 @@ class FieldSensitivePrunedLiveBlocks {
   }
 
   /// Update this liveness result for a single use.
-  IsLive updateForUse(SILInstruction *user, unsigned bitNo) {
+  IsLive updateForUse(SILInstruction *user, unsigned bitNo,
+                      bool isUserBeforeDef) {
     assert(isInitialized());
     auto *block = user->getParent();
-    auto liveness = getBlockLiveness(block, bitNo);
-    if (liveness != Dead)
-      return liveness;
+    if (!isUserBeforeDef) {
+      auto liveness = getBlockLiveness(block, bitNo);
+      if (liveness != Dead)
+        return liveness;
+    }
     computeScalarUseBlockLiveness(block, bitNo);
     return getBlockLiveness(block, bitNo);
   }
 
   /// Update this range of liveness results for a single use.
   void updateForUse(SILInstruction *user, unsigned startBitNo,
-                    unsigned endBitNo,
+                    unsigned endBitNo, SmallBitVector const &useBeforeDefBits,
                     SmallVectorImpl<IsLive> &resultingLiveness);
 
   IsLive getBlockLiveness(SILBasicBlock *bb, unsigned bitNo) const {
@@ -854,10 +857,12 @@ class FieldSensitivePrunedLiveness {
   /// Also for flexibility, \p affectedAddress must be a derived projection from
   /// the base that \p user is affecting.
   void updateForUse(SILInstruction *user, TypeTreeLeafTypeRange span,
-                    bool lifetimeEnding);
+                    bool lifetimeEnding,
+                    SmallBitVector const &useBeforeDefBits);
 
   void updateForUse(SILInstruction *user, SmallBitVector const &bits,
-                    bool lifetimeEnding);
+                    bool lifetimeEnding,
+                    SmallBitVector const &useBeforeDefBits);
 
   void getBlockLiveness(SILBasicBlock *bb, TypeTreeLeafTypeRange span,
                         SmallVectorImpl<FieldSensitivePrunedLiveBlocks::IsLive>
@@ -1160,6 +1165,12 @@ class FieldSensitiveSSAPrunedLiveRange
     return def.first->getParentBlock() == block && def.second->contains(bit);
   }
 
+  template <typename Iterable>
+  void isUserBeforeDef(SILInstruction *user, Iterable const &iterable,
+                       SmallBitVector &useBeforeDefBits) const {
+    assert(useBeforeDefBits.none());
+  }
+
   void
   findBoundariesInBlock(SILBasicBlock *block, unsigned bitNo, bool isLiveOut,
                         FieldSensitivePrunedLivenessBoundary &boundary) const;
@@ -1243,6 +1254,36 @@ class FieldSensitiveMultiDefPrunedLiveRange
     });
   }
 
+  bool isDefBlock(SILBasicBlock *block, SmallBitVector const &bits) const {
+    assert(isInitialized());
+    auto iter = defBlocks.find(block);
+    if (!iter)
+      return false;
+    return llvm::any_of(*iter, [&](TypeTreeLeafTypeRange storedSpan) {
+      return storedSpan.intersects(bits);
+    });
+  }
+
+  /// Return true if \p user occurs before the first def in the same basic
+  /// block. In classical liveness dataflow terms, gen/kill conditions over all
+  /// users in 'bb' are:
+  ///
+  ///   Gen(bb)  |= !isDefBlock(bb) || isUserBeforeDef(bb)
+  ///   Kill(bb) &= isDefBlock(bb) && !isUserBeforeDef(bb)
+  ///
+  /// If 'bb' has no users, it is neither a Gen nor Kill. Otherwise, Gen and
+  /// Kill are complements.
+  bool isUserBeforeDef(SILInstruction *user, unsigned element) const;
+  template <typename Iterable>
+  void isUserBeforeDef(SILInstruction *user, Iterable const &iterable,
+                       SmallBitVector &useBeforeDefBits) const {
+    for (auto bit : iterable) {
+      if (isUserBeforeDef(user, bit)) {
+        useBeforeDefBits.set(bit);
+      }
+    }
+  }
+
   bool isDef(SILInstruction *inst, unsigned bit) const {
     assert(isInitialized());
     auto iter = defs.find(cast<SILNode>(inst));

include/swift/SIL/SILBasicBlock.h

@@ -509,6 +509,17 @@ public SwiftObjectHeader {
 
   void printAsOperand(raw_ostream &OS, bool PrintType = true);
 
+#ifndef NDEBUG
+  /// Print the ID of the block, bbN.
+  void dumpID() const;
+
+  /// Print the ID of the block with \p OS, bbN.
+  void printID(llvm::raw_ostream &OS) const;
+
+  /// Print the ID of the block with \p Ctx, bbN.
+  void printID(SILPrintContext &Ctx) const;
+#endif
+
   /// getSublistAccess() - returns pointer to member of instruction list
   static InstListType SILBasicBlock::*getSublistAccess() {
     return &SILBasicBlock::InstList;

lib/SIL/IR/SILPrinter.cpp

@@ -832,6 +832,12 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     *this << ')';
   }
 
+#ifndef NDEBUG
+  void printID(const SILBasicBlock *BB) {
+    *this << Ctx.getID(BB) << "\n";
+  }
+#endif
+
   void print(const SILBasicBlock *BB) {
     // Output uses for BB arguments. These are put into place as comments before
     // the block header.
@@ -3070,6 +3076,21 @@ void SILBasicBlock::print(SILPrintContext &Ctx) const {
   SILPrinter(Ctx).print(this);
 }
 
+#ifndef NDEBUG
+void SILBasicBlock::dumpID() const {
+  printID(llvm::errs());
+}
+
+void SILBasicBlock::printID(llvm::raw_ostream &OS) const {
+  SILPrintContext Ctx(OS);
+  printID(Ctx);
+}
+
+void SILBasicBlock::printID(SILPrintContext &Ctx) const {
+  SILPrinter(Ctx).printID(this);
+}
+#endif
+
 /// Pretty-print the SILFunction to errs.
 void SILFunction::dump(bool Verbose) const {
   SILPrintContext Ctx(llvm::errs(), Verbose);

lib/SIL/Utils/FieldSensitivePrunedLiveness.cpp

@@ -523,6 +523,7 @@ void FieldSensitivePrunedLiveBlocks::computeScalarUseBlockLiveness(
 /// Terminators are not live out of the block.
 void FieldSensitivePrunedLiveBlocks::updateForUse(
     SILInstruction *user, unsigned startBitNo, unsigned endBitNo,
+    SmallBitVector const &useBeforeDefBits,
     SmallVectorImpl<IsLive> &resultingLivenessInfo) {
   assert(isInitialized());
   resultingLivenessInfo.clear();
@@ -535,10 +536,15 @@ void FieldSensitivePrunedLiveBlocks::updateForUse(
 
   for (unsigned index : indices(resultingLivenessInfo)) {
     unsigned specificBitNo = startBitNo + index;
+    auto isUseBeforeDef = useBeforeDefBits.test(specificBitNo);
     switch (resultingLivenessInfo[index]) {
     case LiveOut:
     case LiveWithin:
-      continue;
+      if (!isUseBeforeDef) {
+        continue;
+      } else {
+        LLVM_FALLTHROUGH;
+      }
     case Dead: {
       // This use block has not yet been marked live. Mark it and its
       // predecessor blocks live.
@@ -617,21 +623,21 @@ void FieldSensitivePrunedLivenessBoundary::dump() const {
 //                        MARK: FieldSensitiveLiveness
 //===----------------------------------------------------------------------===//
 
-void FieldSensitivePrunedLiveness::updateForUse(SILInstruction *user,
-                                                TypeTreeLeafTypeRange range,
-                                                bool lifetimeEnding) {
+void FieldSensitivePrunedLiveness::updateForUse(
+    SILInstruction *user, TypeTreeLeafTypeRange range, bool lifetimeEnding,
+    SmallBitVector const &useBeforeDefBits) {
   SmallVector<FieldSensitivePrunedLiveBlocks::IsLive, 8> resultingLiveness;
   liveBlocks.updateForUse(user, range.startEltOffset, range.endEltOffset,
-                          resultingLiveness);
+                          useBeforeDefBits, resultingLiveness);
 
   addInterestingUser(user, range, lifetimeEnding);
 }
 
-void FieldSensitivePrunedLiveness::updateForUse(SILInstruction *user,
-                                                SmallBitVector const &bits,
-                                                bool lifetimeEnding) {
+void FieldSensitivePrunedLiveness::updateForUse(
+    SILInstruction *user, SmallBitVector const &bits, bool lifetimeEnding,
+    SmallBitVector const &useBeforeDefBits) {
   for (auto bit : bits.set_bits()) {
-    liveBlocks.updateForUse(user, bit);
+    liveBlocks.updateForUse(user, bit, useBeforeDefBits.test(bit));
   }
 
   addInterestingUser(user, bits, lifetimeEnding);
@@ -816,74 +822,46 @@ void FieldSensitivePrunedLiveRange<LivenessWithDefs>::computeBoundary(
   }
 }
 
+bool FieldSensitiveMultiDefPrunedLiveRange::isUserBeforeDef(
+    SILInstruction *user, unsigned element) const {
+  auto *block = user->getParent();
+  if (!isDefBlock(block, element))
+    return false;
+
+  if (llvm::any_of(block->getArguments(), [this, element](SILArgument *arg) {
+        return isDef(arg, element);
+      })) {
+    return false;
+  }
+
+  auto *current = user;
+  while (true) {
+    // If user is also a def, then the use is considered before the def.
+    current = current->getPreviousInstruction();
+    if (!current)
+      return true;
+
+    if (isDef(current, element))
+      return false;
+  }
+}
+
 template <typename LivenessWithDefs>
 void FieldSensitivePrunedLiveRange<LivenessWithDefs>::updateForUse(
     SILInstruction *user, TypeTreeLeafTypeRange range, bool lifetimeEnding) {
-  PRUNED_LIVENESS_LOG(
-      llvm::dbgs()
-      << "Begin FieldSensitivePrunedLiveRange<LivenessWithDefs>::updateForUse "
-         "for: "
-      << *user);
-  PRUNED_LIVENESS_LOG(
-      llvm::dbgs() << "Looking for def instruction earlier in the block!\n");
-
-  auto *parentBlock = user->getParent();
-  for (auto ii = std::next(user->getReverseIterator()),
-            ie = parentBlock->rend();
-       ii != ie; ++ii) {
-    // If we find the def, just mark this instruction as being an interesting
-    // instruction.
-    if (asImpl().isDef(&*ii, range)) {
-      PRUNED_LIVENESS_LOG(llvm::dbgs() << "    Found def: " << *ii);
-      PRUNED_LIVENESS_LOG(llvm::dbgs()
-                 << "    Marking inst as interesting user and returning!\n");
-      addInterestingUser(user, range, lifetimeEnding);
-      return;
-    }
-  }
-
-  // Otherwise, just delegate to our parent class's update for use. This will
-  // update liveness for our predecessor blocks and add this instruction as an
-  // interesting user.
-  PRUNED_LIVENESS_LOG(llvm::dbgs() << "No defs found! Delegating to "
-                             "FieldSensitivePrunedLiveness::updateForUse.\n");
-  FieldSensitivePrunedLiveness::updateForUse(user, range, lifetimeEnding);
+  SmallBitVector useBeforeDefBits(getNumSubElements());
+  asImpl().isUserBeforeDef(user, range.getRange(), useBeforeDefBits);
+  FieldSensitivePrunedLiveness::updateForUse(user, range, lifetimeEnding,
+                                             useBeforeDefBits);
 }
 
 template <typename LivenessWithDefs>
 void FieldSensitivePrunedLiveRange<LivenessWithDefs>::updateForUse(
     SILInstruction *user, SmallBitVector const &bits, bool lifetimeEnding) {
-  PRUNED_LIVENESS_LOG(
-      llvm::dbgs()
-      << "Begin FieldSensitivePrunedLiveRange<LivenessWithDefs>::updateForUse "
-         "for: "
-      << *user);
-  PRUNED_LIVENESS_LOG(llvm::dbgs()
-                      << "Looking for def instruction earlier in the block!\n");
-
-  auto *parentBlock = user->getParent();
-  for (auto ii = std::next(user->getReverseIterator()),
-            ie = parentBlock->rend();
-       ii != ie; ++ii) {
-    // If we find the def, just mark this instruction as being an interesting
-    // instruction.
-    if (asImpl().isDef(&*ii, bits)) {
-      PRUNED_LIVENESS_LOG(llvm::dbgs() << "    Found def: " << *ii);
-      PRUNED_LIVENESS_LOG(
-          llvm::dbgs()
-          << "    Marking inst as interesting user and returning!\n");
-      addInterestingUser(user, bits, lifetimeEnding);
-      return;
-    }
-  }
-
-  // Otherwise, just delegate to our parent class's update for use. This will
-  // update liveness for our predecessor blocks and add this instruction as an
-  // interesting user.
-  PRUNED_LIVENESS_LOG(llvm::dbgs()
-                      << "No defs found! Delegating to "
-                         "FieldSensitivePrunedLiveness::updateForUse.\n");
-  FieldSensitivePrunedLiveness::updateForUse(user, bits, lifetimeEnding);
+  SmallBitVector useBeforeDefBits(getNumSubElements());
+  asImpl().isUserBeforeDef(user, bits.set_bits(), useBeforeDefBits);
+  FieldSensitivePrunedLiveness::updateForUse(user, bits, lifetimeEnding,
+                                             useBeforeDefBits);
 }
 
 //===----------------------------------------------------------------------===//

lib/SILOptimizer/Mandatory/MoveOnlyAddressCheckerUtils.cpp

@@ -1075,11 +1075,11 @@ void UseState::initializeLiveness(
   // Now at this point, we have defined all of our defs so we can start adding
   // uses to the liveness.
   for (auto reinitInstAndValue : reinitInsts) {
+    recordConsumingBlock(reinitInstAndValue.first->getParent(),
+                         reinitInstAndValue.second);
     if (!isReinitToInitConvertibleInst(reinitInstAndValue.first)) {
       liveness.updateForUse(reinitInstAndValue.first, reinitInstAndValue.second,
                             false /*lifetime ending*/);
-      recordConsumingBlock(reinitInstAndValue.first->getParent(),
-                           reinitInstAndValue.second);
       LLVM_DEBUG(llvm::dbgs() << "Added liveness for reinit: "
                               << *reinitInstAndValue.first;
                  liveness.print(llvm::dbgs()));
@@ -1419,6 +1419,8 @@ class ExtendUnconsumedLiveness {
 
 private:
   bool hasDefAfter(SILInstruction *inst, unsigned element);
+  bool isLiveAtBegin(SILBasicBlock *block, unsigned element, bool isLiveAtEnd,
+                     DestroysCollection const &destroys);
 
   bool
   shouldAddDestroyToLiveness(SILInstruction *destroy, unsigned element,
@@ -2979,7 +2981,14 @@ void ExtendUnconsumedLiveness::runOnField(
     // as the other consuming uses).
     BasicBlockWorklist worklist(currentDef->getFunction());
     for (auto *consumingBlock : consumingBlocks) {
-      worklist.push(consumingBlock);
+      if (!originalLiveBlocks.insert(consumingBlock)
+          // Don't walk into the predecessors of blocks which kill liveness.
+          && !isLiveAtBegin(consumingBlock, element, /*isLiveAtEnd=*/true, destroys)) {
+        continue;
+      }
+      for (auto *predecessor : consumingBlock->getPredecessorBlocks()) {
+        worklist.pushIfNotVisited(predecessor);
+      }
     }
 
     // Walk backwards from consuming blocks.
@@ -2988,10 +2997,6 @@ void ExtendUnconsumedLiveness::runOnField(
         continue;
       }
       for (auto *predecessor : block->getPredecessorBlocks()) {
-        // If the block was discovered by liveness, we already added it to the
-        // set.
-        if (originalLiveBlocks.contains(predecessor))
-          continue;
         worklist.pushIfNotVisited(predecessor);
       }
     }
@@ -3108,6 +3113,37 @@ bool ExtendUnconsumedLiveness::shouldAddDestroyToLiveness(
   return !consumedAtEntryBlocks.contains(block);
 }
 
+/// Compute the block's effect on liveness and apply it to \p isLiveAtEnd.
+bool ExtendUnconsumedLiveness::isLiveAtBegin(SILBasicBlock *block,
+                                             unsigned element, bool isLiveAtEnd,
+                                             DestroysCollection const &destroys) {
+  enum class Effect {
+    None, // 0
+    Kill, // 1
+    Gen,  // 2
+  };
+  auto effect = Effect::None;
+  for (auto &instruction : llvm::reverse(*block)) {
+    // An instruction can be both a destroy and a def.  If it is, its
+    // behavior is first to destroy and then to init.  So when walking
+    // backwards, its last action is to destroy, so its effect is that of any
+    // destroy.
+    if (destroys.find(&instruction) != destroys.end()) {
+      effect = Effect::Gen;
+    } else if (liveness.isDef(&instruction, element)) {
+      effect = Effect::Kill;
+    }
+  }
+  switch (effect) {
+  case Effect::None:
+    return isLiveAtEnd;
+  case Effect::Kill:
+    return false;
+  case Effect::Gen:
+    return true;
+  }
+}
+
 bool ExtendUnconsumedLiveness::hasDefAfter(SILInstruction *start,
                                            unsigned element) {
   // NOTE: Start iteration at \p start, not its sequel, because