Swift optimizations: make isSwift51RuntimeAvailable sensitive to the resilience domain of the function.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/InstructionPasses/SimplifyStrongRetainRelease.swift

@@ -76,18 +76,18 @@ private func isNotReferenceCounted(value: Value, context: PassContext) -> Bool {
       return isNotReferenceCounted(value: uci.operand, context: context)
     case let urc as UncheckedRefCastInst:
       return isNotReferenceCounted(value: urc.operand, context: context)
-    case is GlobalValueInst:
+    case let gvi as GlobalValueInst:
       // Since Swift 5.1, statically allocated objects have "immortal" reference
       // counts. Therefore we can safely eliminate unbalaced retains and
       // releases, because they are no-ops on immortal objects.
       // Note that the `simplifyGlobalValuePass` pass is deleting balanced
       // retains/releases, which doesn't require a Swift 5.1 minimum deployment
       // targert.
-      return context.isSwift51RuntimeAvailable
+      return gvi.function.isSwift51RuntimeAvailable
     case let rptr as RawPointerToRefInst:
       // Like `global_value` but for the empty collection singletons from the
       // stdlib, e.g. the empty Array singleton.
-      if context.isSwift51RuntimeAvailable {
+      if rptr.function.isSwift51RuntimeAvailable {
         // The pattern generated for empty collection singletons is:
         //     %0 = global_addr @_swiftEmptyArrayStorage
         //     %1 = address_to_pointer %0

SwiftCompilerSources/Sources/Optimizer/PassManager/PassUtils.swift

@@ -22,10 +22,6 @@ struct PassContext {
 
   let _bridged: BridgedPassContext
 
-  var isSwift51RuntimeAvailable: Bool {
-    PassContext_isSwift51RuntimeAvailable(_bridged) != 0
-  }
-
   var aliasAnalysis: AliasAnalysis {
     let bridgedAA = PassContext_getAliasAnalysis(_bridged)
     return AliasAnalysis(bridged: bridgedAA)

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -52,6 +52,13 @@ final public class Function : CustomStringConvertible, HasName {
   public var argumentTypes: ArgumentTypeArray { ArgumentTypeArray(function: self) }
   public var resultType: Type { SILFunction_getSILResultType(bridged).type }
 
+  /// True, if the function runs with a swift 5.1 runtime.
+  /// Note that this is function specific, because inlinable functions are de-serialized
+  /// in a client module, which might be compiled with a different deployment target.
+  public var isSwift51RuntimeAvailable: Bool {
+    SILFunction_isSwift51RuntimeAvailable(bridged) != 0
+  }
+
   // Only to be called by PassContext
   public func _modifyEffects(_ body: (inout FunctionEffects) -> ()) {
     body(&effects)

include/swift/SIL/SILBridging.h

@@ -205,6 +205,7 @@ SwiftInt SILFunction_getSelfArgumentIndex(BridgedFunction function);
 SwiftInt SILFunction_getNumSILArguments(BridgedFunction function);
 BridgedType SILFunction_getSILArgumentType(BridgedFunction function, SwiftInt idx);
 BridgedType SILFunction_getSILResultType(BridgedFunction function);
+SwiftInt SILFunction_isSwift51RuntimeAvailable(BridgedFunction function);
 
 BridgedStringRef SILGlobalVariable_getName(BridgedGlobalVar global);
 BridgedStringRef SILGlobalVariable_debugDescription(BridgedGlobalVar global);

include/swift/SILOptimizer/OptimizerBridging.h

@@ -86,8 +86,6 @@ void SILPassManager_registerFunctionPass(BridgedStringRef name,
 void SILCombine_registerInstructionPass(BridgedStringRef name,
                                         BridgedInstructionPassRunFn runFn);
 
-SwiftInt PassContext_isSwift51RuntimeAvailable(BridgedPassContext context);
-
 BridgedAliasAnalysis PassContext_getAliasAnalysis(BridgedPassContext context);
 
 BridgedMemoryBehavior AliasAnalysis_getMemBehavior(BridgedAliasAnalysis aa,

lib/SIL/Utils/SILBridging.cpp

@@ -213,6 +213,16 @@ BridgedType SILFunction_getSILResultType(BridgedFunction function) {
   return {resTy.getOpaqueValue()};
 }
 
+SwiftInt SILFunction_isSwift51RuntimeAvailable(BridgedFunction function) {
+  SILFunction *f = castToFunction(function);
+  if (f->getResilienceExpansion() != ResilienceExpansion::Maximal)
+    return 0;
+
+  ASTContext &ctxt = f->getModule().getASTContext();
+  return AvailabilityContext::forDeploymentTarget(ctxt).isContainedIn(
+    ctxt.getSwift51Availability());
+}
+
 //===----------------------------------------------------------------------===//
 //                               SILBasicBlock
 //===----------------------------------------------------------------------===//

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -1240,13 +1240,6 @@ void PassContext_fixStackNesting(BridgedPassContext passContext,
   }
 }
 
-SwiftInt PassContext_isSwift51RuntimeAvailable(BridgedPassContext context) {
-  SILPassManager *pm = castToPassInvocation(context)->getPassManager();
-  ASTContext &ctxt = pm->getModule()->getASTContext();
-  return AvailabilityContext::forDeploymentTarget(ctxt).isContainedIn(
-    ctxt.getSwift51Availability());
-}
-
 BridgedAliasAnalysis PassContext_getAliasAnalysis(BridgedPassContext context) {
   SwiftPassInvocation *invocation = castToPassInvocation(context);
   SILPassManager *pm = invocation->getPassManager();

test/SILOptimizer/immortal-arc-elimination.sil

@@ -28,7 +28,7 @@ bb0:
 }
 
 
-sil_global private @staticArray : $_ContiguousArrayStorage<Int> = {
+sil_global @staticArray : $_ContiguousArrayStorage<Int> = {
   %0 = integer_literal $Builtin.Int64, 0
   %1 = struct $UInt (%0 : $Builtin.Int64)
   %2 = struct $Int (%0 : $Builtin.Int64)
@@ -49,4 +49,15 @@ bb0:
   return %1 : $Builtin.BridgeObject
 }
 
+// CHECK-LABEL: sil [serialized] @testGlobalValueSerialized
+// CHECK:       global_value
+// CHECK:       retain
+// CHECK: } // end sil function 'testGlobalValueSerialized'
+sil [serialized] @testGlobalValueSerialized : $@convention(thin) () -> @owned Builtin.BridgeObject {
+bb0:
+  %0 = global_value @staticArray : $_ContiguousArrayStorage<Int>
+  %1 = unchecked_ref_cast %0 : $_ContiguousArrayStorage<Int> to $Builtin.BridgeObject
+  strong_retain %1 : $Builtin.BridgeObject
+  return %1 : $Builtin.BridgeObject
+}