ARCSequenceOpts: Remove unused args in several functions

Author: meg-gupta

lib/SILOptimizer/ARC/ARCRegionState.cpp

@@ -208,7 +208,7 @@ static bool processBlockBottomUpInsts(
       if (Op && OtherState->first == Op)
         continue;
 
-      OtherState->second.updateForSameLoopInst(I, SetFactory, AA);
+      OtherState->second.updateForSameLoopInst(I, AA);
     }
   }
 
@@ -275,7 +275,7 @@ bool ARCRegionState::processLoopBottomUp(
       continue;
 
     for (auto *I : State->getSummarizedInterestingInsts())
-      OtherState->second.updateForDifferentLoopInst(I, SetFactory, AA);
+      OtherState->second.updateForDifferentLoopInst(I, AA);
   }
 
   return false;
@@ -361,7 +361,7 @@ bool ARCRegionState::processBlockTopDown(
       if (Op && OtherState->first == Op)
         continue;
 
-      OtherState->second.updateForSameLoopInst(I, SetFactory, AA);
+      OtherState->second.updateForSameLoopInst(I, AA);
     }
   }
 
@@ -394,7 +394,7 @@ bool ARCRegionState::processLoopTopDown(
       continue;
 
     for (auto *I : State->getSummarizedInterestingInsts())
-      OtherState->second.updateForDifferentLoopInst(I, SetFactory, AA);
+      OtherState->second.updateForDifferentLoopInst(I, AA);
   }
 
   return false;

lib/SILOptimizer/ARC/GlobalARCSequenceDataflow.cpp

@@ -108,7 +108,7 @@ bool ARCSequenceDataflowEvaluator::processBBTopDown(ARCBBState &BBState) {
       if (Op && OtherState->first == Op)
         continue;
 
-      OtherState->second.updateForSameLoopInst(&I, SetFactory, AA);
+      OtherState->second.updateForSameLoopInst(&I, AA);
     }
   }
 
@@ -260,7 +260,7 @@ bool ARCSequenceDataflowEvaluator::processBBBottomUp(
       if (Op && OtherState->first == Op)
         continue;
 
-      OtherState->second.updateForSameLoopInst(&I, SetFactory, AA);
+      OtherState->second.updateForSameLoopInst(&I, AA);
     }
   }
 

lib/SILOptimizer/ARC/RefCountState.cpp

@@ -195,9 +195,7 @@ bool BottomUpRefCountState::valueCanBeUsedGivenLatticeState() const {
 
 /// Given the current lattice state, if we have seen a use, advance the
 /// lattice state. Return true if we do so and false otherwise.
-bool BottomUpRefCountState::handleUser(
-    SILValue RCIdentity,
-    ImmutablePointerSetFactory<SILInstruction> &SetFactory, AliasAnalysis *AA) {
+bool BottomUpRefCountState::handleUser() {
   assert(valueCanBeUsedGivenLatticeState() &&
          "Must be able to be used at this point of the lattice.");
 
@@ -233,9 +231,7 @@ valueCanBeGuaranteedUsedGivenLatticeState() const {
 
 /// Given the current lattice state, if we have seen a use, advance the
 /// lattice state. Return true if we do so and false otherwise.
-bool BottomUpRefCountState::handleGuaranteedUser(
-    SILValue RCIdentity,
-    ImmutablePointerSetFactory<SILInstruction> &SetFactory, AliasAnalysis *AA) {
+bool BottomUpRefCountState::handleGuaranteedUser() {
   assert(valueCanBeGuaranteedUsedGivenLatticeState() &&
          "Must be able to be used at this point of the lattice.");
 
@@ -270,14 +266,12 @@ bool BottomUpRefCountState::isRefCountInstMatchedToTrackedInstruction(
   if (!Transition.matchingInst(RefCountInst))
     return false;
 
-  return handleRefCountInstMatch(RefCountInst);
+  return handleRefCountInstMatch();
 }
 
 /// We have a matching ref count inst. Return true if we advance the sequence
 /// and false otherwise.
-bool
-BottomUpRefCountState::
-handleRefCountInstMatch(SILInstruction *RefCountInst) {
+bool BottomUpRefCountState::handleRefCountInstMatch() {
   // Otherwise modify the state appropriately in preparation for removing the
   // increment, decrement pair.
   switch (LatState) {
@@ -340,8 +334,7 @@ bool BottomUpRefCountState::merge(const BottomUpRefCountState &Other) {
 // the value we are tracking. If so advance the state's sequence appropriately
 // and return true. Otherwise return false.
 bool BottomUpRefCountState::handlePotentialGuaranteedUser(
-    SILInstruction *PotentialGuaranteedUser,
-    ImmutablePointerSetFactory<SILInstruction> &SetFactory, AliasAnalysis *AA) {
+    SILInstruction *PotentialGuaranteedUser, AliasAnalysis *AA) {
   // If we are not tracking a ref count, just return false.
   if (!isTrackingRefCount())
     return false;
@@ -375,7 +368,7 @@ bool BottomUpRefCountState::handlePotentialGuaranteedUser(
       FoundNonARCUser = true;
 
   // Otherwise, update the ref count state given the guaranteed user.
-  return handleGuaranteedUser(getRCRoot(), SetFactory, AA);
+  return handleGuaranteedUser();
 }
 
 /// Check if PotentialDecrement can decrement the reference count associated
@@ -408,9 +401,8 @@ bool BottomUpRefCountState::handlePotentialDecrement(
 // Check if PotentialUser could be a use of the reference counted value that
 // requires user to be alive. If so advance the state's sequence
 // appropriately and return true. Otherwise return false.
-bool BottomUpRefCountState::handlePotentialUser(
-    SILInstruction *PotentialUser,
-    ImmutablePointerSetFactory<SILInstruction> &SetFactory, AliasAnalysis *AA) {
+bool BottomUpRefCountState::handlePotentialUser(SILInstruction *PotentialUser,
+                                                AliasAnalysis *AA) {
 
   // If we are not tracking a ref count, just return false.
   if (!isTrackingRefCount())
@@ -434,12 +426,11 @@ bool BottomUpRefCountState::handlePotentialUser(
     if (mustUseValue(PotentialUser, getRCRoot(), AA))
       FoundNonARCUser = true;
 
-  return handleUser(getRCRoot(), SetFactory, AA);
+  return handleUser();
 }
 
-void BottomUpRefCountState::updateForSameLoopInst(
-    SILInstruction *I,
-    ImmutablePointerSetFactory<SILInstruction> &SetFactory, AliasAnalysis *AA) {
+void BottomUpRefCountState::updateForSameLoopInst(SILInstruction *I,
+                                                  AliasAnalysis *AA) {
   // If this state is not tracking anything, there is nothing to update.
   if (!isTrackingRefCount())
     return;
@@ -448,7 +439,7 @@ void BottomUpRefCountState::updateForSameLoopInst(
   // instruction in a way that requires us to guarantee the lifetime of the
   // pointer up to this point. This has the effect of performing a use and a
   // decrement.
-  if (handlePotentialGuaranteedUser(I, SetFactory, AA)) {
+  if (handlePotentialGuaranteedUser(I, AA)) {
     LLVM_DEBUG(llvm::dbgs() << "    Found Potential Guaranteed Use:\n        "
                             << getRCRoot());
     return;
@@ -465,15 +456,14 @@ void BottomUpRefCountState::updateForSameLoopInst(
 
   // Otherwise check if the reference counted value we are tracking
   // could be used by the given instruction.
-  if (!handlePotentialUser(I, SetFactory, AA))
+  if (!handlePotentialUser(I, AA))
     return;
   LLVM_DEBUG(llvm::dbgs() << "    Found Potential Use:\n        "
                           << getRCRoot());
 }
 
-void BottomUpRefCountState::updateForDifferentLoopInst(
-    SILInstruction *I,
-    ImmutablePointerSetFactory<SILInstruction> &SetFactory, AliasAnalysis *AA) {
+void BottomUpRefCountState::updateForDifferentLoopInst(SILInstruction *I,
+                                                       AliasAnalysis *AA) {
   // If we are not tracking anything, bail.
   if (!isTrackingRefCount())
     return;
@@ -483,15 +473,15 @@ void BottomUpRefCountState::updateForDifferentLoopInst(
         mayDecrementRefCount(I, getRCRoot(), AA)) {
       LLVM_DEBUG(llvm::dbgs() << "    Found potential guaranteed use:\n        "
                               << getRCRoot());
-      handleGuaranteedUser(getRCRoot(), SetFactory, AA);
+      handleGuaranteedUser();
       return;
     }
   }
 
   // We can just handle potential users normally, since if we handle the user we
   // already saw a decrement implying that we will treat this like a guaranteed
   // use.
-  if (!handlePotentialUser(I, SetFactory, AA))
+  if (!handlePotentialUser(I, AA))
     return;
   LLVM_DEBUG(llvm::dbgs() << "    Found Potential Use:\n        "
                           << getRCRoot());
@@ -585,9 +575,7 @@ bool TopDownRefCountState::valueCanBeDecrementedGivenLatticeState() const {
 
 /// If advance the state's sequence appropriately for a decrement. If we do
 /// advance return true. Otherwise return false.
-bool TopDownRefCountState::handleDecrement(
-    SILInstruction *PotentialDecrement,
-    ImmutablePointerSetFactory<SILInstruction> &SetFactory) {
+bool TopDownRefCountState::handleDecrement() {
   switch (LatState) {
   case LatticeState::Incremented:
     LatState = LatticeState::MightBeDecremented;
@@ -618,9 +606,7 @@ bool TopDownRefCountState::valueCanBeUsedGivenLatticeState() const {
 
 /// Given the current lattice state, if we have seen a use, advance the
 /// lattice state. Return true if we do so and false otherwise.
-bool TopDownRefCountState::handleUser(SILInstruction *PotentialUser,
-                                      SILValue RCIdentity,
-                                      AliasAnalysis *AA) {
+bool TopDownRefCountState::handleUser() {
   assert(valueCanBeUsedGivenLatticeState() &&
          "Must be able to be used at this point of the lattice.");
 
@@ -657,10 +643,7 @@ valueCanBeGuaranteedUsedGivenLatticeState() const {
 
 /// Given the current lattice state, if we have seen a use, advance the
 /// lattice state. Return true if we do so and false otherwise.
-bool TopDownRefCountState::handleGuaranteedUser(
-    SILInstruction *PotentialGuaranteedUser,
-    SILValue RCIdentity, ImmutablePointerSetFactory<SILInstruction> &SetFactory,
-    AliasAnalysis *AA) {
+bool TopDownRefCountState::handleGuaranteedUser() {
   assert(valueCanBeGuaranteedUsedGivenLatticeState() &&
          "Must be able to be used at this point of the lattice.");
   // Advance the sequence...
@@ -694,13 +677,12 @@ bool TopDownRefCountState::isRefCountInstMatchedToTrackedInstruction(
   if (!Transition.matchingInst(RefCountInst))
     return false;
 
-  return handleRefCountInstMatch(RefCountInst);
+  return handleRefCountInstMatch();
 }
 
 /// We have a matching ref count inst. Return true if we advance the sequence
 /// and false otherwise.
-bool TopDownRefCountState::
-handleRefCountInstMatch(SILInstruction *RefCountInst) {
+bool TopDownRefCountState::handleRefCountInstMatch() {
   // Otherwise modify the state appropriately in preparation for removing the
   // increment, decrement pair.
   switch (LatState) {
@@ -762,8 +744,7 @@ bool TopDownRefCountState::merge(const TopDownRefCountState &Other) {
 // the value we are tracking. If so advance the state's sequence appropriately
 // and return true. Otherwise return false.
 bool TopDownRefCountState::handlePotentialGuaranteedUser(
-    SILInstruction *PotentialGuaranteedUser,
-    ImmutablePointerSetFactory<SILInstruction> &SetFactory, AliasAnalysis *AA) {
+    SILInstruction *PotentialGuaranteedUser, AliasAnalysis *AA) {
   // If we are not tracking a ref count, just return false.
   if (!isTrackingRefCount())
     return false;
@@ -789,16 +770,14 @@ bool TopDownRefCountState::handlePotentialGuaranteedUser(
    }
 
   // Otherwise, update our step given that we have a potential decrement.
-  return handleGuaranteedUser(PotentialGuaranteedUser, getRCRoot(),
-                              SetFactory, AA);
+   return handleGuaranteedUser();
 }
 
 // Check if PotentialDecrement can decrement the reference count associated with
 // the value we are tracking. If so advance the state's sequence appropriately
 // and return true. Otherwise return false.
 bool TopDownRefCountState::handlePotentialDecrement(
-    SILInstruction *PotentialDecrement,
-    ImmutablePointerSetFactory<SILInstruction> &SetFactory, AliasAnalysis *AA) {
+    SILInstruction *PotentialDecrement, AliasAnalysis *AA) {
   // If we are not tracking a ref count, just return false.
   if (!isTrackingRefCount())
     return false;
@@ -817,7 +796,7 @@ bool TopDownRefCountState::handlePotentialDecrement(
     return false;
 
   // Otherwise, update our state given the potential decrement.
-  return handleDecrement(PotentialDecrement, SetFactory);
+  return handleDecrement();
 }
 
 // Check if PotentialUser could be a use of the reference counted value that
@@ -840,12 +819,11 @@ bool TopDownRefCountState::handlePotentialUser(SILInstruction *PotentialUser,
   if (!mayHaveSymmetricInterference(PotentialUser, getRCRoot(), AA))
     return false;
 
-  return handleUser(PotentialUser, getRCRoot(), AA);
+  return handleUser();
 }
 
-void TopDownRefCountState::updateForSameLoopInst(
-    SILInstruction *I, 
-    ImmutablePointerSetFactory<SILInstruction> &SetFactory, AliasAnalysis *AA) {
+void TopDownRefCountState::updateForSameLoopInst(SILInstruction *I,
+                                                 AliasAnalysis *AA) {
   // If we are not tracking anything, bail.
   if (!isTrackingRefCount())
     return;
@@ -854,7 +832,7 @@ void TopDownRefCountState::updateForSameLoopInst(
   // instruction in a way that requires us to guarantee the lifetime of the
   // pointer up to this point. This has the effect of performing a use and a
   // decrement.
-  if (handlePotentialGuaranteedUser(I, SetFactory, AA)) {
+  if (handlePotentialGuaranteedUser(I, AA)) {
     LLVM_DEBUG(llvm::dbgs() << "    Found Potential Guaranteed Use:\n        "
                             << getRCRoot());
     return;
@@ -863,7 +841,7 @@ void TopDownRefCountState::updateForSameLoopInst(
   // Check if the instruction we are visiting could potentially decrement
   // the reference counted value we are tracking in a manner that could
   // cause us to change states. If we do change states continue...
-  if (handlePotentialDecrement(I, SetFactory, AA)) {
+  if (handlePotentialDecrement(I, AA)) {
     LLVM_DEBUG(llvm::dbgs() << "    Found Potential Decrement:\n        "
                             << getRCRoot());
     return;
@@ -877,9 +855,8 @@ void TopDownRefCountState::updateForSameLoopInst(
                           << getRCRoot());
 }
 
-void TopDownRefCountState::updateForDifferentLoopInst(
-    SILInstruction *I,
-    ImmutablePointerSetFactory<SILInstruction> &SetFactory, AliasAnalysis *AA) {
+void TopDownRefCountState::updateForDifferentLoopInst(SILInstruction *I,
+                                                      AliasAnalysis *AA) {
   // If we are not tracking anything, bail.
   if (!isTrackingRefCount())
     return;
@@ -888,7 +865,7 @@ void TopDownRefCountState::updateForDifferentLoopInst(
     if (mayGuaranteedUseValue(I, getRCRoot(), AA) ||
         mayDecrementRefCount(I, getRCRoot(), AA)) {
       LLVM_DEBUG(llvm::dbgs() << "    Found potential guaranteed use!\n");
-      handleGuaranteedUser(I, getRCRoot(), SetFactory, AA);
+      handleGuaranteedUser();
       return;
     }
   }