Fix a logic error in eraseUseOfValue.

I failed to create a test case. And we hav existing tests in FSO that will
exercise this.

rdar://25559780

Author: trentxintong

include/swift/SILOptimizer/Utils/Local.h

@@ -77,9 +77,12 @@ bool isInstructionTriviallyDead(SILInstruction *I);
 bool isIntermediateRelease(SILInstruction *I,
                            ConsumedArgToEpilogueReleaseMatcher &ERM); 
 
+/// \brief Recursively collect all the uses and transistive uses of the
+/// instruction.
+void collectUsesOfValue(SILValue V, llvm::DenseSet<SILInstruction *> &Insts);
+
 /// \brief Recursively erase all of the uses of the instruction (but not the
-/// instruction itself) and delete instructions that will become trivially
-/// dead when this instruction is removed.
+/// instruction itself)
 void eraseUsesOfInstruction(
     SILInstruction *Inst,
     std::function<void(SILInstruction *)> C = [](SILInstruction *){});

lib/SILOptimizer/Utils/Local.cpp

@@ -207,29 +207,31 @@ void swift::eraseUsesOfInstruction(SILInstruction *Inst,
   }
 }
 
-void swift::eraseUsesOfValue(SILValue V) {
-  for (auto UI = V->use_begin(), E = V->use_end(); UI != E;) {
+void
+swift::collectUsesOfValue(SILValue V, llvm::DenseSet<SILInstruction *> &Insts) {
+  for (auto UI = V->use_begin(), E = V->use_end(); UI != E; UI++) {
     auto *User = UI->getUser();
-    UI++;
-
-    // If the instruction itself has any uses, recursively zap them so that
-    // nothing uses this instruction.
-    eraseUsesOfValue(User);
+    // Instruction has been processed.
+    if (Insts.find(User) != Insts.end())
+      continue;
 
-    // Walk through the operand list and delete any random instructions that
-    // will become trivially dead when this instruction is removed.
-    for (auto &Op : User->getAllOperands()) {
-      if (auto *OpI = dyn_cast<SILInstruction>(Op.get())) {
-        // Don't recursively delete the pointer we're getting in.
-        if (Op.get() != V) {
-          Op.drop();
-          recursivelyDeleteTriviallyDeadInstructions(OpI, false,
-                                                     [](SILInstruction *){});
-        }
-      }
-    }
+    // Collect the users of this instruction.
+    Insts.insert(User);
+    collectUsesOfValue(User, Insts);
+  }
+}
 
-    User->eraseFromParent();
+void swift::eraseUsesOfValue(SILValue V) {
+  llvm::DenseSet<SILInstruction *> Insts;
+  // Collect the uses.
+  collectUsesOfValue(V, Insts);
+  // Erase the uses, we can have instructions that become dead because
+  // of the removal of these instructions, leave to DCE to cleanup.
+  // Its not safe to do recursively delete here as some of the SILInstruction
+  // maybe tracked by this set.
+  for (auto I : Insts) {
+    I->replaceAllUsesWithUndef();
+    I->eraseFromParent();
   }
 }