libswift: implement ReleaseDevirtualizer in Swift

Author: MaxDesiatov

SwiftCompilerSources/Sources/AST/CMakeLists.txt

@@ -9,6 +9,5 @@
 if(SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING)
   add_subdirectory(ExperimentalRegex)
 endif()
-add_subdirectory(AST)
 add_subdirectory(SIL)
 add_subdirectory(Optimizer)

SwiftCompilerSources/Sources/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
@@ -11,4 +11,5 @@ swift_compiler_sources(Optimizer
   CalleeAnalysis.swift
   DeadEndBlocksAnalysis.swift
   DominatorTree.swift
-  PostDominatorTree.swift)
+  PostDominatorTree.swift
+  RCIdentityAnalysis.swift)

SwiftCompilerSources/Sources/Optimizer/Analysis/CMakeLists.txt

@@ -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/Analysis/RCIdentityAnalysis.swift

@@ -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/CMakeLists.txt

@@ -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 rootObject = functionInfo.getRCIdentityRoot(release.operands[0].value)
+  var root = release.operands[0].value
+  while let newRoot = getRCIdentityPreservingCastOperand(root) {
+    root = newRoot
+  }
+
+  precondition(rootObject === root)
+
+  guard rootObject === allocRefInstruction else {
+    return
+  }
+
+  guard rootObject === 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.getDestructor(ofClass: 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/FunctionPasses/ReleaseDevirtualizer.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/PassRegistration.swift

@@ -10,9 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-import AST
-import SIL
 import OptimizerBridging
+import SIL
 
 public typealias BridgedFunctionPassCtxt =
   OptimizerBridging.BridgedFunctionPassCtxt
@@ -64,6 +63,10 @@ struct PassContext {
     PassContext_notifyChanges(_bridged, branchesChanged)
   }
 
+  var rcIdentityAnalysis: RCIdentityAnalysis {
+    .init(bridged: PassContext_getRCIdentityAnalysis(_bridged))
+  }
+
   enum EraseMode {
     case onlyInstruction, includingDebugUses
   }
@@ -117,12 +120,12 @@ struct PassContext {
     PassContext_fixStackNesting(_bridged, function.bridged)
   }
 
-  func getDeallocRef(for type: Type) -> Function? {
-    PassContext_getDeallocRef(passContext, type.bridged).function
+  func getDestructor(ofClass type: Type) -> Function? {
+    PassContext_getDestructor(_bridged, type.bridged).function
   }
 
   func getContextSubstitutionMap(for type: Type) -> SubstitutionMap {
-    SubstitutionMap(PassContext_getContextSubstitutionMap(passContext, type.bridged))
+    SubstitutionMap(PassContext_getContextSubstitutionMap(_bridged, type.bridged))
   }
 }
 

SwiftCompilerSources/Sources/Optimizer/PassManager/PassUtils.swift

@@ -10,7 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-import AST
 import SILBridging
 
 /// A utility to create new instructions at a given insertion point.
@@ -102,14 +101,16 @@ public struct Builder {
     function: Value,
     _ substitutionMap: SubstitutionMap,
     arguments: [Value]
-  ) -> FunctionRefInst {
+  ) -> ApplyInst {
     notifyInstructionsChanged()
-    let functionRef = arguments.withBridgedValues { valuesRef in
+    notifyCallsChanged()
+
+    let apply = arguments.withBridgedValues { valuesRef in
       SILBuilder_createApply(
         bridgedInsPoint, location.bridgedLocation, function.bridged,
         substitutionMap.bridged, valuesRef
       )
     }
-    return functionRef.getAs(FunctionRefInst.self)
+    return apply.getAs(ApplyInst.self)
   }
 }

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -17,6 +17,7 @@ add_swift_compiler_module(SIL
   Location.swift
   Operand.swift
   Registration.swift
+  SubstitutionMap.swift
   Type.swift
   Utils.swift
   Value.swift)

SwiftCompilerSources/Sources/SIL/CMakeLists.txt

@@ -98,6 +98,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
   }
@@ -237,7 +241,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 {
 }
@@ -355,8 +361,6 @@ final public class GlobalValueInst : GlobalAccessInst {}
 
 final public class IntegerLiteralInst : SingleValueInstruction {}
 
-final public class FunctionRefInst: SingleValueInstruction {}
-
 final public class TupleInst : SingleValueInstruction {
 }
 
@@ -517,6 +521,9 @@ final public class BeginApplyInst : MultipleValueInstruction, FullApplySite {
   public var singleDirectResult: Value? { nil }
 }
 
+final public class RefToBridgeObjectInst: MultipleValueInstruction {
+}
+
 //===----------------------------------------------------------------------===//
 //                            terminator instructions
 //===----------------------------------------------------------------------===//

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -80,7 +80,6 @@ public func registerSILClasses() {
   register(GlobalAddrInst.self)
   register(GlobalValueInst.self)
   register(IntegerLiteralInst.self)
-  register(FunctionRefInst.self)
   register(TupleInst.self)
   register(TupleExtractInst.self)
   register(TupleElementAddrInst.self)
@@ -122,6 +121,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/Registration.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/AST/SubstitutionMap.swift renamed to SwiftCompilerSources/Sources/SIL/SubstitutionMap.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
+  }
+}

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -211,6 +211,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);
@@ -240,6 +241,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/SIL/SILBridging.h

@@ -151,7 +151,7 @@ RCIdentityAnalysis_getFunctionInfo(BridgedRCIdentityAnalysis bridgedAnalysis,
 BridgedValue RCIdentityFunctionInfo_getRCIdentityRoot(
     BridgedRCIdentityFunctionInfo bridgedInfo, BridgedValue value);
 
-OptionalBridgedFunction PassContext_getDeallocRef(BridgedPassContext context,
+OptionalBridgedFunction PassContext_getDestructor(BridgedPassContext context,
                                                   BridgedType type);
 
 BridgedSubstitutionMap