Merge pull request swiftlang#34787 from gottesmm/pr-aa2767f26b092e40ae7b044c1ac4bf2c1f02e1c8

[ownership] Teach CanonicalizeInstruction how to eliminate trivial copies/borrows.

Author: gottesmm

lib/SILOptimizer/Utils/CanonicalizeInstruction.cpp

@@ -383,6 +383,65 @@ broadenSingleElementStores(StoreInst *storeInst,
   return killInstruction(storeInst, nextII, pass);
 }
 
+//===----------------------------------------------------------------------===//
+//                            Simple ARC Peepholes
+//===----------------------------------------------------------------------===//
+
+static SILBasicBlock::iterator
+eliminateSimpleCopies(CopyValueInst *cvi, CanonicalizeInstruction &pass) {
+  auto next = std::next(cvi->getIterator());
+
+  // Eliminate copies that only have destroy_value uses.
+  SmallVector<DestroyValueInst *, 8> destroys;
+  for (auto *use : getNonDebugUses(cvi)) {
+    if (auto *dvi = dyn_cast<DestroyValueInst>(use->getUser())) {
+      destroys.push_back(dvi);
+      continue;
+    }
+    return next;
+  }
+
+  while (!destroys.empty()) {
+    next = killInstruction(destroys.pop_back_val(), next, pass);
+  }
+
+  next = killInstAndIncidentalUses(cvi, next, pass);
+  return next;
+}
+
+static SILBasicBlock::iterator
+eliminateSimpleBorrows(BeginBorrowInst *bbi, CanonicalizeInstruction &pass) {
+  auto next = std::next(bbi->getIterator());
+
+  // We know that our borrow is completely within the lifetime of its base value
+  // if the borrow is never reborrowed. We check for reborrows and do not
+  // optimize such cases. Otherwise, we can eliminate our borrow and instead use
+  // our operand.
+  auto base = bbi->getOperand();
+  auto baseOwnership = base.getOwnershipKind();
+  SmallVector<EndBorrowInst *, 8> endBorrows;
+  for (auto *use : getNonDebugUses(bbi)) {
+    if (auto *ebi = dyn_cast<EndBorrowInst>(use->getUser())) {
+      endBorrows.push_back(ebi);
+      continue;
+    }
+
+    // Otherwise, if we have a use that is non-lifetime ending and can accept
+    // our base ownership, continue.
+    if (!use->isLifetimeEnding() && use->canAcceptKind(baseOwnership))
+      continue;
+
+    return next;
+  }
+
+  while (!endBorrows.empty()) {
+    next = killInstruction(endBorrows.pop_back_val(), next, pass);
+  }
+  bbi->replaceAllUsesWith(base);
+  pass.notifyHasNewUsers(base);
+  return killInstruction(bbi, next, pass);
+}
+
 //===----------------------------------------------------------------------===//
 //                            Top-Level Entry Point
 //===----------------------------------------------------------------------===//
@@ -398,6 +457,12 @@ CanonicalizeInstruction::canonicalize(SILInstruction *inst) {
   if (auto *storeInst = dyn_cast<StoreInst>(inst))
     return broadenSingleElementStores(storeInst, *this);
 
+  if (auto *cvi = dyn_cast<CopyValueInst>(inst))
+    return eliminateSimpleCopies(cvi, *this);
+
+  if (auto *bbi = dyn_cast<BeginBorrowInst>(inst))
+    return eliminateSimpleBorrows(bbi, *this);
+
   // Skip ahead.
   return std::next(inst->getIterator());
 }

test/AutoDiff/SILOptimizer/activity_analysis.swift

@@ -347,31 +347,29 @@ func testArrayUninitializedIntrinsicNested(_ x: Float, _ y: Float) -> [Float] {
 // CHECK: [VARIED]   %11 = integer_literal $Builtin.Word, 1
 // CHECK: [ACTIVE]   %12 = index_addr %9 : $*Float, %11 : $Builtin.Word
 // CHECK: [NONE]   // function_ref _finalizeUninitializedArray<A>(_:)
-// CHECK: [ACTIVE]   %15 = apply %14<Float>(%7) : $@convention(thin) <τ_0_0> (@owned Array<τ_0_0>) -> @owned Array<τ_0_0>
+// CHECK: [ACTIVE]   [[ARRAY:%.*]] = apply %14<Float>(%7) : $@convention(thin) <τ_0_0> (@owned Array<τ_0_0>) -> @owned Array<τ_0_0>
 // CHECK: [USEFUL]   %17 = integer_literal $Builtin.Word, 2
 // CHECK: [NONE]   // function_ref _allocateUninitializedArray<A>(_:)
 // CHECK: [ACTIVE]   %19 = apply %18<Float>(%17) : $@convention(thin) <τ_0_0> (Builtin.Word) -> (@owned Array<τ_0_0>, Builtin.RawPointer)
 // CHECK: [ACTIVE] (**%20**, %21) = destructure_tuple %19 : $(Array<Float>, Builtin.RawPointer)
 // CHECK: [VARIED] (%20, **%21**) = destructure_tuple %19 : $(Array<Float>, Builtin.RawPointer)
 // CHECK: [ACTIVE]   %22 = pointer_to_address %21 : $Builtin.RawPointer to [strict] $*Float
-// CHECK: [ACTIVE]   %23 = begin_borrow %15 : $Array<Float>
-// CHECK: [USEFUL]   %24 = integer_literal $Builtin.IntLiteral, 0
-// CHECK: [USEFUL]   %25 = metatype $@thin Int.Type
+// CHECK: [USEFUL]   %23 = integer_literal $Builtin.IntLiteral, 0
+// CHECK: [USEFUL]   %24 = metatype $@thin Int.Type
 // CHECK: [NONE]   // function_ref Int.init(_builtinIntegerLiteral:)
-// CHECK: [USEFUL]   %27 = apply %26(%24, %25) : $@convention(method) (Builtin.IntLiteral, @thin Int.Type) -> Int
+// CHECK: [USEFUL]   %26 = apply %25(%23, %24) : $@convention(method) (Builtin.IntLiteral, @thin Int.Type) -> Int
 // CHECK: [NONE]   // function_ref Array.subscript.getter
-// CHECK: [NONE]   %29 = apply %28<Float>(%22, %27, %23) : $@convention(method) <τ_0_0> (Int, @guaranteed Array<τ_0_0>) -> @out τ_0_0
-// CHECK: [VARIED]   %30 = integer_literal $Builtin.Word, 1
-// CHECK: [ACTIVE]   %31 = index_addr %22 : $*Float, %30 : $Builtin.Word
-// CHECK: [ACTIVE]   %32 = begin_borrow %15 : $Array<Float>
-// CHECK: [USEFUL]   %33 = integer_literal $Builtin.IntLiteral, 1
-// CHECK: [USEFUL]   %34 = metatype $@thin Int.Type
+// CHECK: [NONE]   %28 = apply %27<Float>(%22, %26, %15) : $@convention(method) <τ_0_0> (Int, @guaranteed Array<τ_0_0>) -> @out τ_0_0
+// CHECK: [VARIED]   %29 = integer_literal $Builtin.Word, 1
+// CHECK: [ACTIVE]   %30 = index_addr %22 : $*Float, %29 : $Builtin.Word
+// CHECK: [USEFUL]   %31 = integer_literal $Builtin.IntLiteral, 1
+// CHECK: [USEFUL]   %32 = metatype $@thin Int.Type
 // CHECK: [NONE]   // function_ref Int.init(_builtinIntegerLiteral:)
-// CHECK: [USEFUL]   %36 = apply %35(%33, %34) : $@convention(method) (Builtin.IntLiteral, @thin Int.Type) -> Int
+// CHECK: [USEFUL]   %34 = apply %33(%31, %32) : $@convention(method) (Builtin.IntLiteral, @thin Int.Type) -> Int
 // CHECK: [NONE]   // function_ref Array.subscript.getter
-// CHECK: [NONE]   %38 = apply %37<Float>(%31, %36, %32) : $@convention(method) <τ_0_0> (Int, @guaranteed Array<τ_0_0>) -> @out τ_0_0
+// CHECK: [NONE]   %36 = apply %35<Float>(%30, %34, %15) : $@convention(method) <τ_0_0> (Int, @guaranteed Array<τ_0_0>) -> @out τ_0_0
 // CHECK: [NONE]   // function_ref _finalizeUninitializedArray<A>(_:)
-// CHECK: [ACTIVE]   %40 = apply %39<Float>(%20) : $@convention(thin) <τ_0_0> (@owned Array<τ_0_0>) -> @owned Array<τ_0_0>
+// CHECK: [ACTIVE]   %38 = apply %37<Float>(%20) : $@convention(thin) <τ_0_0> (@owned Array<τ_0_0>) -> @owned Array<τ_0_0>
 
 // TF-978: Test array literal initialized with `apply` indirect results.
 struct Wrapper<T: Differentiable>: Differentiable {
@@ -733,16 +731,13 @@ func testClassModifyAccessor(_ c: inout C) {
 // CHECK: [VARIED]   %4 = load [copy] %3 : $*C
 // CHECK: [ACTIVE]   %6 = begin_access [read] [static] %0 : $*C
 // CHECK: [VARIED]   %7 = load [copy] %6 : $*C
-// CHECK: [VARIED]   %9 = begin_borrow %7 : $C
-// CHECK: [VARIED]   %10 = class_method %9 : $C, #C.float!getter : (C) -> () -> Float, $@convention(method) (@guaranteed C) -> Float
-// CHECK: [VARIED]   %11 = apply %10(%9) : $@convention(method) (@guaranteed C) -> Float
-// CHECK: [VARIED]   %14 = begin_borrow %4 : $C
-// CHECK: [VARIED]   %15 = class_method %14 : $C, #C.float!modify : (C) -> () -> (), $@yield_once @convention(method) (@guaranteed C) -> @yields @inout Float
-// CHECK: [VARIED] (**%16**, %17) = begin_apply %15(%14) : $@yield_once @convention(method) (@guaranteed C) -> @yields @inout Float
-// CHECK: [VARIED] (%16, **%17**) = begin_apply %15(%14) : $@yield_once @convention(method) (@guaranteed C) -> @yields @inout Float
+// CHECK: [VARIED]   %9 = class_method %7 : $C, #C.float!getter : (C) -> () -> Float, $@convention(method) (@guaranteed C) -> Float
+// CHECK: [VARIED]   %10 = apply %9(%7) : $@convention(method) (@guaranteed C) -> Float
+// CHECK: [VARIED]   %12 = class_method %4 : $C, #C.float!modify : (C) -> () -> (), $@yield_once @convention(method) (@guaranteed C) -> @yields @inout Float
+// CHECK: [VARIED] (**%13**, %14) = begin_apply %12(%4) : $@yield_once @convention(method) (@guaranteed C) -> @yields @inout Float
+// CHECK: [VARIED] (%13, **%14**) = begin_apply %12(%4) : $@yield_once @convention(method) (@guaranteed C) -> @yields @inout Float
 // CHECK: [NONE]   // function_ref static Float.*= infix(_:_:)
-// CHECK: [NONE]   %19 = apply %18(%16, %11, %2) : $@convention(method) (@inout Float, Float, @thin Float.Type) -> ()
-// CHECK: [NONE]   %23 = tuple ()
+// CHECK: [NONE]   %16 = apply %15(%13, %10, %2) : $@convention(method) (@inout Float, Float, @thin Float.Type) -> ()
 
 //===----------------------------------------------------------------------===//
 // Enum differentiation

test/AutoDiff/SILOptimizer/differentiation_diagnostics.swift

@@ -714,7 +714,7 @@ func modify(_ s: Struct, _ x: Float) -> Float {
 func tupleArrayLiteralInitialization(_ x: Float, _ y: Float) -> Float {
   // `Array<(Float, Float)>` does not conform to `Differentiable`.
   let array = [(x * y, x * y)]
-  // expected-note @+1 {{cannot differentiate through a non-differentiable argument; do you want to use 'withoutDerivative(at:)'?}} {{10-10=withoutDerivative(at: }} {{15-15=)}}
+  // expected-note @-1 {{cannot differentiate through a non-differentiable argument; do you want to use 'withoutDerivative(at:)'?}} {{15-15=withoutDerivative(at: }} {{31-31=)}}
   return array[0].0
 }
 

test/IRGen/alloc_box.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -primary-file %s -emit-ir -o - | %FileCheck %s
+// RUN: %target-swift-frontend -Xllvm -sil-disable-pass=SILGenCleanup -primary-file %s -emit-ir -o - | %FileCheck %s
 
 func f() -> Bool? { return nil }
 

test/SILOptimizer/capturepromotion-wrong-lexicalscope.swift

@@ -19,12 +19,12 @@
 // CHECK:   destroy_value %7 : ${ var Int }, loc {{.*}}:33:11, scope 3
 // CHECK:   %13 = partial_apply [callee_guaranteed] %10(%11) : $@convention(thin) (Int) -> Int, loc {{.*}}:33:11, scope 3
 // CHECK:   debug_value %13 : $@callee_guaranteed () -> Int, let, name "f", loc {{.*}}:33:7, scope 3
-// CHECK:   %15 = begin_borrow %13 : $@callee_guaranteed () -> Int, loc {{.*}}:34:10, scope 3
-// CHECK:   %16 = copy_value %15 : $@callee_guaranteed () -> Int, loc {{.*}}:34:10, scope 3
-// CHECK:   end_borrow %15 : $@callee_guaranteed () -> Int
+// There used to be a begin_borrow here. We leave an emptyline here to preserve line numbers.
+// CHECK:   %15 = copy_value %13 : $@callee_guaranteed () -> Int, loc {{.*}}:34:10, scope 3
+// There used to be an end_borrow here. We leave an emptyline here to preserve line numbers.
 // CHECK:   destroy_value %13 : $@callee_guaranteed () -> Int, loc {{.*}}:35:1, scope 3
 // CHECK:   destroy_value %0 : ${ var Int }, loc {{.*}}:35:1, scope 3
-// CHECK:   return %16 : $@callee_guaranteed () -> Int, loc {{.*}}:34:3, scope 3
+// CHECK:   return %15 : $@callee_guaranteed () -> Int, loc {{.*}}:34:3, scope 3
 // CHECK: }
 
 

test/SILOptimizer/constantprop-wrongscope.swift

@@ -13,7 +13,7 @@
 // instructions surrounding it.
 
 // CHECK:   destroy_addr %7 : $*Any, loc {{.*}}:22:19, scope 2
-// CHECK:   dealloc_stack %13 : $*Optional<Any>, loc {{.*}}:22:23, scope 2
+// CHECK:   dealloc_stack %12 : $*Optional<Any>, loc {{.*}}:22:23, scope 2
 // CHECK:   dealloc_stack %7 : $*Any, loc {{.*}}:22:23, scope 2
 // CHECK:   dealloc_stack %6 : $*A, loc {{.*}}:22:7, scope 2
 

test/SILOptimizer/silgen_cleanup.sil

@@ -4,8 +4,27 @@ import Builtin
 
 sil_stage raw
 
-import Swift
-import SwiftShims
+class Klass {}
+class SubKlass : Klass {}
+
+sil @use_klass_guaranteed : $@convention(thin) (@guaranteed Klass) -> ()
+sil @use_klass_owned : $@convention(thin) (@owned Klass) -> ()
+sil @use_klass_unowned : $@convention(thin) (Klass) -> ()
+
+enum FakeOptional<T> {
+case none
+case some(T)
+}
+
+sil @use_fakeoptional_klass_guaranteed : $@convention(thin) (@guaranteed FakeOptional<Klass>) -> ()
+
+struct Int {
+  var _value : Builtin.Int32
+}
+
+struct UInt8 {
+  var _value : Builtin.Int8
+}
 
 // CHECK-LABEL: sil [ossa] @struct_extract_load_to_load_struct_element_addr
 // CHECK: bb0([[IN:%[0-9]+]] : $*UInt8):
@@ -91,30 +110,26 @@ bb0(%0 : $*(Builtin.Int8, Builtin.Int8)):
 
 struct X1 {
   @_hasStorage @_hasInitialValue let a: Int { get }
-  @_hasStorage @_hasInitialValue var obj1: AnyObject { get set }
-  @_hasStorage @_hasInitialValue var obj2: AnyObject { get set }
-  init(a: Int, obj1: AnyObject, obj2: AnyObject)
+  @_hasStorage @_hasInitialValue var obj1: Builtin.NativeObject { get set }
+  @_hasStorage @_hasInitialValue var obj2: Builtin.NativeObject { get set }
+  init(a: Int, obj1: Builtin.NativeObject, obj2: Builtin.NativeObject)
 }
 
-// CHECK-LABEL: sil private [ossa] @testLoadNontrivial : $@convention(thin) (@inout_aliasable X1) -> (Int, @owned AnyObject, @owned AnyObject) {
+// CHECK-LABEL: sil private [ossa] @testLoadNontrivial : $@convention(thin) (@inout_aliasable X1) -> (Int, @owned Builtin.NativeObject, @owned Builtin.NativeObject) {
 // CHECK-LABEL: bb0(%0 : $*X1):
 // CHECK: [[ACCESS:%.*]] = begin_access [read] [unknown] %0 : $*X1
 // CHECK: [[AA:%.*]] = struct_element_addr [[ACCESS]] : $*X1, #X1.a
 // CHECK: load [trivial] [[AA]] : $*Int
 // CHECK: [[OA1:%.*]] = struct_element_addr [[ACCESS]] : $*X1, #X1.obj1
-// CHECK: [[OV1:%.*]] = load [copy] [[OA1]] : $*AnyObject
+// CHECK: [[OV1:%.*]] = load [copy] [[OA1]] : $*Builtin.NativeObject
 // CHECK: [[OA2:%.*]] = struct_element_addr [[ACCESS]] : $*X1, #X1.obj2
-// CHECK: [[OV2:%.*]] = load [copy] [[OA2]] : $*AnyObject
+// CHECK: [[OV2:%.*]] = load [copy] [[OA2]] : $*Builtin.NativeObject
 // CHECK: end_access [[ACCESS]] : $*X1
-// CHECK: [[B1:%.*]] = begin_borrow [[OV1]] : $AnyObject
-// CHECK: copy_value [[B1]] : $AnyObject
-// CHECK: end_borrow [[B1]] : $AnyObject
-// CHECK: [[B2:%.*]] = begin_borrow [[OV2]] : $AnyObject
-// CHECK: copy_value [[B2]] : $AnyObject
-// CHECK: end_borrow [[B2]] : $AnyObject
+// CHECK: copy_value [[OV1]] : $Builtin.NativeObject
+// CHECK: copy_value [[OV2]] : $Builtin.NativeObject
 // CHECK: return
 // CHECK-LABEL: } // end sil function 'testLoadNontrivial'
-sil private [ossa] @testLoadNontrivial : $@convention(thin) (@inout_aliasable X1) -> (Int, @owned AnyObject, @owned AnyObject) {
+sil private [ossa] @testLoadNontrivial : $@convention(thin) (@inout_aliasable X1) -> (Int, @owned Builtin.NativeObject, @owned Builtin.NativeObject) {
 bb0(%0 : $*X1):
   %access = begin_access [read] [unknown] %0 : $*X1
   %load = load [copy] %access : $*X1
@@ -126,44 +141,44 @@ bb0(%0 : $*X1):
 
   %borrow1 = begin_borrow %load : $X1
   %o1 = struct_extract %borrow1 : $X1, #X1.obj1
-  %copy1 = copy_value %o1 : $AnyObject
+  %copy1 = copy_value %o1 : $Builtin.NativeObject
   end_borrow %borrow1 : $X1
 
   %borrow2 = begin_borrow %load : $X1
   %o2 = struct_extract %borrow2 : $X1, #X1.obj2
-  %copy2 = copy_value %o2 : $AnyObject
+  %copy2 = copy_value %o2 : $Builtin.NativeObject
   end_borrow %borrow2 : $X1
 
   destroy_value %load : $X1
 
-  %result = tuple (%a : $Int, %copy1 : $AnyObject, %copy2 : $AnyObject)
-  return %result : $(Int, AnyObject, AnyObject)
+  %result = tuple (%a : $Int, %copy1 : $Builtin.NativeObject, %copy2 : $Builtin.NativeObject)
+  return %result : $(Int, Builtin.NativeObject, Builtin.NativeObject)
 }
 
 struct X2 {
-  @_hasStorage @_hasInitialValue var obj: AnyObject { get set }
+  @_hasStorage @_hasInitialValue var obj: Builtin.NativeObject { get set }
 }
 
 struct X3 {
   @_hasStorage @_hasInitialValue var x2: X2 { get set }
 }
 
-// CHECK-LABEL: sil private [ossa] @testStoreNontrivial : $@convention(thin) (@inout X3, @guaranteed AnyObject) -> () {
-// CHECK-LABEL: bb0(%0 : $*X3, %1 : @guaranteed $AnyObject):
-// CHECK: [[CP:%.*]] = copy_value %1 : $AnyObject
+// CHECK-LABEL: sil private [ossa] @testStoreNontrivial : $@convention(thin) (@inout X3, @guaranteed Builtin.NativeObject) -> () {
+// CHECK: bb0(%0 : $*X3, %1 : @guaranteed $Builtin.NativeObject):
+// CHECK: [[CP:%.*]] = copy_value %1 : $Builtin.NativeObject
 // CHECK: [[ACCESS:%.*]] = begin_access [modify] [unknown] %0 : $*X3
-// CHECK: [[X2:%.*]] = struct $X2 ([[CP]] : $AnyObject)
+// CHECK: [[X2:%.*]] = struct $X2 ([[CP]] : $Builtin.NativeObject)
 // CHECK: [[X3:%.*]] = struct $X3 ([[X2]] : $X2)
 // CHECK: store [[X3]] to [assign] [[ACCESS]] : $*X3
 // CHECK: end_access [[ACCESS]] : $*X3
-// CHECK-LABEL: } // end sil function 'testStoreNontrivial'
-sil private [ossa] @testStoreNontrivial : $@convention(thin) (@inout X3, @guaranteed AnyObject) -> () {
-bb0(%0 : $*X3, %1 : @guaranteed $AnyObject):
-  %4 = copy_value %1 : $AnyObject
+// CHECK: } // end sil function 'testStoreNontrivial'
+sil private [ossa] @testStoreNontrivial : $@convention(thin) (@inout X3, @guaranteed Builtin.NativeObject) -> () {
+bb0(%0 : $*X3, %1 : @guaranteed $Builtin.NativeObject):
+  %4 = copy_value %1 : $Builtin.NativeObject
   %5 = begin_access [modify] [unknown] %0 : $*X3
   %6 = struct_element_addr %5 : $*X3, #X3.x2
   %7 = struct_element_addr %6 : $*X2, #X2.obj
-  store %4 to [assign] %7 : $*AnyObject
+  store %4 to [assign] %7 : $*Builtin.NativeObject
   end_access %5 : $*X3
   %12 = tuple ()
   return %12 : $()