[MemorySSA] Add API to update an incoming block into a MemoryPhi.

[asbirlea]

Summary

Add an API to update the incoming block into a MemoryPhi when a block predecessors changes.
The use case is when splitting blocks. This patch unblocks D45300.

[asbirlea]

This can actually be done with the more generic wireOldPredecessorsToNewImmediatePredecessor.
There's some extra work in the generic one with creating a new phi and then deleting it, but it may be better than having another API.
George, let me know if you agree with using the generic one and I'll abandon this revision. Thanks!

[george.burgess.iv]

George, let me know if you agree with using the generic one and I'll abandon this revision. Thanks!

Unless profiling shows that it makes a difference, I'm in favor of using the generic impl for simplicity/code reuse, too.

Thanks for the patch!

include/llvm/Analysis/MemorySSAUpdater.h

127

(If we do drop the new API, do the users of replacePhiIncomingBlock guarantee that ReplaceWith is empty? I assume so, but if not, might want to rephrase this -- feel free to do so with post-commit review :) )

[asbirlea]

Ack, using the generic one. I can revisit this if, once used, profiling shows a significant difference.

include/llvm/Analysis/MemorySSAUpdater.h

127

Yes, ReplaceWith is empty.

include/llvm/Analysis/MemorySSAUpdater.h

public:
   /// |------|        |      |
   ///    ||      =>   |      |
   ///    \/           |      |
   /// |------|        |      |  <- Start
   /// | From |        |      |
   /// |------|        |------|
   void moveAllAfterMergeBlocks(BasicBlock *From, BasicBlock *To,
                                Instruction *Start);
   /// BasicBlock Old had New, an empty BasicBlock, added directly before it,
   /// and the predecessors in Preds that used to point to Old, now point to
   /// New. If New is the only predecessor, move Old's Phi, if present, to New.
   /// Otherwise, add a new Phi in New with appropriate incoming values, and
   /// update the incoming values in Old's Phi node too, if present.
   void
   wireOldPredecessorsToNewImmediatePredecessor(BasicBlock *Old, BasicBlock *New,
                                                ArrayRef<BasicBlock *> Preds);
-
+  /// `ToReplace` used to be a predecessor of BB. `ReplaceWith` is the new
+  /// predecessor. Update Phi in BB to replace incoming block `ToReplace` with
+  /// `ReplaceWith`.
+  void replacePhiIncomingBlock(BasicBlock *BB, BasicBlock *ToReplace,
+                               BasicBlock *ReplaceWith);
   // The below are utility functions. Other than creation of accesses to pass
   // to insertDef, and removeAccess to remove accesses, you should generally
   // not attempt to update memoryssa yourself. It is very non-trivial to get
   // the edge cases right, and the above calls already operate in near-optimal
   // time bounds.
 
   /// Create a MemoryAccess in MemorySSA at a specified point in a block,
   /// with a specified clobbering definition.

lib/Analysis/MemorySSAUpdater.cpp

while (!Worklist.empty()) {
             continue;
           Worklist.push_back(S);
         }
       }
     }
   }
 }
 
+void MemorySSAUpdater::replacePhiIncomingBlock(BasicBlock *BB,
+                                               BasicBlock *ToReplace,
+                                               BasicBlock *ReplaceWith) {
+  if (MemoryPhi *MPhi = MSSA->getMemoryAccess(BB)) {
+    unsigned I = MPhi->getBasicBlockIndex(ToReplace);
+    assert((I >= 0) && "MemoryPhi position out of bounds");
+    MPhi->setIncomingBlock(I, ReplaceWith);
+  }
+}
+
 // Move What before Where in the MemorySSA IR.
 template <class WhereType>
 void MemorySSAUpdater::moveTo(MemoryUseOrDef *What, BasicBlock *BB,
                               WhereType Where) {
   // Mark MemoryPhi users of What not to be optimized.
   for (auto *U : What->users())
     if (MemoryPhi *PhiUser = dyn_cast<MemoryPhi>(U))
       NonOptPhis.insert(PhiUser);