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

@@ -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,160 @@
+//===--- 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
+    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)
+            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
+) {
+  let allocRefInstruction = deallocStackRef.allocRef
+  var root = release.operands[0].value
+  while let newRoot = stripRCIdentityPreservingInsts(root) {
+    root = newRoot
+  }
+
+  guard root === allocRefInstruction else {
+    return
+  }
+
+  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 stripRCIdentityPreservingInsts(_ value: Value) -> Value? {
+  switch value {
+  // First strip off RC identity preserving casts.
+  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 ||
+    inst is UncheckedEnumDataInst:
+    return inst.operands[0].value
+
+  // Then if we have a struct_extract that is extracting a non-trivial member
+  // from a struct with no other non-trivial members, a ref count operation on
+  // the struct is equivalent to a ref count operation on the extracted
+  // member. Strip off the extract.
+  case let sei as StructExtractInst where sei.isFieldOnlyNonTrivialField:
+    return sei.operands[0].value
+
+  // If we have a struct instruction with only one non-trivial stored field, the
+  // only reference count that can be modified is the non-trivial field. Return
+  // the non-trivial field.
+  case let si as StructInst:
+    return si.uniqueNonTrivialFieldValue
+
+  // If we have an enum instruction with a payload, strip off the enum to
+  // expose the enum's payload.
+  case let ei as EnumInst where !ei.operands.isEmpty:
+    return ei.operands[0].value
+
+  // If we have a tuple_extract that is extracting the only non trivial member
+  // of a tuple, a retain_value on the tuple is equivalent to a retain_value on
+  // the extracted value.
+  case let tei as TupleExtractInst where tei.isEltOnlyNonTrivialElt:
+    return tei.operands[0].value
+
+  // If we are forming a tuple and the tuple only has one element with reference
+  // semantics, a retain_value on the tuple is equivalent to a retain value on
+  // the tuple operand.
+  case let ti as TupleInst:
+    return ti.uniqueNonTrivialElt
+
+  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,7 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-import AST
 import SIL
 import OptimizerBridging
 
@@ -117,8 +116,8 @@ struct PassContext {
     PassContext_fixStackNesting(_bridged, function.bridged)
   }
 
-  func getDeallocRef(for type: Type) -> Function? {
-    PassContext_getDeallocRef(_bridged, type.bridged).function
+  func getDestructor(ofClass type: Type) -> Function? {
+    PassContext_getDestructor(_bridged, type.bridged).function
   }
 
   func getContextSubstitutionMap(for type: Type) -> SubstitutionMap {

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 {
 }
@@ -356,10 +362,14 @@ final public class GlobalValueInst : GlobalAccessInst {}
 final public class IntegerLiteralInst : SingleValueInstruction {}
 
 final public class TupleInst : SingleValueInstruction {
+  public var uniqueNonTrivialElt: Value? {
+    TupleInst_getUniqueNonTrivialElt(bridged).value
+  }
 }
 
 final public class TupleExtractInst : SingleValueInstruction, UnaryInstruction {
   public var fieldIndex: Int { TupleExtractInst_fieldIndex(bridged) }
+  public var isEltOnlyNonTrivialElt: Bool { TupleExtractInst_isEltOnlyNonTrivialElt(bridged) }
 }
 
 final public
@@ -368,10 +378,16 @@ class TupleElementAddrInst : SingleValueInstruction, UnaryInstruction {
 }
 
 final public class StructInst : SingleValueInstruction {
+  public var uniqueNonTrivialFieldValue: Value? {
+    StructInst_getUniqueNonTrivialFieldValue(bridged).value
+  }
 }
 
 final public class StructExtractInst : SingleValueInstruction, UnaryInstruction {
   public var fieldIndex: Int { StructExtractInst_fieldIndex(bridged) }
+  public var isFieldOnlyNonTrivialField: Bool { 
+    StructExtractInst_isFieldOnlyNonTrivialField(bridged)
+  }
 }
 
 final public
@@ -515,6 +531,9 @@ final public class BeginApplyInst : MultipleValueInstruction, FullApplySite {
   public var singleDirectResult: Value? { nil }
 }
 
+final public class RefToBridgeObjectInst: MultipleValueInstruction {
+}
+
 //===----------------------------------------------------------------------===//
 //                            terminator instructions
 //===----------------------------------------------------------------------===//

SwiftCompilerSources/Sources/SIL/Instruction.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/AST/SubstitutionMap.swift renamed to SwiftCompilerSources/Sources/SIL/SubstitutionMap.swift

@@ -58,3 +58,7 @@ final class Undef : Value {
 final class PlaceholderValue : Value {
   public var definingInstruction: Instruction? { nil }
 }
+
+extension OptionalBridgedValue {
+  var value: Value? { obj.getAs(AnyObject.self) as? Value }
+}

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -118,6 +118,10 @@ typedef struct {
   SwiftObject obj;
 } BridgedValue;
 
+typedef struct {
+  OptionalSwiftObject obj;
+} OptionalBridgedValue;
+
 typedef struct {
   SwiftObject obj;
 } BridgedInstruction;
@@ -211,6 +215,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);
@@ -224,8 +229,12 @@ BridgedBuiltinID BuiltinInst_getID(BridgedInstruction bi);
 BridgedGlobalVar GlobalAccessInst_getGlobal(BridgedInstruction globalInst);
 BridgedFunction FunctionRefInst_getReferencedFunction(BridgedInstruction fri);
 SwiftInt TupleExtractInst_fieldIndex(BridgedInstruction tei);
+bool TupleExtractInst_isEltOnlyNonTrivialElt(BridgedInstruction tei);
 SwiftInt TupleElementAddrInst_fieldIndex(BridgedInstruction teai);
+OptionalBridgedValue TupleInst_getUniqueNonTrivialElt(BridgedInstruction ti);
 SwiftInt StructExtractInst_fieldIndex(BridgedInstruction sei);
+bool StructExtractInst_isFieldOnlyNonTrivialField(BridgedInstruction sei);
+OptionalBridgedValue StructInst_getUniqueNonTrivialFieldValue(BridgedInstruction si);
 SwiftInt StructElementAddrInst_fieldIndex(BridgedInstruction seai);
 SwiftInt EnumInst_caseIndex(BridgedInstruction ei);
 SwiftInt UncheckedEnumDataInst_caseIndex(BridgedInstruction uedi);
@@ -241,6 +250,7 @@ SwiftInt SwitchEnumInst_getNumCases(BridgedInstruction se);
 SwiftInt SwitchEnumInst_getCaseIndex(BridgedInstruction se, SwiftInt idx);
 SwiftInt StoreInst_getStoreOwnership(BridgedInstruction store);
 void RefCountingInst_setIsAtomic(BridgedInstruction rc, bool isAtomic);
+bool RefCountingInst_getIsAtomic(BridgedInstruction rc);
 
 BridgedInstruction SILBuilder_createBuiltinBinaryFunction(
           BridgedInstruction insertionPoint,

SwiftCompilerSources/Sources/SIL/Value.swift

@@ -141,17 +141,8 @@ void BasicBlockSet_erase(BridgedBasicBlockSet set, BridgedBasicBlock block);
 BridgedFunction BasicBlockSet_getFunction(BridgedBasicBlockSet set);
 
 void AllocRefInstBase_setIsStackAllocatable(BridgedInstruction arb);
-BridgedRCIdentityAnalysis
-PassContext_getRCIdentityAnalysis(BridgedPassContext context);
 
-BridgedRCIdentityFunctionInfo
-RCIdentityAnalysis_getFunctionInfo(BridgedRCIdentityAnalysis bridgedAnalysis,
-                                   BridgedFunction function);
-
-BridgedValue RCIdentityFunctionInfo_getRCIdentityRoot(
-    BridgedRCIdentityFunctionInfo bridgedInfo, BridgedValue value);
-
-OptionalBridgedFunction PassContext_getDeallocRef(BridgedPassContext context,
+OptionalBridgedFunction PassContext_getDestructor(BridgedPassContext context,
                                                   BridgedType type);
 
 BridgedSubstitutionMap

include/swift/SIL/SILBridging.h

@@ -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")