Index: include/llvm/Analysis/MemorySSA.h
===================================================================
--- include/llvm/Analysis/MemorySSA.h
+++ include/llvm/Analysis/MemorySSA.h
@@ -781,7 +781,7 @@
   // relies on the updater to fixup what it breaks, so it is not public.
 
   void moveTo(MemoryUseOrDef *What, BasicBlock *BB, AccessList::iterator Where);
-  void moveTo(MemoryUseOrDef *What, BasicBlock *BB, InsertionPlace Point);
+  void moveTo(MemoryAccess *What, BasicBlock *BB, InsertionPlace Point);
 
   // Rename the dominator tree branch rooted at BB.
   void renamePass(BasicBlock *BB, MemoryAccess *IncomingVal,
Index: include/llvm/Analysis/MemorySSAUpdater.h
===================================================================
--- include/llvm/Analysis/MemorySSAUpdater.h
+++ include/llvm/Analysis/MemorySSAUpdater.h
@@ -89,6 +89,41 @@
   void moveAfter(MemoryUseOrDef *What, MemoryUseOrDef *Where);
   void moveToPlace(MemoryUseOrDef *What, BasicBlock *BB,
                    MemorySSA::InsertionPlace Where);
+  /// `From` block was spliced into `From` and `To`.
+  /// Move all accesses from `From` to `To` starting at instruction `Start`.
+  /// `To` is newly created BB, so empty of MemorySSA::MemoryAccesses.
+  /// Edges are already updated, so successors of `To` with MPhi nodes need to
+  /// update incoming block.
+  /// |------|        |------|
+  /// | From |        | From |
+  /// |      |        |------|
+  /// |      |           ||
+  /// |      |   =>      \/
+  /// |      |        |------|  <- Start
+  /// |      |        |  To  |
+  /// |------|        |------|
+  void moveAllAfterSpliceBlocks(BasicBlock *From, BasicBlock *To,
+                                Instruction *Start);
+  /// `From` block was merged into `To`. All instructiones were moved and
+  /// `From` is an empty block with successor edges; `From` is about to be
+  /// deleted. Move all accesses from `From` to `To` starting at instruction
+  /// `Start`. `To` may have multiple successors, `From` has a single
+  /// predecessor. `From` may have successors with MPhi nodes, replace their
+  /// incoming block with `To`.
+  /// |------|        |------|
+  /// |  To  |        |  To  |
+  /// |------|        |      |
+  ///    ||      =>   |      |
+  ///    \/           |      |
+  /// |------|        |      |  <- Start
+  /// | From |        |      |
+  /// |------|        |------|
+  void moveAllAfterMergeBlocks(BasicBlock *From, BasicBlock *To,
+                               Instruction *Start);
+  /// BasicBlock Old was split and now has a new immediate predecessor (New),
+  /// whose predecessors are Old's new predecessors. If a phi existed in Old,
+  /// move it to New.
+  void movePhiToNewImmediatePredecessor(BasicBlock *Old, BasicBlock *New);
 
   // The below are utility functions. Other than creation of accesses to pass
   // to insertDef, and removeAccess to remove accesses, you should generally
@@ -162,6 +197,10 @@
   // Move What before Where in the MemorySSA IR.
   template <class WhereType>
   void moveTo(MemoryUseOrDef *What, BasicBlock *BB, WhereType Where);
+  // Move all memory accesses from `From` to `To` starting at `Start`.
+  // Restrictions apply, see public wrappers of this method.
+  void moveAllAccesses(BasicBlock *From, BasicBlock *To, Instruction *Start,
+                       MemorySSA::InsertionPlace Where);
   MemoryAccess *getPreviousDef(MemoryAccess *);
   MemoryAccess *getPreviousDefInBlock(MemoryAccess *);
   MemoryAccess *
Index: lib/Analysis/MemorySSA.cpp
===================================================================
--- lib/Analysis/MemorySSA.cpp
+++ lib/Analysis/MemorySSA.cpp
@@ -1473,8 +1473,16 @@
   insertIntoListsBefore(What, BB, Where);
 }
 
-void MemorySSA::moveTo(MemoryUseOrDef *What, BasicBlock *BB,
+void MemorySSA::moveTo(MemoryAccess *What, BasicBlock *BB,
                        InsertionPlace Point) {
+  if (isa<MemoryPhi>(What)) {
+    assert(Point == Beginning &&
+           "Can only move a Phi at the beginning of the block");
+    // Update lookup table entry
+    ValueToMemoryAccess.erase(What->getBlock());
+    ValueToMemoryAccess[BB] = What;
+  }
+
   removeFromLists(What, false);
   What->setBlock(BB);
   insertIntoListsForBlock(What, BB, Point);
Index: lib/Analysis/MemorySSAUpdater.cpp
===================================================================
--- lib/Analysis/MemorySSAUpdater.cpp
+++ lib/Analysis/MemorySSAUpdater.cpp
@@ -430,6 +430,74 @@
   return moveTo(What, BB, Where);
 }
 
+// All accesses in To used to be in From. Update access lists.
+void MemorySSAUpdater::moveAllAccesses(BasicBlock *From, BasicBlock *To,
+                                       Instruction *Start,
+                                       MemorySSA::InsertionPlace Where) {
+
+  if (MemorySSA::AccessList *Accs = MSSA->getWritableBlockAccesses(From)) {
+    MemoryAccess *FirstInNew = nullptr;
+    BasicBlock::iterator StartSearch = Start->getIterator();
+    while (StartSearch != To->end()) {
+      FirstInNew = MSSA->getMemoryAccess(&*StartSearch);
+      if (FirstInNew)
+        break;
+      ++StartSearch;
+    }
+    if (FirstInNew) {
+      auto *MUD = dyn_cast_or_null<MemoryUseOrDef>(FirstInNew);
+      auto NextIt = ++MUD->getIterator();
+      MemoryUseOrDef *NextMUD =
+          (NextIt == Accs->end()) ? nullptr
+                                  : dyn_cast_or_null<MemoryUseOrDef>(&*NextIt);
+      MSSA->moveTo(MUD, To, Where);
+      auto InsertionPlace = ++MUD->getIterator();
+
+      while (NextMUD) {
+        MUD = NextMUD;
+        NextIt = ++MUD->getIterator();
+        MemorySSA::AccessList *NewAccs = MSSA->getWritableBlockAccesses(From);
+        NextMUD = (!NewAccs || NextIt == NewAccs->end())
+                      ? nullptr
+                      : dyn_cast_or_null<MemoryUseOrDef>(&*NextIt);
+        MSSA->moveTo(MUD, To, InsertionPlace);
+        InsertionPlace = ++MUD->getIterator();
+      }
+    }
+  }
+}
+
+void MemorySSAUpdater::moveAllAfterSpliceBlocks(BasicBlock *From,
+                                                BasicBlock *To,
+                                                Instruction *Start) {
+  assert(MSSA->getBlockAccesses(To) == nullptr &&
+         "To block is expected to be free of MemoryAccesses.");
+  moveAllAccesses(From, To, Start, MemorySSA::End);
+  for (succ_iterator Si = succ_begin(To), Se = succ_end(To); Si != Se; ++Si)
+    if (MemoryPhi *MPhi = MSSA->getMemoryAccess(*Si))
+      MPhi->setIncomingBlock(MPhi->getBasicBlockIndex(From), To);
+}
+
+void MemorySSAUpdater::moveAllAfterMergeBlocks(BasicBlock *From, BasicBlock *To,
+                                               Instruction *Start) {
+  assert(From->getSinglePredecessor() == To &&
+         "From block is expected to have a single predecessor (To).");
+  moveAllAccesses(From, To, Start, MemorySSA::End);
+  for (succ_iterator Si = succ_begin(From), Se = succ_end(From); Si != Se; ++Si)
+    if (MemoryPhi *MPhi = MSSA->getMemoryAccess(*Si))
+      MPhi->setIncomingBlock(MPhi->getBasicBlockIndex(From), To);
+}
+
+void MemorySSAUpdater::movePhiToNewImmediatePredecessor(BasicBlock *Old,
+                                                        BasicBlock *New) {
+  assert(MSSA->getWritableBlockAccesses(New) == nullptr &&
+         "Access list should be null for a new block");
+  MemoryPhi *Phi = MSSA->getMemoryAccess(Old);
+  if (!Phi)
+    return;
+  MSSA->moveTo(Phi, New, MemorySSA::Beginning);
+}
+
 /// If all arguments of a MemoryPHI are defined by the same incoming
 /// argument, return that argument.
 static MemoryAccess *onlySingleValue(MemoryPhi *MP) {