Optimizer: add simplification for the convert_escape_to_noescape instruction

Including the required bridging stuff.

  %2 = thin_to_thick_function %1 to $() -> ()
  %3 = convert_escape_to_noescape %2 : $() -> () to $@NoEscape () -> ()
->
  %3 = thin_to_thick_function %1 to $@NoEscape () -> ()

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -13,6 +13,7 @@ swift_compiler_sources(Optimizer
   SimplifyBuiltin.swift
   SimplifyCondBranch.swift
   SimplifyCondFail.swift
+  SimplifyConvertEscapeToNoEscape.swift
   SimplifyDebugStep.swift
   SimplifyDestructure.swift
   SimplifyGlobalValue.swift

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/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())
   }

include/swift/SIL/SILBridging.h

@@ -129,6 +129,7 @@ struct BridgedType {
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedStringRef getFieldName(SwiftInt idx) const;
   BRIDGED_INLINE SwiftInt getNumTupleElements() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedType getTupleElementType(SwiftInt idx) const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedType getFunctionTypeWithNoEscape(bool withNoEscape) const;
 };
 
 // AST bridging
@@ -899,6 +900,8 @@ struct BridgedBuilder{
                                           SwiftInt caseIdx, BridgedType resultType) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createEnum(SwiftInt caseIdx, OptionalBridgedValue payload,
                                           BridgedType resultType) const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createThinToThickFunction(BridgedValue fn,
+                                                                                  BridgedType resultType) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createBranch(BridgedBasicBlock destBlock,
                                                                      BridgedValueArray arguments) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createUnreachable() const;

include/swift/SIL/SILBridgingImpl.h

@@ -217,6 +217,12 @@ BridgedType BridgedType::getTupleElementType(SwiftInt idx) const {
   return get().getTupleElementType(idx);
 }
 
+BridgedType BridgedType::getFunctionTypeWithNoEscape(bool withNoEscape) const {
+  auto fnType = get().getAs<swift::SILFunctionType>();
+  auto newTy = fnType->getWithExtInfo(fnType->getExtInfo().withNoEscape(true));
+  return swift::SILType::getPrimitiveObjectType(newTy);
+}
+
 //===----------------------------------------------------------------------===//
 //                                BridgedNominalTypeDecl
 //===----------------------------------------------------------------------===//
@@ -1352,6 +1358,10 @@ BridgedInstruction BridgedBuilder::createEnum(SwiftInt caseIdx, OptionalBridgedV
   return {get().createEnum(regularLoc(), pl, caseDecl, resultType.get())};
 }
 
+BridgedInstruction BridgedBuilder::createThinToThickFunction(BridgedValue fn, BridgedType resultType) const {
+  return {get().createThinToThickFunction(regularLoc(), fn.getSILValue(), resultType.get())};
+}
+
 BridgedInstruction BridgedBuilder::createBranch(BridgedBasicBlock destBlock, BridgedValueArray arguments) const {
   llvm::SmallVector<swift::SILValue, 16> argValues;
   return {get().createBranch(regularLoc(), destBlock.get(), arguments.getValues(argValues))};

test/SILOptimizer/simplify_convert_escape_to_noescape.sil

@@ -0,0 +1,28 @@
+// RUN: %target-sil-opt -enable-sil-verify-all %s -onone-simplification -simplify-instruction=convert_escape_to_noescape | %FileCheck %s
+
+// REQUIRES: swift_in_compiler
+
+sil_stage canonical
+
+import Builtin
+import Swift
+import SwiftShims
+
+sil @cl : $@convention(thin) () -> Int
+
+// CHECK-LABEL: sil [ossa] @remove_convert :
+// CHECK:         [[F:%.*]] = thin_to_thick_function %0 : $@convention(thin) () -> Int to $@noescape @callee_guaranteed () -> Int
+// CHECK-NEXT:    apply [[F]]() : $@noescape
+// CHECK-NEXT:    destroy_value [[F]]
+// CHECK:       } // end sil function 'remove_convert'
+sil [ossa] @remove_convert : $@convention(thin) () -> Int {
+bb0:
+  %0 = function_ref @cl : $@convention(thin) () -> Int
+  %1 = thin_to_thick_function %0 : $@convention(thin) () -> Int to $@callee_guaranteed () -> Int
+  %2 = convert_escape_to_noescape %1 : $@callee_guaranteed () -> Int to $@noescape @callee_guaranteed () -> Int
+  %3 = apply %2() : $@noescape @callee_guaranteed () -> Int
+  destroy_value %2 : $@noescape @callee_guaranteed () -> Int
+  return %3 : $Int
+}
+
+