MemoryLifetime: Make the dataflow solving functions of MemoryDataflow more flexible.

Add the possibility to solve with a custom join operator.

Author: eeckstein

include/swift/SIL/MemoryLifetime.h

@@ -183,6 +183,11 @@ class MemoryLocations {
     return &locations[index];
   }
 
+  /// Registers an address projection instruction for a location.
+  void registerProjection(SingleValueInstruction *projection, unsigned locIdx) {
+    addr2LocIdx[projection] = locIdx;
+  }
+
   /// Sets the location bits os \p addr in \p bits, if \p addr is associated
   /// with a location.
   void setBits(Bits &bits, SILValue addr) {
@@ -341,13 +346,29 @@ class MemoryDataflow {
   /// Calculates the BlockState::exitReachable flags.
   void exitReachableAnalysis();
 
+  using JoinOperation = std::function<void (Bits &dest, const Bits &src)>;
+
   /// Derives the block exit sets from the entry sets by applying the gen and
   /// kill sets.
-  void solveDataflowForward();
+  /// At control flow joins, the \p join operation is applied.
+  void solveForward(JoinOperation join);
+
+  /// Calls solveForward() with a bit-intersection as join operation.
+  void solveForwardWithIntersect();
+
+  /// Calls solveForward() with a bit-union as join operation.
+  void solveForwardWithUnion();
 
   /// Derives the block entry sets from the exit sets by applying the gen and
   /// kill sets.
-  void solveDataflowBackward();
+  /// At control flow joins, the \p join operation is applied.
+  void solveBackward(JoinOperation join);
+
+  /// Calls solveBackward() with a bit-intersection as join operation.
+  void solveBackwardWithIntersect();
+
+  /// Calls solveBackward() with a bit-union as join operation.
+  void solveBackwardWithUnion();
 
   /// Debug dump the MemoryLifetime internals.
   void dump() const;

lib/SIL/MemoryLifetime.cpp

@@ -299,7 +299,7 @@ bool MemoryLocations::analyzeAddrProjection(
                                       subLocationMap)) {
     return false;
   }
-  addr2LocIdx[projection] = subLocIdx;
+  registerProjection(projection, subLocIdx);
   collectedVals.push_back(projection);
   return true;
 }
@@ -395,7 +395,7 @@ void MemoryDataflow::exitReachableAnalysis() {
   }
 }
 
-void MemoryDataflow::solveDataflowForward() {
+void MemoryDataflow::solveForward(JoinOperation join) {
   // Pretty standard data flow solving.
   bool changed = false;
   bool firstRound = true;
@@ -405,7 +405,7 @@ void MemoryDataflow::solveDataflowForward() {
       Bits bits = st.entrySet;
       assert(!bits.empty());
       for (SILBasicBlock *pred : st.block->getPredecessorBlocks()) {
-        bits &= block2State[pred]->exitSet;
+        join(bits, block2State[pred]->exitSet);
       }
       if (firstRound || bits != st.entrySet) {
         changed = true;
@@ -419,7 +419,19 @@ void MemoryDataflow::solveDataflowForward() {
   } while (changed);
 }
 
-void MemoryDataflow::solveDataflowBackward() {
+void MemoryDataflow::solveForwardWithIntersect() {
+  solveForward([](Bits &entry, const Bits &predExit){
+    entry &= predExit;
+  });
+}
+
+void MemoryDataflow::solveForwardWithUnion() {
+  solveForward([](Bits &entry, const Bits &predExit){
+    entry |= predExit;
+  });
+}
+
+void MemoryDataflow::solveBackward(JoinOperation join) {
   // Pretty standard data flow solving.
   bool changed = false;
   bool firstRound = true;
@@ -429,7 +441,7 @@ void MemoryDataflow::solveDataflowBackward() {
       Bits bits = st.exitSet;
       assert(!bits.empty());
       for (SILBasicBlock *succ : st.block->getSuccessorBlocks()) {
-        bits &= block2State[succ]->entrySet;
+        join(bits, block2State[succ]->entrySet);
       }
       if (firstRound || bits != st.exitSet) {
         changed = true;
@@ -443,6 +455,18 @@ void MemoryDataflow::solveDataflowBackward() {
   } while (changed);
 }
 
+void MemoryDataflow::solveBackwardWithIntersect() {
+  solveBackward([](Bits &entry, const Bits &predExit){
+    entry &= predExit;
+  });
+}
+
+void MemoryDataflow::solveBackwardWithUnion() {
+  solveBackward([](Bits &entry, const Bits &predExit){
+    entry |= predExit;
+  });
+}
+
 void MemoryDataflow::dump() const {
   for (const BlockState &st : blockStates) {
     llvm::dbgs() << "bb" << st.block->getDebugID() << ":\n"
@@ -894,7 +918,7 @@ void MemoryLifetimeVerifier::verify() {
     MemoryDataflow dataFlow(function, locations.getNumLocations());
     dataFlow.entryReachabilityAnalysis();
     initDataflow(dataFlow);
-    dataFlow.solveDataflowForward();
+    dataFlow.solveForwardWithIntersect();
     checkFunction(dataFlow);
   }
   // Second step: handle single-block locations.