Merge pull request swiftlang#69401 from eeckstein/noallocation-with-precondition

Add some instruction simplifications to make `precondition()` not allocate in Onone builds

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -13,7 +13,10 @@ swift_compiler_sources(Optimizer
   SimplifyBuiltin.swift
   SimplifyCondBranch.swift
   SimplifyCondFail.swift
+  SimplifyConvertEscapeToNoEscape.swift
+  SimplifyCopyValue.swift
   SimplifyDebugStep.swift
+  SimplifyDestroyValue.swift
   SimplifyDestructure.swift
   SimplifyGlobalValue.swift
   SimplifyInitEnumDataAddr.swift

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyApply.swift

@@ -14,6 +14,9 @@ import SIL
 
 extension ApplyInst : OnoneSimplifyable {
   func simplify(_ context: SimplifyContext) {
+    if tryTransformThickToThinCallee(of: self, context) {
+      return
+    }
     _ = context.tryDevirtualize(apply: self, isMandatory: false)
   }
 }
@@ -29,3 +32,29 @@ extension BeginApplyInst : OnoneSimplifyable {
     _ = context.tryDevirtualize(apply: self, isMandatory: false)
   }
 }
+
+/// Optimizes a thick function call if the callee is a `thin_to_thick_function` instruction:
+///
+///   %2 = thin_to_thick_function %1
+///   %3 = apply %2(...) : @callee_guaranteed
+/// ->
+///   %2 = thin_to_thick_function %1
+///   %3 = apply %1(...): @convention(thin)
+///
+private func tryTransformThickToThinCallee(of apply: ApplyInst, _ context: SimplifyContext) -> Bool {
+  if let tttf = apply.callee as? ThinToThickFunctionInst,
+     !apply.callee.type.isCalleeConsumedFunction
+  {
+    let builder = Builder(before: apply, context)
+    let newApply = builder.createApply(function: tttf.operand.value,
+                                       apply.substitutionMap,
+                                       arguments: Array(apply.arguments),
+                                       isNonThrowing: apply.isNonThrowing,
+                                       isNonAsync: apply.isNonAsync,
+                                       specializationInfo: apply.specializationInfo)
+    apply.uses.replaceAll(with: newApply, context)
+    context.erase(instruction: apply)
+    return true
+  }
+  return false
+}

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyConvertEscapeToNoEscape.swift

@@ -0,0 +1,40 @@
+//===--- SimplifyConvertEscapeToNoEscape.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
+
+extension ConvertEscapeToNoEscapeInst : OnoneSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+    tryCombineWithThinToThickOperand(context)
+  }
+}
+
+private extension ConvertEscapeToNoEscapeInst {
+
+  /// Combine with a thin_to_thick_function operand:
+  ///
+  ///   %2 = thin_to_thick_function %1 to $() -> ()
+  ///   %3 = convert_escape_to_noescape %2 : $() -> () to $@noescape () -> ()
+  /// ->
+  ///   %3 = thin_to_thick_function %1 to $@noescape () -> ()
+
+  func tryCombineWithThinToThickOperand(_ context: SimplifyContext) {
+    if let thinToThick = fromFunction as? ThinToThickFunctionInst {
+      let builder = Builder(before: self, context)
+      let noEscapeFnType = thinToThick.type.getFunctionType(withNoEscape: true)
+      let newThinToThick = builder.createThinToThickFunction(thinFunction: thinToThick.operand.value,
+                                                             resultType: noEscapeFnType)
+      uses.replaceAll(with: newThinToThick, context)
+      context.erase(instruction: self)
+    }
+  }
+}

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyCopyValue.swift

@@ -0,0 +1,22 @@
+//===--- SimplifyCopyValue.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
+
+extension CopyValueInst : OnoneSimplifyable, SILCombineSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+    if fromValue.ownership == .none {
+      uses.replaceAll(with: fromValue, context)
+      context.erase(instruction: self)
+    }
+  }
+}

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyDestroyValue.swift

@@ -0,0 +1,21 @@
+//===--- SimplifyDestroyValue.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
+
+extension DestroyValueInst : OnoneSimplifyable, SILCombineSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+    if destroyedValue.ownership == .none {
+      context.erase(instruction: self)
+    }
+  }
+}

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -97,6 +97,8 @@ private func registerSwiftPasses() {
   registerForSILCombine(RetainValueInst.self,      { run(RetainValueInst.self, $0) })
   registerForSILCombine(ReleaseValueInst.self,     { run(ReleaseValueInst.self, $0) })
   registerForSILCombine(LoadInst.self,             { run(LoadInst.self, $0) })
+  registerForSILCombine(CopyValueInst.self,        { run(CopyValueInst.self, $0) })
+  registerForSILCombine(DestroyValueInst.self,     { run(DestroyValueInst.self, $0) })
 
   // Test passes
   registerPass(functionUsesDumper, { functionUsesDumper.run($0) })

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -220,6 +220,11 @@ public struct Builder {
     return notifyNew(enumInst.getAs(EnumInst.self))
   }
 
+  public func createThinToThickFunction(thinFunction: Value, resultType: Type) -> ThinToThickFunctionInst {
+    let tttf = bridged.createThinToThickFunction(thinFunction.bridged, resultType.bridged)
+    return notifyNew(tttf.getAs(ThinToThickFunctionInst.self))
+  }
+
   @discardableResult
   public func createSwitchEnum(enum enumVal: Value,
                                cases: [(Int, BasicBlock)],

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -794,6 +794,11 @@ class ConvertFunctionInst : SingleValueInstruction, ConversionInstruction {
 final public
 class ThinToThickFunctionInst : SingleValueInstruction, ConversionInstruction {}
 
+final public
+class ConvertEscapeToNoEscapeInst : SingleValueInstruction, UnaryInstruction {
+  public var fromFunction: Value { operand.value }
+}
+
 final public
 class ObjCExistentialMetatypeToObjectInst : SingleValueInstruction,
                                             ConversionInstruction {}

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -131,6 +131,7 @@ public func registerSILClasses() {
   register(UnconditionalCheckedCastInst.self)
   register(ConvertFunctionInst.self)
   register(ThinToThickFunctionInst.self)
+  register(ConvertEscapeToNoEscapeInst.self)
   register(ObjCExistentialMetatypeToObjectInst.self)
   register(ObjCMetatypeToObjectInst.self)
   register(ValueToBridgeObjectInst.self)

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -111,6 +111,10 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
     return idx >= 0 ? idx : nil
   }
 
+  public func getFunctionType(withNoEscape: Bool) -> Type {
+    bridged.getFunctionTypeWithNoEscape(withNoEscape).type
+  }
+
   public var description: String {
     String(taking: bridged.getDebugDescription())
   }