libswift: implement ReleaseDevirtualizer in Swift

Author: MaxDesiatov

SwiftCompilerSources/Sources/AST/CMakeLists.txt

@@ -1,6 +1,6 @@
 # This source file is part of the Swift.org open source project
 #
-# Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+# Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
 # Licensed under Apache License v2.0 with Runtime Library Exception
 #
 # See http://swift.org/LICENSE.txt for license information

SwiftCompilerSources/Sources/AST/SubstitutionMap.swift

@@ -1,4 +1,4 @@
-//===--- PassUtils.swift - Utilities for optimzation passes ---------------===//
+//===--- SubstitutionMap.swift - Swift Substitution Map ASTs --------------===//
 //
 // This source file is part of the Swift.org open source project
 //

SwiftCompilerSources/Sources/Optimizer/Analysis/CMakeLists.txt

@@ -1,11 +1,12 @@
 # This source file is part of the Swift.org open source project
 #
-# Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+# Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
 # Licensed under Apache License v2.0 with Runtime Library Exception
 #
 # See http://swift.org/LICENSE.txt for license information
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
 swift_compiler_sources(Optimizer
   AliasAnalysis.swift
-  CalleeAnalysis.swift)
+  CalleeAnalysis.swift
+  RCIdentityAnalysis.swift)

SwiftCompilerSources/Sources/Optimizer/Analysis/RCIdentityAnalysis.swift

@@ -0,0 +1,30 @@
+//===--- CalleeAnalysis.swift - the callee analysis -----------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import OptimizerBridging
+import SIL
+
+struct RCIdentityAnalysis {
+  let bridged: BridgedRCIdentityAnalysis
+
+  func getFunctionInfo(_ function: Function) -> RCIdentityFunctionInfo {
+    RCIdentityFunctionInfo(bridged: RCIdentityAnalysis_getFunctionInfo(bridged, function.bridged))
+  }
+}
+
+struct RCIdentityFunctionInfo {
+  let bridged: BridgedRCIdentityFunctionInfo
+
+  func getRCIdentityRoot(_ value: Value) -> AnyObject {
+    RCIdentityFunctionInfo_getRCIdentityRoot(bridged, value.bridged).getAs(AnyObject.self)
+  }
+}

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CMakeLists.txt

@@ -1,6 +1,6 @@
 # This source file is part of the Swift.org open source project
 #
-# Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+# Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
 # Licensed under Apache License v2.0 with Runtime Library Exception
 #
 # See http://swift.org/LICENSE.txt for license information
@@ -10,4 +10,5 @@ swift_compiler_sources(Optimizer
   AssumeSingleThreaded.swift
   SILPrinter.swift
   MergeCondFails.swift
+  ReleaseDevirtualizer.swift
 )

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ReleaseDevirtualizer.swift

@@ -0,0 +1,140 @@
+//===--- ReleaseDevirtualizer.swift - Devirtualizes release-instructions --===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+
+/// Devirtualizes release instructions which are known to destruct the object.
+///
+/// This means, it replaces a sequence of
+///    %x = alloc_ref [stack] $X
+///      ...
+///    strong_release %x
+///    dealloc_stack_ref %x
+/// with
+///    %x = alloc_ref [stack] $X
+///      ...
+///    set_deallocating %x
+///    %d = function_ref @dealloc_of_X
+///    %a = apply %d(%x)
+///    dealloc_stack_ref %x
+///
+/// The optimization is only done for stack promoted objects because they are
+/// known to have no associated objects (which are not explicitly released
+/// in the deinit method).
+let releaseDevirtualizerPass = FunctionPass(
+  name: "release-devirtualizer", { function, context in
+    let functionInfo = context.rcIdentityAnalysis.getFunctionInfo(function)
+
+    for block in function.blocks {
+      // The last `release_value`` or `strong_release`` instruction before the
+      // deallocation.
+      var lastRelease: RefCountingInst?
+
+      for instruction in block.instructions {
+        if let release = lastRelease {
+          // We only do the optimization for stack promoted object, because for
+          // these we know that they don't have associated objects, which are
+          // _not_ released by the deinit method.
+          if let deallocStackRef = instruction as? DeallocStackRefInst {
+            devirtualizeReleaseOfObject(context, release, deallocStackRef, functionInfo)
+            lastRelease = nil
+            continue
+          }
+        }
+
+        if instruction is ReleaseValueInst || instruction is StrongReleaseInst {
+          lastRelease = instruction as? RefCountingInst
+        } else if instruction.mayReleaseOrReadRefCount {
+          lastRelease = nil
+        }
+      }
+    }
+  }
+)
+
+/// Devirtualize releases of array buffers.
+private func devirtualizeReleaseOfObject(
+  _ context: PassContext,
+  _ release: RefCountingInst,
+  _ deallocStackRef: DeallocStackRefInst,
+  _ functionInfo: RCIdentityFunctionInfo
+) {
+  let allocRefInstruction = deallocStackRef.allocRef
+  let rcRoot = functionInfo.getRCIdentityRoot(release.operands[0].value)
+  var root = release.operands[0].value
+  while let newRoot = getRCIdentityPreservingCastOperand(root) {
+    root = newRoot
+  }
+
+  precondition(rcRoot === root)
+
+  guard rcRoot === allocRefInstruction else {
+    return
+  }
+
+  guard rcRoot === release.operands[0].value else {
+    print(release.description)
+    print(release.block.function.description)
+    fatalError()
+  }
+
+  createDeallocCall(context, allocRefInstruction.type, release, allocRefInstruction)
+}
+
+/// Replaces the release-instruction `release` with an explicit call to
+/// the deallocating destructor of `type` for `object`.
+private func createDeallocCall(
+  _ context: PassContext,
+  _ type: Type,
+  _ release: RefCountingInst,
+  _ object: Value
+) {
+  guard let dealloc = context.getDealloc(for: type) else {
+    return
+  }
+
+  let substitutionMap = context.getContextSubstitutionMap(for: type)
+
+  let builder = Builder(at: release, location: release.location, context)
+
+  var object = object
+  if object.type != type {
+    object = builder.createUncheckedRefCast(object: object, type: type)
+  }
+
+  // Do what a release would do before calling the deallocator: set the object
+  // in deallocating state, which means set the RC_DEALLOCATING_FLAG flag.
+  builder.createSetDeallocating(operand: object, isAtomic: release.isAtomic)
+
+  // Create the call to the destructor with the allocated object as self
+  // argument.
+  let functionRef = builder.createFunctionRef(dealloc)
+
+  builder.createApply(function: functionRef, substitutionMap, arguments: [object])
+  context.erase(instruction: release)
+}
+
+private func getRCIdentityPreservingCastOperand(_ value: Value) -> Value? {
+  switch value {
+  case let inst as Instruction where inst is UpcastInst ||
+       inst is UncheckedRefCastInst ||
+       inst is InitExistentialRefInst ||
+       inst is OpenExistentialRefInst ||
+       inst is RefToBridgeObjectInst ||
+       inst is BridgeObjectToRefInst ||
+       inst is ConvertFunctionInst:
+    return inst.operands[0].value
+
+  default:
+    return nil
+  }
+}

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -51,4 +51,5 @@ private func registerSwiftPasses() {
   registerPass(simplifyStrongRetainPass, { simplifyStrongRetainPass.run($0) })
   registerPass(simplifyStrongReleasePass, { simplifyStrongReleasePass.run($0) })
   registerPass(assumeSingleThreadedPass, { assumeSingleThreadedPass.run($0) })
+  registerPass(releaseDevirtualizerPass, { releaseDevirtualizerPass.run($0) })
 }

SwiftCompilerSources/Sources/Optimizer/PassManager/PassUtils.swift

@@ -37,6 +37,10 @@ struct PassContext {
     return CalleeAnalysis(bridged: bridgeCA)
   }
 
+  var rcIdentityAnalysis: RCIdentityAnalysis {
+    .init(bridged: PassContext_getRCIdentityAnalysis(passContext))
+  }
+
   enum EraseMode {
     case onlyInstruction, includingDebugUses
   }
@@ -86,8 +90,8 @@ struct PassContext {
     RefCountingInst_setIsAtomic(instruction.bridged, isAtomic)
   }
 
-  func getDeallocRef(for type: Type) -> Function? {
-    PassContext_getDeallocRef(passContext, type.bridged).function
+  func getDealloc(for type: Type) -> Function? {
+    PassContext_getDealloc(passContext, type.bridged).function
   }
 
   func getContextSubstitutionMap(for type: Type) -> SubstitutionMap {

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -91,6 +91,10 @@ public class Instruction : ListNode, CustomStringConvertible, Hashable {
     }
   }
 
+  final public var mayReleaseOrReadRefCount: Bool {
+    return SILInstruction_mayReleaseOrReadRefCount(bridged)
+  }
+
   public static func ==(lhs: Instruction, rhs: Instruction) -> Bool {
     lhs === rhs
   }
@@ -230,7 +234,9 @@ final public class SetDeallocatingInst : Instruction, UnaryInstruction {}
 
 final public class DeallocRefInst : Instruction, UnaryInstruction {}
 
-public class RefCountingInst : Instruction, UnaryInstruction {}
+public class RefCountingInst : Instruction, UnaryInstruction {
+  public var isAtomic: Bool { RefCountingInst_getIsAtomic(bridged) }
+}
 
 final public class StrongRetainInst : RefCountingInst {
 }
@@ -478,6 +484,9 @@ final public class BeginApplyInst : MultipleValueInstruction, FullApplySite {
   public var singleDirectResult: Value? { nil }
 }
 
+final public class RefToBridgeObjectInst: MultipleValueInstruction {
+}
+
 //===----------------------------------------------------------------------===//
 //                            terminator instructions
 //===----------------------------------------------------------------------===//

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -120,6 +120,7 @@ public func registerSILClasses() {
   register(DestructureStructInst.self)
   register(DestructureTupleInst.self)
   register(BeginApplyInst.self)
+  register(RefToBridgeObjectInst.self)
 
   register(UnreachableInst.self)
   register(ReturnInst.self)

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -22,3 +22,9 @@ public struct Type {
     return SILType_isTrivial(bridged, function.bridged) != 0
   }
 }
+
+extension Type: Equatable {
+  public static func == (lhs: Type, rhs: Type) -> Bool {
+    lhs.bridged.typePtr == rhs.bridged.typePtr
+  }
+}

include/swift/SIL/SILBridging.h

@@ -218,6 +218,7 @@ void SILInstruction_setOperand(BridgedInstruction inst, SwiftInt index,
                                BridgedValue value);
 BridgedLocation SILInstruction_getLocation(BridgedInstruction inst);
 BridgedMemoryBehavior SILInstruction_getMemBehavior(BridgedInstruction inst);
+bool SILInstruction_mayReleaseOrReadRefCount(BridgedInstruction inst);
 
 BridgedInstruction MultiValueInstResult_getParent(BridgedMultiValueResult result);
 SwiftInt MultipleValueInstruction_getNumResults(BridgedInstruction inst);
@@ -243,6 +244,7 @@ BridgedBasicBlock BranchInst_getTargetBlock(BridgedInstruction bi);
 SwiftInt SwitchEnumInst_getNumCases(BridgedInstruction se);
 SwiftInt SwitchEnumInst_getCaseIndex(BridgedInstruction se, SwiftInt idx);
 SwiftInt StoreInst_getStoreOwnership(BridgedInstruction store);
+bool RefCountingInst_getIsAtomic(BridgedInstruction rc);
 void RefCountingInst_setIsAtomic(BridgedInstruction rc, bool isAtomic);
 
 BridgedInstruction SILBuilder_createBuiltinBinaryFunction(

include/swift/SILOptimizer/OptimizerBridging.h

@@ -89,8 +89,8 @@ RCIdentityAnalysis_getFunctionInfo(BridgedRCIdentityAnalysis bridgedAnalysis,
 BridgedValue RCIdentityFunctionInfo_getRCIdentityRoot(
     BridgedRCIdentityFunctionInfo bridgedInfo, BridgedValue value);
 
-OptionalBridgedFunction PassContext_getDeallocRef(BridgedPassContext context,
-                                                  BridgedType type);
+OptionalBridgedFunction PassContext_getDealloc(BridgedPassContext context,
+                                               BridgedType type);
 
 BridgedSubstitutionMap
 PassContext_getContextSubstitutionMap(BridgedPassContext context,

include/swift/SILOptimizer/PassManager/Passes.def

@@ -336,7 +336,7 @@ PASS(RedundantPhiElimination, "redundant-phi-elimination",
      "Redundant Phi Block Argument Elimination")
 PASS(PhiExpansion, "phi-expansion",
      "Replace Phi arguments by their only used field")
-PASS(ReleaseDevirtualizer, "release-devirtualizer",
+SWIFT_FUNCTION_PASS_WITH_LEGACY(ReleaseDevirtualizer, "release-devirtualizer",
      "SIL release Devirtualization")
 PASS(RetainSinking, "retain-sinking",
      "SIL retain Sinking")

lib/SIL/Utils/SILBridging.cpp

@@ -394,6 +394,10 @@ BridgedMemoryBehavior SILInstruction_getMemBehavior(BridgedInstruction inst) {
   return (BridgedMemoryBehavior)castToInst(inst)->getMemoryBehavior();
 }
 
+bool SILInstruction_mayReleaseOrReadRefCount(BridgedInstruction inst) {
+  return castToInst(inst)->mayReleaseOrReadRefCount();
+}
+
 BridgedInstruction MultiValueInstResult_getParent(BridgedMultiValueResult result) {
   return {static_cast<MultipleValueInstructionResult *>(result.obj)->getParent()};
 }
@@ -483,6 +487,11 @@ SwiftInt StoreInst_getStoreOwnership(BridgedInstruction store) {
   return (SwiftInt)castToInst<StoreInst>(store)->getOwnershipQualifier();
 }
 
+bool RefCountingInst_getIsAtomic(BridgedInstruction rc) {
+  return castToInst<RefCountingInst>(rc)->getAtomicity() ==
+         RefCountingInst::Atomicity::Atomic;
+}
+
 void RefCountingInst_setIsAtomic(BridgedInstruction rc, bool isAtomic) {
   castToInst<RefCountingInst>(rc)->setAtomicity(
       isAtomic ? RefCountingInst::Atomicity::Atomic
@@ -558,4 +567,4 @@ BridgedInstruction SILBuilder_createApply(BridgedInstruction insertionPoint,
   return {builder.createApply(getRegularLocation(loc), castToSILValue(function),
                               castToSubstitutionMap(subMap),
                               getSILValues(arguments, argValues))};
-}
+}

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -1217,8 +1217,8 @@ PassContext_getRCIdentityAnalysis(BridgedPassContext context) {
   return {pm->getAnalysis<RCIdentityAnalysis>()};
 }
 
-OptionalBridgedFunction PassContext_getDeallocRef(BridgedPassContext context,
-                                                  BridgedType type) {
+OptionalBridgedFunction PassContext_getDealloc(BridgedPassContext context,
+                                               BridgedType type) {
   auto *cd = castToSILType(type).getClassOrBoundGenericClass();
   assert(cd && "no class type allocated with alloc_ref");
 

lib/SILOptimizer/Transforms/ReleaseDevirtualizer.cpp

@@ -159,6 +159,6 @@ bool ReleaseDevirtualizer::createDeallocCall(SILType AllocType,
 
 } // end anonymous namespace
 
-SILTransform *swift::createReleaseDevirtualizer() {
+SILTransform *swift::createLegacyReleaseDevirtualizer() {
   return new ReleaseDevirtualizer();
 }