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]`

Also, run the simplification of `begin_borrow` in SILCombine by adding it as SILCombine-pass.

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
 //
@@ -12,7 +12,7 @@
 
 import SIL
 
-extension BeginBorrowInst : OnoneSimplifyable {
+extension BeginBorrowInst : OnoneSimplifyable, SILCombineSimplifyable {
   func simplify(_ context: SimplifyContext) {
     if borrowedValue.ownership == .owned,
        // We need to keep lexical lifetimes in place.
@@ -21,7 +21,52 @@ extension BeginBorrowInst : OnoneSimplifyable {
        !findPointerEscapingUse(of: borrowedValue)
     {
       tryReplaceBorrowWithOwnedOperand(beginBorrow: self, context)
+
+    } else if let thin2thickFn = borrowedValue as? ThinToThickFunctionInst,
+              uses.filterUsers(ofType: BranchInst.self).isEmpty
+    {
+      uses.ignoreUsers(ofType: EndBorrowInst.self).replaceAll(with: thin2thickFn, context)
+      context.erase(instructionIncludingAllUsers: self)
+    }
+  }
+}
+
+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)
   }
 }
 
@@ -156,7 +201,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

@@ -100,13 +100,15 @@ private func registerSwiftPasses() {
   registerPass(autodiffClosureSpecialization, { autodiffClosureSpecialization.run($0) })
 
   // Instruction passes
+  registerForSILCombine(BeginBorrowInst.self,      { run(BeginBorrowInst.self, $0) })
   registerForSILCombine(BeginCOWMutationInst.self, { run(BeginCOWMutationInst.self, $0) })
   registerForSILCombine(GlobalValueInst.self,      { run(GlobalValueInst.self, $0) })
   registerForSILCombine(StrongRetainInst.self,     { run(StrongRetainInst.self, $0) })
   registerForSILCombine(StrongReleaseInst.self,    { run(StrongReleaseInst.self, $0) })
   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

@@ -516,6 +516,7 @@ PASS(PruneVTables, "prune-vtables",
      "Mark class methods that do not require vtable dispatch")
 PASS_RANGE(AllPasses, AliasInfoDumper, PruneVTables)
 
+SWIFT_SILCOMBINE_PASS(BeginBorrowInst)
 SWIFT_SILCOMBINE_PASS(BeginCOWMutationInst)
 SWIFT_SILCOMBINE_PASS(ClassifyBridgeObjectInst)
 SWIFT_SILCOMBINE_PASS(GlobalValueInst)
@@ -524,6 +525,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
+}