Remove SILValue::replaceAllUsesWith.

It's not needed anymore because we can use ValueBase::replaceAllUses

Author: eeckstein

include/swift/SIL/SILValue.h

@@ -230,8 +230,6 @@ class SILValue {
   /// intrinsic call.
   SILValue stripExpectIntrinsic();
 
-  void replaceAllUsesWith(SILValue V);
-
   void dump() const;
   void print(raw_ostream &os) const;
 

lib/Parse/ParseSIL.cpp

@@ -546,7 +546,7 @@ void SILParser::setLocalValue(ValueBase *Value, StringRef Name,
       HadError = true;
     } else {
       // Forward references only live here if they have a single result.
-      SILValue(Entry).replaceAllUsesWith(SILValue(Value));
+      Entry->replaceAllUsesWith(Value);
     }
     Entry = Value;
     return;

lib/SIL/SILValue.cpp

@@ -34,13 +34,6 @@ static_assert(sizeof(SILValue) == sizeof(uintptr_t),
 //                              Utility Methods
 //===----------------------------------------------------------------------===//
 
-void SILValue::replaceAllUsesWith(SILValue V) {
-  assert(*this != V && "Cannot RAUW a value with itself");
-  assert(getType() == V.getType() && "Invalid type");
-  while (!use_empty())
-    (**use_begin()).set(V);
-}
-
 static bool isRCIdentityPreservingCast(ValueKind Kind) {
   switch (Kind) {
   case ValueKind::UpcastInst:

lib/SILGen/SILGenEpilog.cpp

@@ -95,7 +95,7 @@ SILGenFunction::emitEpilogBB(SILLocation TopLevel) {
     if (needsArg) {
       returnValue = predBranch->getArgs()[0];
       // RAUW the old BB argument (if any) with the new value.
-      SILValue(*epilogBB->bbarg_begin()).replaceAllUsesWith(returnValue);
+      (*epilogBB->bbarg_begin())->replaceAllUsesWith(returnValue.getDef());
     }
 
     // If we are optimizing, we should use the return location from the single,

lib/SILOptimizer/IPO/FunctionSignatureOpts.cpp

@@ -397,8 +397,8 @@ unsigned ArgumentDescriptor::updateOptimizedBBArgs(SILBuilder &Builder,
 
   // Replace all uses of the original arg with undef so it does not have any
   // uses.
-  SILValue OrigArg = SILValue(BB->getBBArg(OldArgOffset));
-  OrigArg.replaceAllUsesWith(SILUndef::get(OrigArg.getType(), BB->getModule()));
+  SILArgument *OrigArg = BB->getBBArg(OldArgOffset);
+  OrigArg->replaceAllUsesWith(SILUndef::get(OrigArg->getType(), BB->getModule()));
 
   // Now erase the old argument since it does not have any uses. We also
   // decrement ArgOffset since we have one less argument now.

lib/SILOptimizer/Mandatory/ConstantPropagation.cpp

@@ -766,7 +766,7 @@ constantFoldStringConcatenation(ApplyInst *AI,
     return false;
 
   // Replace all uses of the old instruction by a new instruction.
-  SILValue(AI).replaceAllUsesWith(Concatenated);
+  AI->replaceAllUsesWith(Concatenated);
 
   auto RemoveCallback = [&](SILInstruction *DeadI) { WorkList.remove(DeadI); };
   // Remove operands that are not used anymore.
@@ -861,7 +861,7 @@ processFunction(SILFunction &F, bool EnableDiagnostics,
       [&](SILInstruction *I, ValueBase *V) { /* ReplaceInstUsesAction */
 
         InvalidateInstructions = true;
-        SILValue(I).replaceAllUsesWith(V);
+        I->replaceAllUsesWith(V);
       },
       [&](SILInstruction *I) { /* EraseAction */
         auto *TI = dyn_cast<TermInst>(I);
@@ -1036,7 +1036,7 @@ processFunction(SILFunction &F, bool EnableDiagnostics,
 
 
       // We were able to fold, so all users should use the new folded value.
-      SILValue(User).replaceAllUsesWith(C);
+      User->replaceAllUsesWith(C.getDef());
 
       // The new constant could be further folded now, add it to the worklist.
       if (auto *Inst = dyn_cast<SILInstruction>(C.getDef()))

lib/SILOptimizer/Mandatory/DiagnoseUnreachable.cpp

@@ -171,7 +171,7 @@ static void propagateBasicBlockArgs(SILBasicBlock &BB) {
     SILArgument *Arg = *AI;
 
     // We were able to fold, so all users should use the new folded value.
-    SILValue(Arg).replaceAllUsesWith(Args[Idx]);
+    Arg->replaceAllUsesWith(Args[Idx].getDef());
     NumBasicBlockArgsPropagated++;
   }
 

lib/SILOptimizer/Transforms/RedundantLoadElimination.cpp

@@ -1342,7 +1342,7 @@ bool RLEContext::run() {
       DEBUG(llvm::dbgs() << "Replacing  " << SILValue(F.first) << "With "
                          << F.second);
       SILChanged = true;
-      SILValue(F.first).replaceAllUsesWith(F.second);
+      F.first->replaceAllUsesWith(F.second.getDef());
       InstsToDelete.insert(F.first);
       ++NumForwardedLoads;
     }

lib/SILOptimizer/Transforms/RemovePin.cpp

@@ -111,7 +111,7 @@ class RemovePinInsts : public SILFunctionTransform {
               Changed = true;
               auto *Enum = SILBuilder(PinDef).createOptionalSome(
                   PinDef->getLoc(), PinDef->getOperand(), PinDef->getType());
-              SILValue(PinDef).replaceAllUsesWith(Enum);
+              PinDef->replaceAllUsesWith(Enum);
               Unpin->eraseFromParent();
               PinDef->eraseFromParent();
               // Remove this pindef from AvailablePins.

lib/SILOptimizer/Transforms/SILCodeMotion.cpp

@@ -423,7 +423,7 @@ static bool sinkArgument(SILBasicBlock *BB, unsigned ArgNum) {
   if (!FSI)
     return false;
 
-  SILValue Undef = SILUndef::get(FirstPredArg.getType(), BB->getModule());
+  auto *Undef = SILUndef::get(FirstPredArg.getType(), BB->getModule());
 
   // Delete the debug info of the instruction that we are about to sink.
   deleteAllDebugUses(FSI);
@@ -435,7 +435,7 @@ static bool sinkArgument(SILBasicBlock *BB, unsigned ArgNum) {
     // The instruction we are lowering has an argument which is different
     // for each predecessor.  We need to sink the instruction, then add
     // arguments for each predecessor.
-    SILValue(BB->getBBArg(ArgNum)).replaceAllUsesWith(FSI);
+    BB->getBBArg(ArgNum)->replaceAllUsesWith(FSI);
 
     const auto &ArgType = FSI->getOperand(*DifferentOperandIndex).getType();
     BB->replaceBBArg(ArgNum, ArgType);
@@ -465,16 +465,16 @@ static bool sinkArgument(SILBasicBlock *BB, unsigned ArgNum) {
   }
 
   // Sink one of the copies of the instruction.
-  FirstPredArg.replaceAllUsesWith(Undef);
+  FirstPredArg->replaceAllUsesWith(Undef);
   FSI->moveBefore(&*BB->begin());
-  SILValue(BB->getBBArg(ArgNum)).replaceAllUsesWith(FirstPredArg);
+  BB->getBBArg(ArgNum)->replaceAllUsesWith(FirstPredArg.getDef());
 
   // The argument is no longer in use. Replace all incoming inputs with undef
   // and try to delete the instruction.
   for (auto S : Clones)
     if (S.getDef() != FSI) {
       deleteAllDebugUses(S.getDef());
-      S.replaceAllUsesWith(Undef);
+      S->replaceAllUsesWith(Undef);
       auto DeadArgInst = cast<SILInstruction>(S.getDef());
       recursivelyDeleteTriviallyDeadInstructions(DeadArgInst);
     }

lib/SILOptimizer/Transforms/SILSROA.cpp

@@ -236,7 +236,7 @@ void SROAMemoryUseAnalyzer::chopUpAlloca(std::vector<AllocStackInst *> &Worklist
       Elements.push_back(B.createLoad(LI->getLoc(), NewAI));
     auto *Agg = createAgg(B, LI->getLoc(), LI->getType().getObjectType(),
                           Elements);
-    SILValue(LI).replaceAllUsesWith(Agg);
+    LI->replaceAllUsesWith(Agg);
     LI->eraseFromParent();
   }
 
@@ -252,8 +252,8 @@ void SROAMemoryUseAnalyzer::chopUpAlloca(std::vector<AllocStackInst *> &Worklist
 
   // Forward any field extracts to the new allocation.
   for (auto *Ext : ExtractInsts) {
-    SILValue NewValue = NewAllocations[getEltNoForProjection(Ext)];
-    SILValue(Ext).replaceAllUsesWith(NewValue);
+    AllocStackInst *NewValue = NewAllocations[getEltNoForProjection(Ext)];
+    Ext->replaceAllUsesWith(NewValue);
     Ext->eraseFromParent();
   }
 

lib/SILOptimizer/Transforms/SimplifyCFG.cpp

@@ -1077,7 +1077,7 @@ bool SimplifyCFG::simplifyBranchBlock(BranchInst *BI) {
     // branch operands, since they must dominate the dest block.
     for (unsigned i = 0, e = BI->getArgs().size(); i != e; ++i) {
       if (DestBB->getBBArg(i) != BI->getArg(i).getDef())
-        SILValue(DestBB->getBBArg(i)).replaceAllUsesWith(BI->getArg(i));
+        DestBB->getBBArg(i)->replaceAllUsesWith(BI->getArg(i).getDef());
       else {
         // We must be processing an unreachable part of the cfg with a cycle.
         // bb1(arg1): // preds: bb3
@@ -2490,7 +2490,7 @@ bool ArgumentSplitter::createNewArguments() {
     assert(Agg->hasValue() && "Expected a result");
   }
 
-  SILValue(Arg).replaceAllUsesWith(SILValue(Agg));
+  Arg->replaceAllUsesWith(Agg);
 
   // Look at all users of agg and see if we can simplify any of them. This will
   // eliminate struct_extracts/tuple_extracts from the newly created aggregate

lib/SILOptimizer/Utils/CFG.cpp

@@ -728,7 +728,7 @@ bool swift::mergeBasicBlockWithSuccessor(SILBasicBlock *BB, DominanceInfo *DT,
   // If there are any BB arguments in the destination, replace them with the
   // branch operands, since they must dominate the dest block.
   for (unsigned i = 0, e = Branch->getArgs().size(); i != e; ++i)
-    SILValue(SuccBB->getBBArg(i)).replaceAllUsesWith(Branch->getArg(i));
+    SuccBB->getBBArg(i)->replaceAllUsesWith(Branch->getArg(i).getDef());
 
   Branch->eraseFromParent();
 

lib/SILOptimizer/Utils/Local.cpp

@@ -2221,7 +2221,7 @@ bool swift::simplifyUsers(SILInstruction *I) {
     if (!S)
       continue;
 
-    SILValue(User).replaceAllUsesWith(S);
+    User->replaceAllUsesWith(S.getDef());
     User->eraseFromParent();
     Changed = true;
   }

lib/SILOptimizer/Utils/SILInliner.cpp

@@ -112,7 +112,7 @@ bool SILInliner::inlineFunction(FullApplySite AI, ArrayRef<SILValue> Args) {
     if (ReturnInst *RI = dyn_cast<ReturnInst>(CalleeEntryBB->getTerminator())) {
       // Replace all uses of the apply instruction with the operands of the
       // return instruction, appropriately mapped.
-      SILValue(nonTryAI).replaceAllUsesWith(remapValue(RI->getOperand()));
+      nonTryAI->replaceAllUsesWith(remapValue(RI->getOperand()).getDef());
       return true;
     }
   }
@@ -137,10 +137,10 @@ bool SILInliner::inlineFunction(FullApplySite AI, ArrayRef<SILValue> Args) {
                            SILFunction::iterator(ReturnToBB));
 
     // Create an argument on the return-to BB representing the returned value.
-    SILValue RetArg = new (F.getModule()) SILArgument(ReturnToBB,
+    auto *RetArg = new (F.getModule()) SILArgument(ReturnToBB,
                                             AI.getInstruction()->getType());
     // Replace all uses of the ApplyInst with the new argument.
-    SILValue(AI.getInstruction()).replaceAllUsesWith(RetArg);
+    AI.getInstruction()->replaceAllUsesWith(RetArg);
   }
 
   // Now iterate over the callee BBs and fix up the terminators.