Optimizer: simplify load_borrow

* Remove dead `load_borrow` instructions (replaces the old peephole optimization in SILCombine)
* If the `load_borrow` is followed by a `copy_value`, combine both into a `load [copy]`

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -9,7 +9,7 @@
 swift_compiler_sources(Optimizer
   SimplifyAllocRefDynamic.swift
   SimplifyApply.swift
-  SimplifyBeginBorrow.swift
+  SimplifyBeginAndLoadBorrow.swift
   SimplifyBeginCOWMutation.swift
   SimplifyBranch.swift
   SimplifyBuiltin.swift

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBeginBorrow.swift renamed to SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBeginAndLoadBorrow.swift

@@ -1,4 +1,4 @@
-//===--- SimplifyBeginBorrow.swift ----------------------------------------===//
+//===--- SimplifyBeginAndLoadBorrow.swift ---------------------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -25,6 +25,45 @@ extension BeginBorrowInst : OnoneSimplifyable {
   }
 }
 
+extension LoadBorrowInst : Simplifyable, SILCombineSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+    if uses.ignoreDebugUses.ignoreUsers(ofType: EndBorrowInst.self).isEmpty {
+      context.erase(instructionIncludingAllUsers: self)
+      return
+    }
+
+    // If the load_borrow is followed by a copy_value, combine both into a `load [copy]`:
+    // ```
+    //   %1 = load_borrow %0
+    //   %2 = some_forwarding_instruction %1 // zero or more forwarding instructions
+    //   %3 = copy_value %2
+    //   end_borrow %1
+    // ```
+    // ->
+    // ```
+    //   %1 = load [copy] %0
+    //   %3 = some_forwarding_instruction %1 // zero or more forwarding instructions
+    // ```
+    //
+    tryCombineWithCopy(context)
+  }
+
+  private func tryCombineWithCopy(_ context: SimplifyContext) {
+    let forwardedValue = lookThroughSingleForwardingUses()
+    guard let singleUser = forwardedValue.uses.ignoreUsers(ofType: EndBorrowInst.self).singleUse?.instruction,
+          let copy = singleUser as? CopyValueInst,
+          copy.parentBlock == self.parentBlock else {
+      return
+    }
+    let builder = Builder(before: self, context)
+    let loadCopy = builder.createLoad(fromAddress: address, ownership: .copy)
+    let forwardedOwnedValue = replace(guaranteedValue: self, withOwnedValue: loadCopy, context)
+    copy.uses.replaceAll(with: forwardedOwnedValue, context)
+    context.erase(instruction: copy)
+    context.erase(instructionIncludingAllUsers: self)
+  }
+}
+
 private func tryReplaceBorrowWithOwnedOperand(beginBorrow: BeginBorrowInst, _ context: SimplifyContext) {
   // The last value of a (potentially empty) forwarding chain, beginning at the `begin_borrow`.
   let forwardedValue = beginBorrow.lookThroughSingleForwardingUses()
@@ -156,7 +195,7 @@ private extension ForwardingInstruction {
 }
 
 /// Replaces a guaranteed value with an owned value.
-/// 
+///
 /// If the `guaranteedValue`'s use is a ForwardingInstruction (or forwarding instruction chain),
 /// it is converted to an owned version of the forwarding instruction (or instruction chain).
 ///

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -108,6 +108,7 @@ private func registerSwiftPasses() {
   registerForSILCombine(RetainValueInst.self,      { run(RetainValueInst.self, $0) })
   registerForSILCombine(ReleaseValueInst.self,     { run(ReleaseValueInst.self, $0) })
   registerForSILCombine(LoadInst.self,             { run(LoadInst.self, $0) })
+  registerForSILCombine(LoadBorrowInst.self,       { run(LoadBorrowInst.self, $0) })
   registerForSILCombine(CopyValueInst.self,        { run(CopyValueInst.self, $0) })
   registerForSILCombine(DestroyValueInst.self,     { run(DestroyValueInst.self, $0) })
   registerForSILCombine(DestructureStructInst.self, { run(DestructureStructInst.self, $0) })

include/swift/SILOptimizer/PassManager/Passes.def

@@ -526,6 +526,7 @@ SWIFT_SILCOMBINE_PASS(StrongReleaseInst)
 SWIFT_SILCOMBINE_PASS(RetainValueInst)
 SWIFT_SILCOMBINE_PASS(ReleaseValueInst)
 SWIFT_SILCOMBINE_PASS(LoadInst)
+SWIFT_SILCOMBINE_PASS(LoadBorrowInst)
 SWIFT_SILCOMBINE_PASS(CopyValueInst)
 SWIFT_SILCOMBINE_PASS(DestroyValueInst)
 SWIFT_SILCOMBINE_PASS(DestructureStructInst)

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -252,7 +252,6 @@ class SILCombiner :
   // NOTE: The load optimized in this method is a load [trivial].
   SILInstruction *optimizeLoadFromStringLiteral(LoadInst *li);
 
-  SILInstruction *visitLoadBorrowInst(LoadBorrowInst *LI);
   SILInstruction *visitIndexAddrInst(IndexAddrInst *IA);
   bool optimizeStackAllocatedEnum(AllocStackInst *AS);
   SILInstruction *visitAllocStackInst(AllocStackInst *AS);

lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp

@@ -779,19 +779,6 @@ static SILValue isConstIndexAddr(SILValue val, unsigned &index) {
   return IA->getBase();
 }
 
-SILInstruction *SILCombiner::visitLoadBorrowInst(LoadBorrowInst *lbi) {
-  // If we have a load_borrow that only has non_debug end_borrow uses, delete
-  // it.
-  if (llvm::all_of(getNonDebugUses(lbi), [](Operand *use) {
-        return isa<EndBorrowInst>(use->getUser());
-      })) {
-    eraseInstIncludingUsers(lbi);
-    return nullptr;
-  }
-
-  return nullptr;
-}
-
 /// Optimize nested index_addr instructions:
 /// Example in SIL pseudo code:
 ///    %1 = index_addr %ptr, x

test/SILOptimizer/simplify_load_borrow.sil

@@ -0,0 +1,95 @@
+// RUN: %target-sil-opt %s -simplification -simplify-instruction=load_borrow | %FileCheck %s
+
+import Swift
+import Builtin
+
+class B { }
+
+class E : B {
+  @_hasStorage var i: Int
+}
+
+// CHECK-LABEL: sil [ossa] @load_borrow_and_copy :
+// CHECK:         %1 = load [copy] %0
+// CHECK:         %2 = begin_borrow %1
+// CHECK:         %3 = ref_element_addr %2, #E.i
+// CHECK:         %4 = load [trivial] %3
+// CHECK:         end_borrow %2
+// CHECK:         destroy_value %1 
+// CHECK:         return %4
+// CHEKCK       } // end sil function '@load_borrow_and_copy'
+sil [ossa] @load_borrow_and_copy : $@convention(thin) (@inout E) -> Int {
+bb0(%0 : $*E):
+  %1 = load_borrow %0
+  %2 = copy_value %1
+  end_borrow %1
+  %4 = begin_borrow %2
+  %5 = ref_element_addr %4, #E.i
+  %6 = load [trivial] %5
+  end_borrow %4
+  destroy_value %2
+  return %6
+}
+
+// CHECK-LABEL: sil [ossa] @load_borrow_and_copy_forwarding :
+// CHECK:         %1 = load [copy] %0
+// CHECK:         %2 = unchecked_ref_cast %1 to $E
+// CHECK:         %3 = begin_borrow %2
+// CHECK:         %4 = ref_element_addr %3, #E.i
+// CHECK:         %5 = load [trivial] %4
+// CHECK:         end_borrow %3
+// CHECK:         destroy_value %2 
+// CHECK:         return %5
+// CHEKCK       } // end sil function '@load_borrow_and_copy_forwarding'
+sil [ossa] @load_borrow_and_copy_forwarding : $@convention(thin) (@inout B) -> Int {
+bb0(%0 : $*B):
+  %1 = load_borrow %0
+  %2 = unchecked_ref_cast %1 to $E
+  %3 = copy_value %2
+  end_borrow %1
+  %5 = begin_borrow %3
+  %6 = ref_element_addr %5, #E.i
+  %7 = load [trivial] %6
+  end_borrow %5
+  destroy_value %3
+  return %7
+}
+
+// CHECK-LABEL: sil [ossa] @load_borrow_and_copy_different_block :
+// CHECK:         %1 = load_borrow %0
+// CHECK:         %3 = copy_value %1
+// CHEKCK       } // end sil function '@load_borrow_and_copy_different_block'
+sil [ossa] @load_borrow_and_copy_different_block : $@convention(thin) (@inout E) -> () {
+bb0(%0 : $*E):
+  %1 = load_borrow %0
+  cond_br undef, bb1, bb2
+bb1:
+  %3 = copy_value %1
+  %4 = begin_borrow %3
+  %5 = ref_element_addr %4, #E.i
+  %6 = load [trivial] %5
+  fix_lifetime %6
+  end_borrow %4
+  destroy_value %3
+  br bb3
+bb2:
+  br bb3
+bb3:
+  end_borrow %1
+  %r = tuple ()
+  return %r
+}
+
+// CHECK-LABEL: sil [ossa] @dead_load_borrow :
+// CHECK-NOT:     load_borrow
+// CHECK:         %1 = tuple ()
+// CHECK:         return %1
+// CHEKCK       } // end sil function '@dead_load_borrow'
+sil [ossa] @dead_load_borrow : $@convention(thin) (@inout B) -> () {
+bb0(%0 : $*B):
+  %1 = load_borrow %0
+  debug_value %1, var, name "x"
+  end_borrow %1
+  %4 = tuple ()
+  return %4
+}