- remove the not needed transitive use visitors

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Utilities/BorrowUtils.swift

@@ -366,13 +366,15 @@ enum BeginBorrowValue {
 
   /// The EndBorrows, reborrows (phis), and consumes (of closures)
   /// that end the local borrow scope. Empty if hasLocalScope is false.
-  var scopeEndingOperands: LazyFilterSequence<TransitiveBorrowedFromUses> {
+  var scopeEndingOperands: LazyFilterSequence<UseList> {
     switch self {
     case let .beginApply(value):
       return (value.definingInstruction
-                as! BeginApplyInst).token.transitiveBorrowedFromUses.endingLifetime
+                as! BeginApplyInst).token.uses.endingLifetime
+    case let .reborrow(phi):
+      return phi.value.lookThroughBorrowedFromUser.uses.endingLifetime
     default:
-      return value.transitiveBorrowedFromUses.endingLifetime
+      return value.uses.endingLifetime
     }
   }
 }
@@ -384,44 +386,6 @@ extension Value {
     }
     return self
   }
-
-  /// Get uses by looking transitively through forwarding (only operand 0) borrowed-from instructions.
-  var transitiveBorrowedFromUses: TransitiveBorrowedFromUses {
-    TransitiveBorrowedFromUses(of: self)
-  }
-}
-
-struct TransitiveBorrowedFromUses : CollectionLikeSequence, IteratorProtocol {
-  private var currentUse: Operand?
-
-  public mutating func next() -> Operand? {
-    if let use = currentUse {
-      currentUse = Self.nextValidUse(use.nextUse, of: use.value)
-      return use
-    }
-    return nil
-  }
-
-  init(of value: Value) {
-    precondition(!(value is BorrowedFromInst), "Can't get TransitiveBorrowedFromUses from \(value)")
-    currentUse = Self.nextValidUse(value.uses.first, of: value)
-  }
-
-  private static func nextValidUse(_ use: Operand?, of value: Value) -> Operand? {
-    if let use = use {
-      // Walk down and look through a borrowed-from user.
-      if let bfiUser = use.forwardingBorrowedFromUser {
-        return nextValidUse(bfiUser.uses.first, of: bfiUser)
-      }
-      return use
-    }
-    // No more uses in the current use-list: Walk up and see if any borrowed-from further up in the def-use
-    // chain contains more uses.
-    if let bfiDef = value as? BorrowedFromInst {
-      return nextValidUse(bfiDef.operands[0].nextUse, of: bfiDef.operands[0].value)
-    }
-    return nil
-  }
 }
 
 /// Find the borrow introducers for `value`. This gives you a set of
@@ -605,7 +569,7 @@ let borrowIntroducersTest = FunctionTest("borrow_introducers") {
   defer {
     introducers.deinitialize()
   }
-  gatherBorrowIntroducers(for: lookThroughBorrowedFromUser(of: value), in: &introducers, context)
+  gatherBorrowIntroducers(for: value.lookThroughBorrowedFromUser, in: &introducers, context)
   introducers.forEach { print($0) }
 }
 
@@ -618,25 +582,18 @@ let enclosingValuesTest = FunctionTest("enclosing_values") {
   defer {
     enclosing.deinitialize()
   }
-  gatherEnclosingValues(for: lookThroughBorrowedFromUser(of: value), in: &enclosing, context)
+  gatherEnclosingValues(for: value.lookThroughBorrowedFromUser, in: &enclosing, context)
   enclosing.forEach { print($0) }
 }
 
-let transitiveBorrowedFromUsesTest = FunctionTest("transitive_borrowed_from_uses") {
-  function, arguments, context in
-  let value = arguments.takeValue()
-  print("Transitive borrowed uses for: \(value)")
-  for use in value.transitiveBorrowedFromUses.map({"\($0)"}).sorted() {
-    print(use)
-  }
-}
-
-private func lookThroughBorrowedFromUser(of value: Value) -> Value {
-  for use in value.uses {
-    if let bfi = use.forwardingBorrowedFromUser {
-      return bfi
+extension Value {
+  var lookThroughBorrowedFromUser: Value {
+    for use in uses {
+      if let bfi = use.forwardingBorrowedFromUser {
+        return bfi
+      }
     }
+    return self
   }
-  return value
 }
 

SwiftCompilerSources/Sources/Optimizer/Utilities/OwnershipLiveness.swift

@@ -56,7 +56,7 @@ func computeLinearLiveness(for definingValue: Value, _ context: Context)
   var range = InstructionRange(for: definingValue, context)
 
   // Compute liveness.
-  definingValue.transitiveBorrowedFromUses.endingLifetime.forEach {
+  definingValue.lookThroughBorrowedFromUser.uses.endingLifetime.forEach {
     range.insert($0.instruction)
   }
   return range
@@ -661,7 +661,7 @@ extension InteriorUseWalker: AddressUseVisitor {
       if handleInner(borrowed: load) == .abortWalk {
         return .abortWalk
       }
-      return load.transitiveBorrowedFromUses.endingLifetime.walk {
+      return load.uses.endingLifetime.walk {
         useVisitor($0)
       }
     default:

SwiftCompilerSources/Sources/Optimizer/Utilities/Test.swift

@@ -164,7 +164,6 @@ public func registerOptimizerTests() {
     lifetimeDependenceUseTest,
     linearLivenessTest,
     parseTestSpecificationTest,
-    transitiveBorrowedFromUsesTest,
     variableIntroducerTest
   )
 

include/swift/SIL/OwnershipUtils.h

@@ -91,9 +91,8 @@ inline bool isForwardingConsume(SILValue value) {
 //===----------------------------------------------------------------------===//
 
 BorrowedFromInst *getBorrowedFromUser(SILValue v);
-SILValue lookThroughSingleBorrowedFromUser(SILValue v);
+SILValue lookThroughBorrowedFromUser(SILValue v);
 SILValue lookThroughBorrowedFromDef(SILValue v);
-void getTransitiveConsumingUses(SILValue v, llvm::SmallVectorImpl<Operand *> &results);
 
 /// Whether the specified OSSA-lifetime introducer has a pointer escape.
 ///

lib/SIL/Utils/OwnershipUtils.cpp

@@ -214,7 +214,7 @@ BorrowedFromInst *swift::getBorrowedFromUser(SILValue v) {
   return nullptr;
 }
 
-SILValue swift::lookThroughSingleBorrowedFromUser(SILValue v) {
+SILValue swift::lookThroughBorrowedFromUser(SILValue v) {
   if (BorrowedFromInst *bfi = getBorrowedFromUser(v))
     return bfi;
   return v;
@@ -227,18 +227,6 @@ SILValue swift::lookThroughBorrowedFromDef(SILValue v) {
   return v;
 }
 
-void swift::getTransitiveConsumingUses(SILValue v, llvm::SmallVectorImpl<Operand *> &results) {
-  for (Operand *use : v->getUses()) {
-    if (use->isLifetimeEnding()) {
-      results.push_back(use);
-    } else if (auto *bfi = dyn_cast<BorrowedFromInst>(use->getUser())) {
-      if (use->getOperandNumber() == 0) {
-        getTransitiveConsumingUses(bfi, results);
-      }
-    }
-  }
-}
-
 //===----------------------------------------------------------------------===//
 //                 Guaranteed Use-Point (Lifetime) Discovery
 //===----------------------------------------------------------------------===//
@@ -943,18 +931,17 @@ bool BorrowedValue::visitLocalScopeEndingUses(
     llvm_unreachable("Using invalid case?!");
   case BorrowedValueKind::SILFunctionArgument:
     llvm_unreachable("Should only call this with a local scope");
-  case BorrowedValueKind::Phi:
   case BorrowedValueKind::LoadBorrow:
-  case BorrowedValueKind::BeginBorrow: {
-    llvm::SmallVector<Operand *, 16> consumingUses;
-    getTransitiveConsumingUses(v, consumingUses);
-    for (Operand *use : consumingUses) {
-      if (!visitor(use))
-        return false;
+  case BorrowedValueKind::BeginBorrow:
+  case BorrowedValueKind::Phi:
+    for (auto *use : lookThroughBorrowedFromUser(value)->getUses()) {
+      if (use->isLifetimeEnding()) {
+        if (!visitor(use))
+          return false;
+      }
     }
     return true;
   }
-  }
   llvm_unreachable("Covered switch isn't covered?!");
 }
 
@@ -2298,9 +2285,7 @@ void swift::visitTransitiveEndBorrows(
 
   while (!worklist.empty()) {
     auto val = worklist.pop();
-    llvm::SmallVector<Operand *, 16> consumingUses;
-    getTransitiveConsumingUses(val, consumingUses);
-    for (auto *consumingUse : consumingUses) {
+    for (auto *consumingUse : lookThroughBorrowedFromUser(val)->getConsumingUses()) {
       auto *consumingUser = consumingUse->getUser();
       if (auto *branch = dyn_cast<BranchInst>(consumingUser)) {
         auto *succBlock = branch->getSingleSuccessorBlock();

lib/SIL/Verifier/GuaranteedPhiVerifier.cpp

@@ -28,14 +28,12 @@ bool GuaranteedPhiVerifier::verifyDependentPhiLifetime(SILPhiArgument *phi,
   dependentPhiToBaseValueMap[phi].insert(baseValue);
 
   // Now, verify whether phi's lifetime is within baseValue's lifetime
-  SmallVector<Operand *, 4> baseValConsumingUses;
-  getTransitiveConsumingUses(baseValue, baseValConsumingUses);
+  SmallVector<Operand *, 4> baseValConsumingUses(lookThroughBorrowedFromUser(baseValue)->getConsumingUses());
   // If the baseValue has no consuming uses, there is nothing more to verify
   if (baseValConsumingUses.empty())
     return false;
 
-  SmallVector<Operand *, 4> phiUses;
-  getTransitiveConsumingUses(phi, phiUses);
+  SmallVector<Operand *, 4> phiUses(lookThroughBorrowedFromUser(phi)->getUses());
   LinearLifetimeChecker checker(deadEndBlocks);
   // newErrorBuilder is consumed at the end of the checkValue function.
   // Copy initial state from errorBuilder everytime

lib/SILOptimizer/Transforms/ConditionForwarding.cpp

@@ -164,7 +164,7 @@ bool ConditionForwarding::tryOptimize(SwitchEnumInst *SEI) {
   if (!Arg)
     return false;
 
-  SILValue argValue = lookThroughSingleBorrowedFromUser(Arg);
+  SILValue argValue = lookThroughBorrowedFromUser(Arg);
 
   // The switch_enum must be the only use of the Enum, except it may be used in
   // SEI's successors.