Add pointer escape and dependent use tracking to InteriorLiveness

Rig TransitiveAddressWalker to keep track of enough information for passes to
correctly check for pointer escapes and dependence uses. Requires for precise
bail-outs and asserts.

Author: atrick

include/swift/SIL/AddressUseKind.h

@@ -15,7 +15,7 @@
 
 namespace swift {
 
-enum class AddressUseKind { NonEscaping, PointerEscape, Unknown };
+enum class AddressUseKind { NonEscaping, Dependent, PointerEscape, Unknown };
 
 inline AddressUseKind meet(AddressUseKind lhs, AddressUseKind rhs) {
   return (lhs > rhs) ? lhs : rhs;

include/swift/SIL/AddressWalker.h

@@ -48,6 +48,7 @@ class TransitiveAddressWalker {
   /// Whether we could tell if this address use didn't escape, did have a
   /// pointer escape, or unknown if we failed to understand something.
   AddressUseKind result = AddressUseKind::NonEscaping;
+  Operand *escapingUse = nullptr;
 
   unsigned didInvalidate = false;
 
@@ -83,6 +84,11 @@ class TransitiveAddressWalker {
     result = swift::meet(result, other);
   }
 
+  void recordEscape(Operand *op, AddressUseKind kind = AddressUseKind::PointerEscape) {
+    meet(kind);
+    escapingUse = op;
+  }
+
 private:
   /// Shim that actually calls visitUse and changes early exit.
   void callVisitUse(Operand *use) {
@@ -92,12 +98,16 @@ class TransitiveAddressWalker {
   }
 
 public:
-  AddressUseKind walk(SILValue address) &&;
+  AddressUseKind walk(SILValue address);
+
+  // If the result of walk() is not NonEscaping, this returns a non-null
+  // operand that caused the escape or unknown use.
+  Operand *getEscapingUse() const { return escapingUse; }
 };
 
 template <typename Impl>
 inline AddressUseKind
-TransitiveAddressWalker<Impl>::walk(SILValue projectedAddress) && {
+TransitiveAddressWalker<Impl>::walk(SILValue projectedAddress) {
   assert(!didInvalidate);
 
   // When we exit, set the result to be invalidated so we can't use this again.
@@ -155,7 +165,7 @@ TransitiveAddressWalker<Impl>::walk(SILValue projectedAddress) && {
       case TermKind::CondBranchInst:
         // We could have an address phi. To be conservative, just treat this as
         // a point escape.
-        meet(AddressUseKind::PointerEscape);
+        recordEscape(op);
         for (auto succBlockArgList : ti->getSuccessorBlockArgumentLists()) {
           auto *succ = succBlockArgList[op->getOperandNumber()];
           for (auto *use : succ->getUses())
@@ -185,10 +195,13 @@ TransitiveAddressWalker<Impl>::walk(SILValue projectedAddress) && {
       }
     }
 
-    // TODO: Partial apply should be NonEscaping, but then we need to consider
-    // the apply to be a use point.
-    if (isa<PartialApplyInst>(user) || isa<AddressToPointerInst>(user)) {
-      meet(AddressUseKind::PointerEscape);
+    if (isa<PartialApplyInst>(user)) {
+      recordEscape(op, AddressUseKind::Dependent);
+      callVisitUse(op);
+      continue;
+    }
+    if (isa<AddressToPointerInst>(user)) {
+      recordEscape(op);
       callVisitUse(op);
       continue;
     }
@@ -297,7 +310,7 @@ TransitiveAddressWalker<Impl>::walk(SILValue projectedAddress) && {
       // address. See AddressUtils.swift. Until that is implemented, this must
       // be considered a pointer escape.
       if (op->get() == mdi->getBase()) {
-        meet(AddressUseKind::PointerEscape);
+        recordEscape(op, AddressUseKind::Dependent);
         callVisitUse(op);
         continue;
       }

include/swift/SIL/OwnershipLiveness.h

@@ -241,6 +241,7 @@ class InteriorLiveness : public OSSALiveness {
 public:
   // Summarize address uses
   AddressUseKind addressUseKind = AddressUseKind::Unknown;
+  Operand *escapingUse = nullptr;
 
 public:
   InteriorLiveness(SILValue def): OSSALiveness(def) {}

include/swift/SIL/OwnershipUseVisitor.h

@@ -494,7 +494,7 @@ bool OwnershipUseVisitor<Impl>::visitInteriorPointerUses(Operand *use) {
   // just assumes that all scopes are incomplete.
   SmallVector<Operand *, 8> interiorUses;
   auto useKind = InteriorPointerOperand(use).findTransitiveUses(&interiorUses);
-  if (useKind == AddressUseKind::PointerEscape) {
+  if (useKind != AddressUseKind::NonEscaping) {
     if (!asImpl().handlePointerEscape(use))
       return false;
   }

lib/SIL/Utils/OwnershipLiveness.cpp

@@ -150,6 +150,7 @@ struct InteriorLivenessVisitor :
 
   bool handlePointerEscape(Operand *use) {
     interiorLiveness.addressUseKind = AddressUseKind::PointerEscape;
+    interiorLiveness.escapingUse = use;
     if (!handleUsePoint(use, UseLifetimeConstraint::NonLifetimeEnding))
       return false;
 
@@ -198,6 +199,9 @@ void InteriorLiveness::print(llvm::raw_ostream &OS) const {
   case AddressUseKind::PointerEscape:
     OS << "Incomplete liveness: Escaping address\n";
     break;
+  case AddressUseKind::Dependent:
+    OS << "Incomplete liveness: Dependent value\n";
+    break;
   case AddressUseKind::Unknown:
     OS << "Incomplete liveness: Unknown address use\n";
     break;