[ComputeSideEffects] Track deinit-barrier-ness.

Functions "are deinit barriers" (more pedantically, applies of functions
are deinit barriers) if any of their instructions are deinit barriers.
During side-effect analysis, when walking a function's instructions for
other global effects, also check for the deinit-barrier effect.  If an
instruction is found to be a deinit barrier, mark the function's global
effects accordingly.

Add SILFunction::isDeinitBarrier to conveniently access the effects
computed during ComputeSideEffects.

Update the isBarrierApply predicate to iterate over the list of callees,
if complete, to check whether any is a deinit barrier.  If none is, then
the apply is not a deinit barrier.

Author: nate-chandler

SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift

@@ -54,10 +54,19 @@ public struct CalleeAnalysis {
   }
 }
 
+extension FullApplySite {
+  fileprivate func isBarrier(_ analysis: CalleeAnalysis) -> Bool {
+    guard let callees = analysis.getCallees(callee: callee) else {
+      return true
+    }
+    return callees.contains { $0.isDeinitBarrier }
+  }
+}
+
 extension Instruction {
   public final func maySynchronize(_ analysis: CalleeAnalysis) -> Bool {
     if let site = self as? FullApplySite {
-      return true
+      return site.isBarrier(analysis)
     }
     return maySynchronizeNotConsideringSideEffects
   }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -88,6 +88,7 @@ private struct CollectedEffects {
   }
 
   mutating func addInstructionEffects(_ inst: Instruction) {
+    var checkedIfDeinitBarrier = false
     switch inst {
     case is CopyValueInst, is RetainValueInst, is StrongRetainInst:
       addEffects(.copy, to: inst.operands[0].value, fromInitialPath: SmallProjectionPath(.anyValueFields))
@@ -131,12 +132,14 @@ private struct CollectedEffects {
         addDestroyEffects(of: calleeValue)
       }
       handleApply(apply)
+      checkedIfDeinitBarrier = true
 
     case let pa as PartialApplyInst:
       if pa.canBeAppliedInFunction(context) {
         // Only if the created closure can actually be called in the function
         // we have to consider side-effects within the closure.
         handleApply(pa)
+        checkedIfDeinitBarrier = true
       }
 
     case let fl as FixLifetimeInst:
@@ -178,6 +181,13 @@ private struct CollectedEffects {
         globalEffects.allocates = true
       }
     }
+    // If we didn't already, check whether the instruction could be a deinit
+    // barrier.  If it's an apply of some sort, that was already done in
+    // handleApply.
+    if !checkedIfDeinitBarrier,
+       inst.mayBeDeinitBarrierNotConsideringSideEffects {
+      globalEffects.isDeinitBarrier = true
+    }
   }
 
   mutating func addEffectsForEcapingArgument(argument: FunctionArgument) {

SwiftCompilerSources/Sources/SIL/Effects.swift

@@ -395,19 +395,29 @@ public struct SideEffects : CustomStringConvertible, NoReflectionChildren {
     /// are not observable form the outside and are therefore not considered.
     public var allocates: Bool
 
+    /// If true, destroys of lexical values may not be hoisted over applies of
+    /// the function.
+    ///
+    /// This is true when the function (or a callee, transitively) contains a
+    /// deinit barrier instruction.
+    public var isDeinitBarrier: Bool
+
     /// When called with default arguments, it creates an "effect-free" GlobalEffects.
     public init(memory: Memory = Memory(read: false, write: false),
                 ownership: Ownership = Ownership(copy: false, destroy: false),
-                allocates: Bool = false) {
+                allocates: Bool = false,
+                isDeinitBarrier: Bool = false) {
       self.memory = memory
       self.ownership = ownership
       self.allocates = allocates
+      self.isDeinitBarrier = isDeinitBarrier
     }
 
     public mutating func merge(with other: GlobalEffects) {
       memory.merge(with: other.memory)
       ownership.merge(with: other.ownership)
       allocates = allocates || other.allocates
+      isDeinitBarrier = isDeinitBarrier || other.isDeinitBarrier
     }
 
     /// Removes effects, which cannot occur for an `argument` value with a given `convention`.
@@ -444,12 +454,13 @@ public struct SideEffects : CustomStringConvertible, NoReflectionChildren {
     }
 
     public static var worstEffects: GlobalEffects {
-      GlobalEffects(memory: .worstEffects, ownership: .worstEffects, allocates: true)
+      GlobalEffects(memory: .worstEffects, ownership: .worstEffects, allocates: true, isDeinitBarrier: true)
     }
 
     public var description: String {
       var res: [String] = [memory.description, ownership.description].filter { !$0.isEmpty }
       if allocates { res += ["allocate"] }
+      if isDeinitBarrier { res += ["deinit_barrier"] }
       return res.joined(separator: ",")
     }
   }
@@ -652,6 +663,7 @@ extension StringParser {
       else if consume("copy")     { globalEffects.ownership.copy = true }
       else if consume("destroy")  { globalEffects.ownership.destroy = true }
       else if consume("allocate") { globalEffects.allocates = true }
+      else if consume("deinit_barrier") { globalEffects.isDeinitBarrier = true }
       else {
         break
       }

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -186,6 +186,10 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
     SILFunction_needsStackProtection(bridged) != 0
   }
 
+  public var isDeinitBarrier: Bool {
+    effects.sideEffects?.global.isDeinitBarrier ?? true
+  }
+
   // Only to be called by PassContext
   public func _modifyEffects(_ body: (inout FunctionEffects) -> ()) {
     body(&effects)

lib/SILOptimizer/Utils/InstOptUtils.cpp

@@ -21,6 +21,8 @@
 #include "swift/SIL/DynamicCasts.h"
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/SILArgument.h"
+#include "swift/SIL/SILBridging.h"
+#include "swift/SIL/SILBridgingUtils.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILDebugInfoExpression.h"
 #include "swift/SIL/SILModule.h"
@@ -30,7 +32,9 @@
 #include "swift/SILOptimizer/Analysis/ARCAnalysis.h"
 #include "swift/SILOptimizer/Analysis/Analysis.h"
 #include "swift/SILOptimizer/Analysis/ArraySemantic.h"
+#include "swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h"
 #include "swift/SILOptimizer/Analysis/DominanceAnalysis.h"
+#include "swift/SILOptimizer/OptimizerBridging.h"
 #include "swift/SILOptimizer/Utils/CFGOptUtils.h"
 #include "swift/SILOptimizer/Utils/DebugOptUtils.h"
 #include "swift/SILOptimizer/Utils/ValueLifetime.h"

test/SILOptimizer/cross-module-effects.swift

@@ -79,6 +79,10 @@ public func inlineWithEffects(_ x: X) -> Int {
   return internalCallee(x)
 }
 
+// CHECK-LE-MODULE-LABEL: sil [serialized] [noinline] [canonical] @loadWeakX_from : {{.*}} {
+// CHECK-LE-MODULE:       {{^[^[]}}
+// CHECK-LE-MODULE-LABEL: } // end sil function 'loadWeakX_from'
+
 // CHECK-FR-MODULE-LABEL: sil [serialized] [noinline] [canonical] @$s6Module12simpleInlineySiAA1XCF : $@convention(thin) (@guaranteed X) -> Int {
 // CHECK-FR-MODULE-NEXT:  [%0: noescape **, read c0.v**]
 // CHECK-FR-MODULE-NEXT:  [global: ]
@@ -91,6 +95,21 @@ public func simpleInline(_ x: X) -> Int {
   return x.i
 }
 
+public struct S {
+  public init(_ x: X) { self.x = x }
+  public weak var x: X?
+}
+
+// CHECK-FR-MODULE-LABEL: sil [serialized] [noinline] [canonical] @loadWeakX_from : {{.*}} {
+// CHECK-FR-MODULE:       [global: deinit_barrier]
+// CHECK-FR-MODULE-LABEL: } // end sil function 'loadWeakX_from'
+@inlinable
+@inline(never)
+@_silgen_name("loadWeakX_from")
+public func loadWeakX(from s: S) -> X? {
+  return s.x
+}
+
 #else
 
 import Module
@@ -176,6 +195,27 @@ public func callit5() -> Int {
 // CHECK-LE-MAIN-LABEL: sil public_external [noinline] @$s6Module12simpleInlineySiAA1XCF : $@convention(thin) (@guaranteed X) -> Int {
 // CHECK-LE-MAIN-NEXT:  {{^[^[]}}
 
+// CHECK-MAIN-LABEL: sil [noinline] @callit6 : {{.*}} {
+// CHECK-MAIN:         [[GET_X:%[^,]+]] = function_ref @$s6Module1XCACycfc
+// CHECK-MAIN:         [[X:%[^,]+]] = apply [[GET_X]]({{%[^,]+}})
+// CHECK-MAIN:         [[LOAD_WEAK_X_FROM:%[^,]+]] = function_ref @loadWeakX_from
+// CHECK-MAIN:         apply [[LOAD_WEAK_X_FROM]]({{%[^,]+}})
+// CHECK-MAIN:         strong_release [[X]]
+// CHECK-MAIN-LABEL: } // end sil function 'callit6'
+@_silgen_name("callit6")
+@inline(never)
+public func callit6() -> X? {
+  let x = X()
+  let s = S(x)
+  let out = loadWeakX(from: s)
+  return out
+}
+
+// CHECK-MAIN-LABEL: sil public_external [noinline] @loadWeakX_from : {{.*}} {
+// CHECK-FR-MAIN:       [global: deinit_barrier]
+// CHECK-LE-MAIN:       {{^[^[]}}
+// CHECK-MAIN-LABEL: } // end sil function 'loadWeakX_from'
+
 // CHECK-FR-MAIN-LABEL: sil @$s6Module14internalCalleeySiAA1XCF : $@convention(thin) (@guaranteed X) -> Int {
 // CHECK-FR-MAIN-NEXT:  [%0: noescape **, read c0.v**]
 // CHECK-FR-MAIN-NEXT:  [global: ]

test/SILOptimizer/side_effects.sil

@@ -129,7 +129,7 @@ bb0(%0 : $X, %1 : $*Int32):
 // CHECK-NEXT:  [%0: read v**]
 // CHECK-NEXT:  [%1: write v**]
 // CHECK-NEXT:  [%2: write c0.v**, destroy c*.v**]
-// CHECK-NEXT:  [global: read,write,copy,destroy,allocate]
+// CHECK-NEXT:  [global: read,write,copy,destroy,allocate,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil @partial_apply_load_store_to_args : $@convention(thin) (@inout Int32, @inout Int32, @guaranteed X) -> () {
 bb0(%0 : $*Int32, %1 : $*Int32, %2 : $X):
@@ -220,7 +220,7 @@ bb0(%0 : $X):
 }
 
 // CHECK-LABEL: sil @call_unknown
-// CHECK-NEXT:  [global: read,write,copy,destroy,allocate]
+// CHECK-NEXT:  [global: read,write,copy,destroy,allocate,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil @call_unknown : $@convention(thin) () -> () {
 bb0:
@@ -233,7 +233,7 @@ bb0:
 
 // CHECK-LABEL: sil @call_unknown_func_with_trivial_args
 // CHECK-NEXT:  [%0: read v**]
-// CHECK-NEXT:  [global: read,write,copy,destroy,allocate]
+// CHECK-NEXT:  [global: read,write,copy,destroy,allocate,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil @call_unknown_func_with_trivial_args : $@convention(thin) (@in Int32, Int32) -> () {
 bb0(%0 : $*Int32, %1 : $Int32):
@@ -293,7 +293,7 @@ bb0(%0 : $Builtin.NativeObject):
 sil @checkedaddr : $@convention(thin) (Builtin.NativeObject, X) -> () {
 // CHECK-NEXT:  [%0: read v**.c*.v**, write v**.c*.v**, copy v**.c*.v**, destroy v**.c*.v**]
 // CHECK-NEXT:  [%1: read c*.v**, write c*.v**, copy c*.v**, destroy c*.v**]
-// CHECK-NEXT:  [global: read,write,copy,destroy,allocate]
+// CHECK-NEXT:  [global: read,write,copy,destroy,allocate,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 bb0(%0 : $Builtin.NativeObject, %1 : $X):
   unconditional_checked_cast_addr Builtin.NativeObject in %0 : $Builtin.NativeObject to X in %1 : $X
@@ -450,7 +450,7 @@ bb0(%0 : $*X, %1 : @owned $X):
 // CHECK-LABEL: sil [ossa] @unknown_destructor_effects
 // CHECK-NEXT:  [%0: write v**, destroy v**]
 // CHECK-NEXT:  [%1: read c*.v**, write c*.v**, copy c*.v**, destroy c*.v**]
-// CHECK-NEXT:  [global: read,write,copy,destroy,allocate]
+// CHECK-NEXT:  [global: read,write,copy,destroy,allocate,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil [ossa] @unknown_destructor_effects : $@convention(thin) (@inout Y, @owned Y) -> () {
 bb0(%0 : $*Y, %1 : @owned $Y):
@@ -496,7 +496,7 @@ bb0(%0 : $*X, %1 : $*X):
 
 // CHECK-LABEL: sil [ossa] @destroy_value_effects1
 // CHECK-NEXT:  [%0: destroy v**.c*.v**]
-// CHECK-NEXT:  [global: read,write,copy,destroy,allocate]
+// CHECK-NEXT:  [global: read,write,copy,destroy,allocate,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil [ossa] @destroy_value_effects1 : $@convention(thin) (@owned SP) -> () {
 bb0(%0 : @owned $SP):
@@ -628,7 +628,7 @@ bb0(%0 : $*X):
 
 // CHECK-LABEL: sil [ossa] @pass_arg_to_unknown_function
 // CHECK-NEXT:  [%0: read s1.v**, write s1.v**, copy s1.v**, destroy s1.v**]
-// CHECK-NEXT:  [global: read,write,copy,destroy,allocate]
+// CHECK-NEXT:  [global: read,write,copy,destroy,allocate,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil [ossa] @pass_arg_to_unknown_function : $@convention(thin) (@inout TwoSPs) -> () {
 bb0(%0 : $*TwoSPs):
@@ -641,7 +641,7 @@ bb0(%0 : $*TwoSPs):
 
 // CHECK-LABEL: sil [ossa] @copy_addr_and_consume_by_unknown_func
 // CHECK-NEXT:  [%0: read v**, copy v**, destroy v**]
-// CHECK-NEXT:  [global: read,write,copy,destroy,allocate]
+// CHECK-NEXT:  [global: read,write,copy,destroy,allocate,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil [ossa] @copy_addr_and_consume_by_unknown_func : $@convention(thin) (@in X) -> () {
 bb0(%0 : $*X):
@@ -672,7 +672,7 @@ bb2:
 }
 
 // CHECK-LABEL: sil @call_readnone
-// CHECK-NEXT:  [global: copy]
+// CHECK-NEXT:  [global: copy,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil @call_readnone : $@convention(thin) () -> () {
 bb0:
@@ -683,7 +683,7 @@ bb0:
 }
 
 // CHECK-LABEL: sil @call_releasenone
-// CHECK-NEXT:  [global: read,write,copy,allocate]
+// CHECK-NEXT:  [global: read,write,copy,allocate,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil @call_releasenone : $@convention(thin) () -> () {
 bb0:
@@ -696,7 +696,7 @@ bb0:
 
 // CHECK-LABEL: sil @call_readonly_owned
 // CHECK-NEXT:  [%0: read c*.v**, copy c*.v**]
-// CHECK-NEXT:  [global: read,copy]
+// CHECK-NEXT:  [global: read,copy,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil @call_readonly_owned : $@convention(thin) (@owned X) -> () {
 bb0(%0 : $X):
@@ -708,7 +708,7 @@ bb0(%0 : $X):
 
 // CHECK-LABEL: sil [ossa] @call_readnone_owned
 // CHECK-NEXT:  [%0: copy c*.v**]
-// CHECK-NEXT:  [global: copy]
+// CHECK-NEXT:  [global: copy,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil [ossa] @call_readnone_owned : $@convention(thin) (@owned X) -> @owned X {
 bb0(%0 : @owned $X):
@@ -719,7 +719,7 @@ bb0(%0 : @owned $X):
 
 // CHECK-LABEL: sil @call_readonly_guaranteed
 // CHECK-NEXT:  [%0: read c*.v**, copy c*.v**]
-// CHECK-NEXT:  [global: read,copy]
+// CHECK-NEXT:  [global: read,copy,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil @call_readonly_guaranteed : $@convention(thin) (@guaranteed X) -> () {
 bb0(%0 : $X):
@@ -733,7 +733,7 @@ bb0(%0 : $X):
 // CHECK-NEXT:  [%0: write v**]
 // CHECK-NEXT:  [%1: read v**, copy v**]
 // CHECK-NEXT:  [%2: read v**, copy v**]
-// CHECK-NEXT:  [global: read,copy]
+// CHECK-NEXT:  [global: read,copy,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil @call_readonly_indirect_params : $@convention(thin) (@in_guaranteed X, @inout X) -> @out X {
 bb0(%0 : $*X, %1 : $*X, %2 : $*X):
@@ -747,7 +747,7 @@ bb0(%0 : $*X, %1 : $*X, %2 : $*X):
 // CHECK-NEXT:  [%0: write v**]
 // CHECK-NEXT:  [%1: read v**, copy v**]
 // CHECK-NEXT:  [%2: read v**, copy v**]
-// CHECK-NEXT:  [global: read,copy]
+// CHECK-NEXT:  [global: read,copy,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil @call_readnone_indirect_params : $@convention(thin) (@in_guaranteed X, @inout X) -> @out X {
 bb0(%0 : $*X, %1 : $*X, %2 : $*X):
@@ -759,7 +759,7 @@ bb0(%0 : $*X, %1 : $*X, %2 : $*X):
 
 // CHECK-LABEL: sil @call_unknown_func_with_in_guaranteed_arg
 // CHECK-NEXT:  [%0: read v**, copy v**]
-// CHECK-NEXT:  [global: read,write,copy,destroy,allocate]
+// CHECK-NEXT:  [global: read,write,copy,destroy,allocate,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil @call_unknown_func_with_in_guaranteed_arg : $@convention(thin) (@in_guaranteed X) -> () {
 bb0(%0 : $*X):
@@ -771,7 +771,7 @@ bb0(%0 : $*X):
 
 // CHECK-LABEL: sil @test_escaping_in_argument
 // CHECK-NEXT:  [%0: read v**, copy v**]
-// CHECK-NEXT:  [global: read,write,copy,destroy,allocate]
+// CHECK-NEXT:  [global: read,write,copy,destroy,allocate,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil @test_escaping_in_argument : $@convention(thin) (@in_guaranteed X) -> () {
 bb0(%0 : $*X):
@@ -859,7 +859,7 @@ bb0:
 }
 
 // CHECK-LABEL: sil @call_public_external_func
-// CHECK-NEXT:  [global: read,write,copy,destroy,allocate]
+// CHECK-NEXT:  [global: read,write,copy,destroy,allocate,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil @call_public_external_func : $@convention(thin) () -> () {
 bb0:
@@ -969,7 +969,7 @@ bb3:
 
 // CHECK-LABEL: sil @storeMaybeLocalPhi
 // CHECK-NEXT:  [%0: read c*.v**, write c*.v**, copy **, destroy c*.v**]
-// CHECK-NEXT:  [global: read,write,copy,destroy,allocate]
+// CHECK-NEXT:  [global: read,write,copy,destroy,allocate,deinit_barrier]
 // CHECK-NEXT:  {{^[^[]}}
 sil @storeMaybeLocalPhi : $@convention(thin) (@guaranteed List) -> () {
 bb0(%1 : $List):
@@ -1069,3 +1069,13 @@ bb0(%0 : @guaranteed ${ var Int32 }):
   end_access %5 : $*Int32
   return %6 : $Int32
 }
+
+// CHECK-LABEL: sil [ossa] @callUnknownIsDeinitBarrier : {{.*}} {
+// CHECK-NEXT:  [global: {{.*}}deinit_barrier]
+// CHECK-LABEL: } // end sil function 'callUnknownIsDeinitBarrier'
+sil [ossa] @callUnknownIsDeinitBarrier : $@convention(thin) () -> () {
+  %callee = function_ref @unknown_func : $@convention(thin) () -> ()
+  apply %callee() : $@convention(thin) () -> ()
+  %retval = tuple ()
+  return %retval : $()
+}