Optimizer: de-virtualize deinits of non-copyable types

eeckstein · eeckstein · commit 048624f967bf · 2023-11-17T17:14:31.000+01:00
In regular swift this is a nice optimization. In embedded swift it's a requirement, because the compiler needs to be able to specialize generic deinits of non-copyable types.
The new de-virtualization utilities are called from two places:

* from the new DeinitDevirtualizer pass. It replaces the old MoveOnlyDeinitDevirtualization, which is very basic and does not fulfill the needs for embedded swift.

* from MandatoryPerformanceOptimizations for embedded swift
diff --git a/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CMakeLists.txt b/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CMakeLists.txt
@@ -13,6 +13,7 @@ swift_compiler_sources(Optimizer
   ComputeEscapeEffects.swift
   ComputeSideEffects.swift
   DeadStoreElimination.swift
+  DeinitDevirtualizer.swift
   InitializeStaticGlobals.swift
   LetPropertyLowering.swift
   ObjectOutliner.swift
diff --git a/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/DeinitDevirtualizer.swift b/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/DeinitDevirtualizer.swift
@@ -0,0 +1,30 @@
+//===--- DeinitDevirtualizer.swift ----------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 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 destroys of non-copyable values.
+///
+let deinitDevirtualizer = FunctionPass(name: "deinit-devirtualizer") {
+  (function: Function, context: FunctionPassContext) in
+
+  for inst in function.instructions {
+    switch inst {
+    case let destroyValue as DestroyValueInst:
+      _ = devirtualizeDeinits(of: destroyValue, context)
+    case let destroyAddr as DestroyAddrInst:
+      _ = devirtualizeDeinits(of: destroyAddr, context)
+    default:
+      break
+    }
+  }
+}
diff --git a/SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift b/SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift
@@ -90,6 +90,16 @@ private func optimize(function: Function, _ context: FunctionPassContext, _ work
           _ = context.specializeClassMethodInst(classMethod)
         }
 
+      // We need to de-virtualize deinits of non-copyable types to be able to specialize the deinitializers.
+      case let destroyValue as DestroyValueInst:
+        if !devirtualizeDeinits(of: destroyValue, simplifyCtxt) {
+          context.diagnosticEngine.diagnose(destroyValue.location.sourceLoc, .deinit_not_visible)
+        }
+      case let destroyAddr as DestroyAddrInst:
+        if !devirtualizeDeinits(of: destroyAddr, simplifyCtxt) {
+          context.diagnosticEngine.diagnose(destroyAddr.location.sourceLoc, .deinit_not_visible)
+        }
+
       default:
         break
       }
diff --git a/SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift b/SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift
@@ -42,6 +42,10 @@ extension Context {
       default:         fatalError("unhandled SILStage case")
     }
   }
+
+  func lookupDeinit(ofNominal: NominalTypeDecl) -> Function? {
+    _bridged.lookUpNominalDeinitFunction(ofNominal.bridged).function
+  }
 }
 
 /// A context which allows mutation of a function's SIL.
diff --git a/SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift b/SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift
@@ -86,6 +86,7 @@ private func registerSwiftPasses() {
   registerPass(deadStoreElimination, { deadStoreElimination.run($0) })
   registerPass(redundantLoadElimination, { redundantLoadElimination.run($0) })
   registerPass(earlyRedundantLoadElimination, { earlyRedundantLoadElimination.run($0) })
+  registerPass(deinitDevirtualizer, { deinitDevirtualizer.run($0) })
 
   // Instruction passes
   registerForSILCombine(BeginCOWMutationInst.self, { run(BeginCOWMutationInst.self, $0) })
diff --git a/SwiftCompilerSources/Sources/Optimizer/Utilities/CMakeLists.txt b/SwiftCompilerSources/Sources/Optimizer/Utilities/CMakeLists.txt
@@ -8,6 +8,7 @@
 
 swift_compiler_sources(Optimizer
   DiagnosticEngine.swift
+  Devirtualization.swift
   EscapeUtils.swift
   OptUtils.swift
   ForwardingUtils.swift
diff --git a/SwiftCompilerSources/Sources/Optimizer/Utilities/Devirtualization.swift b/SwiftCompilerSources/Sources/Optimizer/Utilities/Devirtualization.swift
@@ -0,0 +1,236 @@
+//===--- Devirtualization.swift -------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 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 all value-type deinitializers of a `destroy_value`.
+///
+/// This may be a no-op if the destroy doesn't call any deinitializers.
+/// Returns true if all deinitializers could be devirtualized.
+func devirtualizeDeinits(of destroy: DestroyValueInst, _ context: some MutatingContext) -> Bool {
+  return devirtualize(destroy: destroy, context)
+}
+
+/// Devirtualizes all value-type deinitializers of a `destroy_addr`.
+///
+/// This may be a no-op if the destroy doesn't call any deinitializers.
+/// Returns true if all deinitializers could be devirtualized.
+func devirtualizeDeinits(of destroy: DestroyAddrInst, _ context: some MutatingContext) -> Bool {
+  return devirtualize(destroy: destroy, context)
+}
+
+private func devirtualize(destroy: some DevirtualizableDestroy, _ context: some MutatingContext) -> Bool {
+  let type = destroy.type
+  guard type.isMoveOnly && type.selfOrAnyFieldHasValueDeinit(in: destroy.parentFunction) else {
+    return true
+  }
+  precondition(type.isNominal, "non-copyable non-nominal types not supported, yet")
+
+  let result: Bool
+  if type.nominal.hasValueDeinit && !destroy.hasDropDeinit {
+    guard let deinitFunc = context.lookupDeinit(ofNominal: type.nominal) else {
+      return false
+    }
+    destroy.createDeinitCall(to: deinitFunc, context)
+    result = true
+  } else {
+    // If there is no deinit to be called for the original type we have to recursively visit
+    // the struct fields or enum cases.
+    if type.isStruct {
+      result = destroy.devirtualizeStructFields(context)
+    } else {
+      precondition(type.isEnum, "unknown nominal value type")
+      result = destroy.devirtualizeEnumPayloads(context)
+    }
+  }
+  context.erase(instruction: destroy)
+  return result
+}
+
+// Used to dispatch devirtualization tasks to `destroy_value` and `destroy_addr`.
+private protocol DevirtualizableDestroy : UnaryInstruction {
+  func createDeinitCall(to deinitializer: Function, _ context: some MutatingContext)
+  func devirtualizeStructFields(_ context: some MutatingContext) -> Bool
+  func devirtualizeEnumPayload(enumCase: EnumCase, in block: BasicBlock, _ context: some MutatingContext) -> Bool
+  func createSwitchEnum(atEndOf block: BasicBlock, cases: [(Int, BasicBlock)], _ context: some MutatingContext)
+}
+
+private extension DevirtualizableDestroy {
+  var type: Type { operand.value.type }
+
+  var hasDropDeinit: Bool { operand.value.lookThoughOwnershipInstructions is DropDeinitInst }
+
+  func devirtualizeEnumPayloads(_ context: some MutatingContext) -> Bool {
+    guard let cases = type.getEnumCases(in: parentFunction) else {
+      return false
+    }
+    if cases.allPayloadsAreTrivial(in: parentFunction) {
+      let builder = Builder(before: self, context)
+      builder.createEndLifetime(of: operand.value)
+      return true
+    }
+
+    var caseBlocks: [(caseIndex: Int, targetBlock: BasicBlock)] = []
+    let switchBlock = parentBlock
+    let endBlock = context.splitBlock(before: self)
+    var result = true
+
+    for enumCase in cases {
+      let caseBlock = context.createBlock(after: switchBlock)
+      caseBlocks.append((enumCase.index, caseBlock))
+      let builder = Builder(atEndOf: caseBlock, location: location, context)
+      builder.createBranch(to: endBlock)
+      if !devirtualizeEnumPayload(enumCase: enumCase, in: caseBlock, context) {
+        result = false
+      }
+    }
+    createSwitchEnum(atEndOf: switchBlock, cases: caseBlocks, context)
+    return result
+  }
+}
+
+extension DestroyValueInst : DevirtualizableDestroy {
+  fileprivate func createDeinitCall(to deinitializer: Function, _ context: some MutatingContext) {
+    let builder = Builder(before: self, context)
+    let subs = context.getContextSubstitutionMap(for: type)
+    let deinitRef = builder.createFunctionRef(deinitializer)
+    if deinitializer.getArgumentConvention(for: deinitializer.selfArgumentIndex).isIndirect {
+      let allocStack = builder.createAllocStack(type)
+      builder.createStore(source: destroyedValue, destination: allocStack, ownership: .initialize)
+      builder.createApply(function: deinitRef, subs, arguments: [allocStack])
+      builder.createDeallocStack(allocStack)
+    } else {
+      builder.createApply(function: deinitRef, subs, arguments: [destroyedValue])
+    }
+  }
+
+  fileprivate func devirtualizeStructFields(_ context: some MutatingContext) -> Bool {
+    let builder = Builder(before: self, context)
+
+    guard let fields = type.getNominalFields(in: parentFunction) else {
+      return false
+    }
+    if fields.allFieldsAreTrivial(in: parentFunction) {
+      builder.createEndLifetime(of: operand.value)
+      return true
+    }
+    let destructure = builder.createDestructureStruct(struct: destroyedValue)
+    var result = true
+
+    for fieldValue in destructure.results where !fieldValue.type.isTrivial(in: parentFunction) {
+      let destroyField = builder.createDestroyValue(operand: fieldValue)
+      if !devirtualizeDeinits(of: destroyField, context) {
+        result = false
+      }
+    }
+    return result
+  }
+
+  fileprivate func devirtualizeEnumPayload(
+    enumCase: EnumCase,
+    in block: BasicBlock,
+    _ context: some MutatingContext
+  ) -> Bool {
+    let builder = Builder(atBeginOf: block, location: location, context)
+    if let payloadTy = enumCase.payload {
+      let payload = block.addArgument(type: payloadTy, ownership: .owned, context)
+      if !payloadTy.isTrivial(in: parentFunction) {
+        let destroyPayload = builder.createDestroyValue(operand: payload)
+        return devirtualizeDeinits(of: destroyPayload, context)
+      }
+    }
+    return true
+  }
+
+  fileprivate func createSwitchEnum(
+    atEndOf block: BasicBlock,
+    cases: [(Int, BasicBlock)],
+    _ context: some MutatingContext
+  ) {
+    let builder = Builder(atEndOf: block, location: location, context)
+    builder.createSwitchEnum(enum: destroyedValue, cases: cases)
+  }
+}
+
+extension DestroyAddrInst : DevirtualizableDestroy {
+  fileprivate func createDeinitCall(to deinitializer: Function, _ context: some MutatingContext) {
+    let builder = Builder(before: self, context)
+    let subs = context.getContextSubstitutionMap(for: destroyedAddress.type)
+    let deinitRef = builder.createFunctionRef(deinitializer)
+    if !deinitializer.getArgumentConvention(for: deinitializer.selfArgumentIndex).isIndirect {
+      let value = builder.createLoad(fromAddress: destroyedAddress, ownership: .take)
+      builder.createApply(function: deinitRef, subs, arguments: [value])
+    } else {
+      builder.createApply(function: deinitRef, subs, arguments: [destroyedAddress])
+    }
+  }
+
+  fileprivate func devirtualizeStructFields(_ context: some MutatingContext) -> Bool {
+    let builder = Builder(before: self, context)
+
+    guard let fields = type.getNominalFields(in: parentFunction) else {
+      return false
+    }
+    if fields.allFieldsAreTrivial(in: parentFunction) {
+      builder.createEndLifetime(of: operand.value)
+      return true
+    }
+    var result = true
+    for (fieldIdx, fieldTy) in fields.enumerated()
+      where !fieldTy.isTrivial(in: parentFunction)
+    {
+      let fieldAddr = builder.createStructElementAddr(structAddress: destroyedAddress, fieldIndex: fieldIdx)
+      let destroyField = builder.createDestroyAddr(address: fieldAddr)
+      if !devirtualizeDeinits(of: destroyField, context) {
+        result = false
+      }
+    }
+    return result
+  }
+
+  fileprivate func devirtualizeEnumPayload(
+    enumCase: EnumCase,
+    in block: BasicBlock,
+    _ context: some MutatingContext
+  ) -> Bool {
+    let builder = Builder(atBeginOf: block, location: location, context)
+    if let payloadTy = enumCase.payload,
+       !payloadTy.isTrivial(in: parentFunction)
+    {
+      let caseAddr = builder.createUncheckedTakeEnumDataAddr(enumAddress: destroyedAddress, caseIndex: enumCase.index)
+      let destroyPayload = builder.createDestroyAddr(address: caseAddr)
+      return devirtualizeDeinits(of: destroyPayload, context)
+    }
+    return true
+  }
+
+  fileprivate func createSwitchEnum(
+    atEndOf block: BasicBlock,
+    cases: [(Int, BasicBlock)],
+    _ context: some MutatingContext
+  ) {
+    let builder = Builder(atEndOf: block, location: location, context)
+    builder.createSwitchEnumAddr(enumAddress: destroyedAddress, cases: cases)
+  }
+}
+
+private extension EnumCases {
+  func allPayloadsAreTrivial(in function: Function) -> Bool {
+    allSatisfy({ $0.payload?.isTrivial(in: function) ?? true })
+  }
+}
+
+private extension NominalFieldsArray {
+  func allFieldsAreTrivial(in function: Function) -> Bool {
+    allSatisfy({ $0.isTrivial(in: function)})
+  }
+}
diff --git a/include/swift/AST/DiagnosticsSIL.def b/include/swift/AST/DiagnosticsSIL.def
@@ -888,5 +888,9 @@ WARNING(call_site_transfer_yields_race, none,
 NOTE(possible_racy_access_site, none,
      "access here could race", ())
 
+// TODO: print the name of the nominal type
+ERROR(deinit_not_visible, none,
+      "deinit of non-copyable type not visible in the current module", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"
diff --git a/include/swift/SILOptimizer/OptimizerBridging.h b/include/swift/SILOptimizer/OptimizerBridging.h
@@ -268,6 +268,7 @@ struct BridgedPassContext {
                                                                           bool loadCalleesRecursively) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE void loadFunction(BridgedFunction function, bool loadCalleesRecursively) const;
   SWIFT_IMPORT_UNSAFE OptionalBridgedFunction lookupStdlibFunction(BridgedStringRef name) const;
+  SWIFT_IMPORT_UNSAFE OptionalBridgedFunction lookUpNominalDeinitFunction(BridgedNominalTypeDecl nominal) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedSubstitutionMap getContextSubstitutionMap(BridgedType type) const;
 
   // Passmanager housekeeping
diff --git a/include/swift/SILOptimizer/PassManager/Passes.def b/include/swift/SILOptimizer/PassManager/Passes.def
@@ -341,6 +341,8 @@ PASS(RedundantPhiElimination, "redundant-phi-elimination",
      "Redundant Phi Block Argument Elimination")
 PASS(PhiExpansion, "phi-expansion",
      "Replace Phi arguments by their only used field")
+SWIFT_FUNCTION_PASS(DeinitDevirtualizer, "deinit-devirtualizer",
+     "Devirtualizes destroys of non-copyable values")
 SWIFT_FUNCTION_PASS(ReleaseDevirtualizer, "release-devirtualizer",
      "SIL release Devirtualization")
 PASS(RetainSinking, "retain-sinking",
diff --git a/lib/SILOptimizer/PassManager/PassManager.cpp b/lib/SILOptimizer/PassManager/PassManager.cpp
@@ -1638,6 +1638,11 @@ OptionalBridgedFunction BridgedPassContext::lookupStdlibFunction(BridgedStringRe
   return {funcBuilder.getOrCreateFunction(SILLocation(decl), declRef, NotForDefinition)};
 }
 
+OptionalBridgedFunction BridgedPassContext::lookUpNominalDeinitFunction(BridgedNominalTypeDecl nominal)  const {
+  swift::SILModule *mod = invocation->getPassManager()->getModule();
+  return {mod->lookUpMoveOnlyDeinitFunction(nominal.unbridged())};
+}
+
 bool BridgedPassContext::enableSimplificationFor(BridgedInstruction inst) const {
   // Fast-path check.
   if (SimplifyInstructionTest.empty() && SILDisablePass.empty())
diff --git a/lib/SILOptimizer/PassManager/PassPipeline.cpp b/lib/SILOptimizer/PassManager/PassPipeline.cpp
@@ -71,6 +71,11 @@ llvm::cl::opt<bool>
     EnableDestroyHoisting("enable-destroy-hoisting", llvm::cl::init(false),
                           llvm::cl::desc("Enable the DestroyHoisting pass."));
 
+llvm::cl::opt<bool>
+    EnableDeinitDevirtualizer("enable-deinit-devirtualizer", llvm::cl::init(false),
+                          llvm::cl::desc("Enable the DestroyHoisting pass."));
+
+
 //===----------------------------------------------------------------------===//
 //                          Diagnostic Pass Pipeline
 //===----------------------------------------------------------------------===//
@@ -162,6 +167,10 @@ static void addMandatoryDiagnosticOptPipeline(SILPassPipelinePlan &P) {
 
   // Check noImplicitCopy and move only types for objects and addresses.
   P.addMoveOnlyChecker();
+
+  if (EnableDeinitDevirtualizer)
+    P.addDeinitDevirtualizer();
+
   // Lower move only wrapped trivial types.
   P.addTrivialMoveOnlyTypeEliminator();
   // Check no uses after consume operator of a value in an address.
diff --git a/test/SILOptimizer/devirt_deinits.sil b/test/SILOptimizer/devirt_deinits.sil
diff --git a/test/SILOptimizer/devirt_deinits.swift b/test/SILOptimizer/devirt_deinits.swift
diff --git a/test/SILOptimizer/moveonly_deinit_devirtualization.sil b/test/SILOptimizer/moveonly_deinit_devirtualization.sil
diff --git a/test/SILOptimizer/moveonly_deinit_devirtualization_library_evolution.sil b/test/SILOptimizer/moveonly_deinit_devirtualization_library_evolution.sil

Original file line number	Diff line number	Diff line change
`@@ -42,6 +42,10 @@ extension Context {`
`42`	`42`	`default: fatalError("unhandled SILStage case")`
`43`	`43`	`}`
`44`	`44`	`}`
	`45`	`+`
	`46`	`+ func lookupDeinit(ofNominal: NominalTypeDecl) -> Function? {`
	`47`	`+ _bridged.lookUpNominalDeinitFunction(ofNominal.bridged).function`
	`48`	`+ }`
`45`	`49`	`}`
`46`	`50`
`47`	`51`	`/// A context which allows mutation of a function's SIL.`