[MemorySSA] Add API to reset optimized for uses of a replaced instruction.

[asbirlea]

Summary

If an instruction is optimized and replaced with another value, all the uses (instructions) of the replaced instruction, now point to said value.
This means that if these uses (instructions) have MemoryAccesses attached, they need to be un-optimized, as they may not longer have teh same clobbering access.
The use case that triggered this is in EarlyCSE w/ MemorySSA, where the replacement value is "undef".

[asbirlea]

Need to bypass geps when traversing users, use worklist.
Adding test in dependent patch.

[asbirlea]

Avoid duplicates (use set).

include/llvm/Analysis/MemorySSAUpdater.h

public:
   /// Assumption we make here: all uses of deleted defs and phi must either
   /// occur in blocks about to be deleted (thus will be deleted as well), or
   /// they occur in phis that will simply lose an incoming value.
   /// Deleted blocks still have successor info, but their predecessor edges and
   /// Phi nodes may already be updated. Instructions in DeadBlocks should be
   /// deleted after this call.
   void removeBlocks(const SmallPtrSetImpl<BasicBlock *> &DeadBlocks);
 
+  /// Reset optimized for uses of a given instruction, if those uses have
+  /// MemoryAccesses. This should be called when the instruction is about to be
+  /// replaced, since its replacement may change the clobber (e.g., simplify to
+  /// undef).
+  void resetOptimizeUses(const Instruction *I);
+
   /// Get handle on MemorySSA.
   MemorySSA* getMemorySSA() const { return MSSA; }
 
 private:
   // 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`.

lib/Analysis/MemorySSAUpdater.cpp

for (auto AB = Acc->begin(), AE = Acc->end(); AB != AE;) {
       MemoryAccess *MA = &*AB;
       ++AB;
       MSSA->removeFromLookups(MA);
       MSSA->removeFromLists(MA);
     }
   }
 }
 
+void MemorySSAUpdater::resetOptimizeUses(const Instruction *I) {
+  SmallVector<const Instruction *, 16> Worklist;
+  for (const auto *Usr : I->users())
+    if (auto *UsrI = dyn_cast<Instruction>(Usr))
+      Worklist.push_back(UsrI);
+
+  for (unsigned It = 0; It < Worklist.size(); ++It) {
+    if (auto *MA = MSSA->getMemoryAccess(Worklist[It])) {
+      auto *MUD = cast<MemoryUseOrDef>(MA);
+      if (MUD->isOptimized())
+        MUD->resetOptimized();
+    } else {
+      for (const auto *Usr : Worklist[It]->users())
+        if (auto *UsrI = dyn_cast<Instruction>(Usr))
+          Worklist.push_back(UsrI);
+    }
+  }
+}
+
 MemoryAccess *MemorySSAUpdater::createMemoryAccessInBB(
     Instruction *I, MemoryAccess *Definition, const BasicBlock *BB,
     MemorySSA::InsertionPlace Point) {
   MemoryUseOrDef *NewAccess = MSSA->createDefinedAccess(I, Definition);
   MSSA->insertIntoListsForBlock(NewAccess, BB, Point);
   return NewAccess;
 }