EscapeAnalysis: Make EscapeState and UsePoints a property of the content node only.

For alias analysis query to be generally correct, we need to
effectively merge the escape state and use points for everything in a
defer web.

It was unclear from the current design whether the "escaping" property
applied to the pointer value or its content. The implementation is
inconsistent in how it was treated. It appears that some bugs have
been worked around by propagating forward through defer edges, some
have been worked around by querying the content instead of the
pointer, and others have been worked around be creating fake use
points at block arguments.

If we always simply query the content for escape state and use points,
then we never need to propagate along defer edges. The current code
that propagates escape state along defer edges in one direction is
simply incorrect from the perspective of alias analysis.

One very attractive solution is to merge nodes eagerly without
creating any defer edges, but that would be a much more radical change
even than what I've done here. It would also pose some new issues: how
to resolve the current "node types" when merging and how to deal with
missing content nodes.

This solution of applying escape state to content nodes solves all
these problems without too radical of a change at the expense of
eagerly creating content nodes. (The potential graph memory usage is
not really an issue because it's possible to drastically shrink the
size of the graph anyway in a future commit--I've been able to fit a
node within one cache line). This solution nicely preserves graph
structure which makes it easy to debug and relate to the IR.

Eagerly creating content nodes also solves the missing content node
problem. For example, when querying canEscapeTo, we need to know
whether to look at the escape state for just the pointer value itself,
or also for its content. It may be possible the its content node is
actually part of the same object at the IR level. If the content node
is missing, then we don't know if the object's interior address is not
recognizable/representable or whether we simply never saw an access to
the interior address. We can't simply look at whether the current IR
value happens to be a reference, because that doesn't tell us whether
the graph node may have been merged with a non-reference node or even
with it's own content node. To be correct in general, this query would
need to be extremely conservative. However, if content nodes are
always created for references, then we only need to query the escape
state of a pointer's content node. The content node's flag tells us if
it's an interior node, in which case it will always point to another
content node which also needs to be queried.

Author: atrick

include/swift/SILOptimizer/Analysis/EscapeAnalysis.h

@@ -641,10 +641,10 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
     CGNode *ReturnNode = nullptr;
 
     /// The list of use points.
-    llvm::SmallVector<SILNode *, 16> UsePointTable;
+    llvm::SmallVector<SILInstruction *, 16> UsePointTable;
 
     /// Mapping of use points to bit indices in CGNode::UsePoints.
-    llvm::DenseMap<SILNode *, int> UsePoints;
+    llvm::DenseMap<SILInstruction *, int> UsePoints;
 
     /// The allocator for nodes.
     llvm::SpecificBumpPtrAllocator<CGNode> NodeAllocator;
@@ -798,19 +798,6 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
         Node->mappedValue = V;
     }
 
-    /// Adds an argument/instruction in which the node's value is used.
-    int addUsePoint(CGNode *Node, SILNode *User) {
-      if (Node->getEscapeState() >= EscapeState::Global)
-        return -1;
-
-      User = User->getRepresentativeSILNodeInObject();
-      int Idx = (int)UsePoints.size();
-      assert(UsePoints.count(User) == 0 && "value is already a use-point");
-      UsePoints[User] = Idx;
-      UsePointTable.push_back(User);
-      assert(UsePoints.size() == UsePointTable.size());
-      Node->setUsePointBit(Idx);
-      return Idx;
     /// If \p pointer is a pointer, set it's content to global escaping.
     ///
     /// Only mark the content node as escaping. Marking a pointer node as
@@ -828,13 +815,8 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
         content->markEscaping();
     }
 
-    void escapeContentsOf(CGNode *Node) {
-      CGNode *escapedContent = Node->getContentNodeOrNull();
-      if (!escapedContent) {
-        escapedContent = createContentNode(Node, /*hasRC=*/false);
-      }
-      escapedContent->markEscaping();
-    }
+    /// Adds an argument/instruction in which the node's value is used.
+    int addUsePoint(CGNode *Node, SILInstruction *User);
 
     /// Creates a defer-edge between \p From and \p To.
     /// This may trigger node merges to keep the graph invariance 4).
@@ -920,11 +902,11 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
     /// (indirectly) somehow refer to the Node's value.
     /// Use-points are only values which are relevant for lifeness computation,
     /// e.g. release or apply instructions.
-    bool isUsePoint(SILNode *UsePoint, CGNode *Node);
+    bool isUsePoint(SILInstruction *UsePoint, CGNode *Node);
 
     /// Returns all use points of \p Node in \p UsePoints.
     void getUsePoints(CGNode *Node,
-                      llvm::SmallVectorImpl<SILNode *> &UsePoints);
+                      llvm::SmallVectorImpl<SILInstruction *> &UsePoints);
 
     /// Computes the use point information.
     void computeUsePoints();
@@ -1108,10 +1090,11 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
   bool mergeSummaryGraph(ConnectionGraph *SummaryGraph,
                          ConnectionGraph *Graph);
 
-  /// Returns true if the value \p V can escape to the \p UsePoint, where
-  /// \p UsePoint is either a release-instruction or a function call.
-  bool canEscapeToUsePoint(SILValue V, SILNode *UsePoint,
-                           ConnectionGraph *ConGraph);
+  /// Returns true if the value \p value or any address within that value can
+  /// escape to the \p usePoint, where \p usePoint is either a
+  /// release-instruction or a function call.
+  bool canEscapeToUsePoint(SILValue value, SILInstruction *usePoint,
+                           ConnectionGraph *conGraph);
 
   friend struct ::CGForDotView;
 

lib/SILOptimizer/Analysis/AliasAnalysis.cpp

@@ -737,8 +737,8 @@ bool AliasAnalysis::mayValueReleaseInterfereWithInstruction(SILInstruction *User
   // The most important check: does the object escape the current function?
   auto LO = getUnderlyingObject(V);
   auto *ConGraph = EA->getConnectionGraph(User->getFunction());
-  auto *Node = ConGraph->getNodeOrNull(LO);
-  if (Node && !Node->escapes())
+  auto *Content = ConGraph->getValueContent(LO);
+  if (Content && !Content->escapes())
     return false;
 
   // This is either a non-local allocation or a scoped allocation that escapes.

lib/SILOptimizer/Analysis/EscapeAnalysis.cpp

@@ -804,10 +804,14 @@ void EscapeAnalysis::ConnectionGraph::propagateEscapeStates() {
     Changed = false;
 
     for (CGNode *Node : Nodes) {
-      // Propagate the state to all successor nodes.
+      // Propagate the state to all pointsTo nodes. It would be sufficient to
+      // only follow proper pointsTo edges, since this loop also follows defer
+      // edges, but this may converge faster.
       if (Node->pointsTo) {
         Changed |= Node->pointsTo->mergeEscapeState(Node->State);
       }
+      // Note: Propagating along defer edges may be interesting from an SSA
+      // standpoint, but it is entirely irrelevant alias analysis.
       for (CGNode *Def : Node->defersTo) {
         Changed |= Def->mergeEscapeState(Node->State);
       }
@@ -845,14 +849,13 @@ void EscapeAnalysis::ConnectionGraph::computeUsePoints() {
           /// liferange. And that must be a releasing instruction.
           int ValueIdx = -1;
           for (const Operand &Op : I.getAllOperands()) {
-            ValueBase *OpV = Op.get();
-            if (CGNode *OpNd = lookupNode(EA->getPointerRoot(OpV))) {
-              if (ValueIdx < 0) {
-                ValueIdx = addUsePoint(OpNd, &I);
-              } else {
-                OpNd->setUsePointBit(ValueIdx);
-              }
-            }
+            CGNode *content = getValueContent(Op.get());
+            if (!content)
+              continue;
+            if (ValueIdx < 0)
+              ValueIdx = addUsePoint(content, &I);
+            else
+              content->setUsePointBit(ValueIdx);
           }
           break;
         }
@@ -867,11 +870,10 @@ void EscapeAnalysis::ConnectionGraph::computeUsePoints() {
   do {
     Changed = false;
     for (CGNode *Node : Nodes) {
-      // Propagate the bits to all successor nodes.
-      Node->visitSuccessors([&Changed, Node](CGNode *succ) {
-        Changed |= succ->mergeUsePoints(Node);
-        return true;
-      });
+      // Propagate the bits to pointsTo. A release of a node may also release
+      // any content pointed to be the node.
+      if (Node->pointsTo)
+        Changed |= Node->pointsTo->mergeUsePoints(Node);
     }
   } while (Changed);
 }
@@ -1097,11 +1099,10 @@ bool EscapeAnalysis::ConnectionGraph::mergeFrom(ConnectionGraph *SourceGraph,
 /// somehow refer to the Node's value.
 /// Use-points are only values which are relevant for lifeness computation,
 /// e.g. release or apply instructions.
-bool EscapeAnalysis::ConnectionGraph::isUsePoint(SILNode *UsePoint,
+bool EscapeAnalysis::ConnectionGraph::isUsePoint(SILInstruction *UsePoint,
                                                  CGNode *Node) {
   assert(Node->getEscapeState() < EscapeState::Global &&
          "Use points are only valid for non-escaping nodes");
-  UsePoint = UsePoint->getRepresentativeSILNodeInObject();
   auto Iter = UsePoints.find(UsePoint);
   if (Iter == UsePoints.end())
     return false;
@@ -1111,8 +1112,8 @@ bool EscapeAnalysis::ConnectionGraph::isUsePoint(SILNode *UsePoint,
   return Node->UsePoints.test(Idx);
 }
 
-void EscapeAnalysis::ConnectionGraph::
-getUsePoints(CGNode *Node, llvm::SmallVectorImpl<SILNode *> &UsePoints) {
+void EscapeAnalysis::ConnectionGraph::getUsePoints(
+    CGNode *Node, llvm::SmallVectorImpl<SILInstruction *> &UsePoints) {
   assert(Node->getEscapeState() < EscapeState::Global &&
          "Use points are only valid for non-escaping nodes");
   for (int Idx = Node->UsePoints.find_first(); Idx >= 0;
@@ -2571,13 +2572,13 @@ bool EscapeAnalysis::canEscapeToValue(SILValue V, SILValue To) {
     return true;
   auto *ConGraph = getConnectionGraph(F);
 
-  CGNode *Node = ConGraph->getNodeOrNull(V);
-  if (!Node)
+  CGNode *valueContent = ConGraph->getValueContent(V);
+  if (!valueContent)
     return true;
-  CGNode *ToNode = ConGraph->getNodeOrNull(To);
-  if (!ToNode)
+  CGNode *userContent = ConGraph->getValueContent(To);
+  if (!userContent)
     return true;
-  return ConGraph->mayReach(ToNode, Node);
+  return ConGraph->mayReach(userContent, valueContent);
 }
 
 bool EscapeAnalysis::canPointToSameMemory(SILValue V1, SILValue V2) {
@@ -2592,27 +2593,26 @@ bool EscapeAnalysis::canPointToSameMemory(SILValue V1, SILValue V2) {
     return true;
   auto *ConGraph = getConnectionGraph(F);
 
-  CGNode *Node1 = ConGraph->getNodeOrNull(V1);
-  if (!Node1)
+  CGNode *Content1 = ConGraph->getValueContent(V1);
+  if (!Content1)
     return true;
-  CGNode *Node2 = ConGraph->getNodeOrNull(V2);
-  if (!Node2)
+
+  CGNode *Content2 = ConGraph->getValueContent(V2);
+  if (!Content2)
     return true;
 
   // Finish the check for one value being a non-escaping local object.
-  if (isUniq1 && Node1->valueEscapesInsideFunction(V1))
+  if (isUniq1 && Content1->valueEscapesInsideFunction(V1))
     isUniq1 = false;
 
-  if (isUniq2 && Node2->valueEscapesInsideFunction(V2))
+  if (isUniq2 && Content2->valueEscapesInsideFunction(V2))
     isUniq2 = false;
 
   if (!isUniq1 && !isUniq2)
     return true;
 
   // Check if both nodes may point to the same content.
-  CGNode *Content1 = getValueContent(ConGraph, V1);
-  CGNode *Content2 = getValueContent(ConGraph, V2);
-
+  // FIXME!!!: This will be rewritten to use node flags in the next commit.
   SILType T1 = V1->getType();
   SILType T2 = V2->getType();
   if (T1.isAddress() && T2.isAddress()) {

lib/SILOptimizer/Transforms/StackPromotion.cpp

@@ -108,32 +108,20 @@ bool StackPromotion::tryPromoteAlloc(AllocRefInst *ARI, EscapeAnalysis *EA,
     return false;
 
   auto *ConGraph = EA->getConnectionGraph(ARI->getFunction());
-  auto *Node = ConGraph->getNodeOrNull(ARI);
-  if (!Node)
+  auto *contentNode = ConGraph->getValueContent(ARI);
+  if (!contentNode)
     return false;
 
   // The most important check: does the object escape the current function?
-  if (Node->escapes())
+  if (contentNode->escapes())
     return false;
 
   LLVM_DEBUG(llvm::dbgs() << "Promote " << *ARI);
 
   // Collect all use-points of the allocation. These are refcount instructions
   // and apply instructions.
-  llvm::SmallVector<SILNode *, 8> BaseUsePoints;
   llvm::SmallVector<SILInstruction *, 8> UsePoints;
-  ConGraph->getUsePoints(Node, BaseUsePoints);
-  for (SILNode *UsePoint : BaseUsePoints) {
-    if (SILInstruction *I = dyn_cast<SILInstruction>(UsePoint)) {
-      UsePoints.push_back(I);
-    } else {
-      // Also block arguments can be use points.
-      SILBasicBlock *UseBB = cast<SILPhiArgument>(UsePoint)->getParent();
-      // For simplicity we just add the first instruction of the block as use
-      // point.
-      UsePoints.push_back(&UseBB->front());
-    }
-  }
+  ConGraph->getUsePoints(contentNode, UsePoints);
 
   ValueLifetimeAnalysis VLA(ARI, UsePoints);
   // Check if there is a use point before the allocation (this can happen e.g.

lib/SILOptimizer/UtilityPasses/EscapeAnalysisDumper.cpp

@@ -25,6 +25,23 @@ llvm::cl::opt<bool> EnableGraphWriter(
 
 namespace {
 
+static bool gatherValues(EscapeAnalysis *EA, SILFunction &Fn,
+                         std::vector<SILValue> &Values) {
+  for (auto &BB : Fn) {
+    for (auto *Arg : BB.getArguments()) {
+      if (EA->isPointer(Arg))
+        Values.push_back(SILValue(Arg));
+    }
+    for (auto &II : BB) {
+      for (auto result : II.getResults()) {
+        if (EA->isPointer(result))
+          Values.push_back(result);
+      }
+    }
+  }
+  return Values.size() > 1;
+}
+
 /// Dumps the escape information of all functions in the module.
 /// Only dumps if the compiler is built with assertions.
 /// For details see EscapeAnalysis.
@@ -43,6 +60,33 @@ class EscapeAnalysisDumper : public SILModuleTransform {
         ConnectionGraph->print(llvm::outs());
         if (EnableGraphWriter)
           ConnectionGraph->dumpCG();
+
+        // Gather up all Values in Fn.
+        std::vector<SILValue> Values;
+        if (!gatherValues(EA, F, Values))
+          continue;
+
+        // Emit the N^2 escape analysis evaluation of the values.
+        for (auto &bb : F) {
+          for (auto &ii : bb) {
+            if (auto fas = FullApplySite::isa(&ii)) {
+              for (unsigned i = 0, e = Values.size(); i != e; ++i) {
+                SILValue val = Values[i];
+                bool escape = EA->canEscapeTo(val, fas);
+                llvm::outs() << (escape ? "May" : "No") << "Escape: " << val
+                             << " to " << ii;
+              }
+            }
+            if (RefCountingInst *rci = dyn_cast<RefCountingInst>(&ii)) {
+              for (unsigned i = 0, e = Values.size(); i != e; ++i) {
+                SILValue val = Values[i];
+                bool escape = EA->canEscapeTo(val, rci);
+                llvm::outs() << (escape ? "May" : "No") << "Escape: " << val
+                             << " to " << ii;
+              }
+            }
+          }
+        }
       }
     }
 #endif