Merge pull request #80819 from eeckstein/copy-block-optimization

Optimizer: remove redundant `copy_block` instructions

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -19,6 +19,7 @@ swift_compiler_sources(Optimizer
   SimplifyCondBranch.swift
   SimplifyCondFail.swift
   SimplifyConvertEscapeToNoEscape.swift
+  SimplifyCopyBlock.swift
   SimplifyCopyValue.swift
   SimplifyDebugStep.swift
   SimplifyDestroyValue.swift

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyCopyBlock.swift

@@ -0,0 +1,70 @@
+//===--- SimplifyCopyBlock.swift ------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2025 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 CopyBlockInst : Simplifiable, SILCombineSimplifiable {
+
+  /// Removes a `copy_block` if its only uses, beside ownership instructions, are callees of function calls
+  /// ```
+  ///   %2 = copy_block %0
+  ///   %3 = begin_borrow [lexical] %2
+  ///   %4 = apply %3() : $@convention(block) @noescape () -> ()
+  ///   end_borrow %3
+  ///   destroy_value %2
+  /// ```
+  /// ->
+  /// ```
+  ///   %4 = apply %0() : $@convention(block) @noescape () -> ()
+  /// ```
+  ///
+  func simplify(_ context: SimplifyContext) {
+    if hasValidUses(block: self) {
+      replaceBlock( self, with: operand.value, context)
+      context.erase(instruction: self)
+    }
+  }
+}
+
+private func hasValidUses(block: Value) -> Bool {
+  for use in block.uses {
+    switch use.instruction {
+    case let beginBorrow as BeginBorrowInst:
+      if !hasValidUses(block: beginBorrow) {
+        return false
+      }
+    case let apply as FullApplySite where apply.isCallee(operand: use):
+      break
+    case is EndBorrowInst, is DestroyValueInst:
+      break
+    default:
+      return false
+    }
+  }
+  return true
+}
+
+private func replaceBlock(_ block: Value, with original: Value, _ context: SimplifyContext) {
+  for use in block.uses {
+    switch use.instruction {
+    case let beginBorrow as BeginBorrowInst:
+      replaceBlock(beginBorrow, with: original, context)
+      context.erase(instruction: beginBorrow)
+    case is FullApplySite:
+      use.set(to: original, context)
+    case is EndBorrowInst, is DestroyValueInst:
+      context.erase(instruction: use.instruction)
+    default:
+      fatalError("unhandled use")
+    }
+  }
+}

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -114,6 +114,7 @@ private func registerSwiftPasses() {
   registerForSILCombine(LoadInst.self,             { run(LoadInst.self, $0) })
   registerForSILCombine(LoadBorrowInst.self,       { run(LoadBorrowInst.self, $0) })
   registerForSILCombine(CopyValueInst.self,        { run(CopyValueInst.self, $0) })
+  registerForSILCombine(CopyBlockInst.self,        { run(CopyBlockInst.self, $0) })
   registerForSILCombine(DestroyValueInst.self,     { run(DestroyValueInst.self, $0) })
   registerForSILCombine(DestructureStructInst.self, { run(DestructureStructInst.self, $0) })
   registerForSILCombine(DestructureTupleInst.self, { run(DestructureTupleInst.self, $0) })

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -1071,7 +1071,7 @@ class ThinToThickFunctionInst : SingleValueInstruction, UnaryInstruction {
 final public class ThickToObjCMetatypeInst : SingleValueInstruction {}
 final public class ObjCToThickMetatypeInst : SingleValueInstruction {}
 
-final public class CopyBlockInst : SingleValueInstruction {}
+final public class CopyBlockInst : SingleValueInstruction, UnaryInstruction {}
 final public class CopyBlockWithoutEscapingInst : SingleValueInstruction {}
 
 final public

lib/SILOptimizer/SILCombiner/Simplifications.def

@@ -41,6 +41,7 @@ INSTRUCTION_SIMPLIFICATION(ReleaseValueInst)
 INSTRUCTION_SIMPLIFICATION(LoadInst)
 INSTRUCTION_SIMPLIFICATION(LoadBorrowInst)
 INSTRUCTION_SIMPLIFICATION(CopyValueInst)
+INSTRUCTION_SIMPLIFICATION(CopyBlockInst)
 INSTRUCTION_SIMPLIFICATION(DestroyValueInst)
 INSTRUCTION_SIMPLIFICATION(DestructureStructInst)
 INSTRUCTION_SIMPLIFICATION(DestructureTupleInst)

test/SILOptimizer/optimize_copy_block.swift

@@ -0,0 +1,39 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+// RUN: %target-swift-frontend -I %t %t/test.swift -O -emit-sil | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+//--- module.modulemap
+
+module CModule {
+  header "c-header.h"
+  export *
+}
+
+
+//--- c-header.h
+
+@import Foundation;
+
+@interface TestClass : NSObject
+- (void)callHandlerInline: (NS_NOESCAPE _Nonnull dispatch_block_t)block;
+@end
+
+
+//--- test.swift
+
+import CModule
+
+@objc @implementation
+extension TestClass {
+  // CHECK-LABEL: sil private [thunk] @$sSo9TestClassC4testE17callHandlerInlineyyyyXEFTo :
+  // CHECK-NOT:     copy_block
+  // CHECK:         apply %0
+  // CHECK-NOT:     destroy_value
+  // CHECK:       } // end sil function '$sSo9TestClassC4testE17callHandlerInlineyyyyXEFTo' 
+  func callHandlerInline(_ handler: () -> Void) {
+    handler()
+  }
+}
+

test/SILOptimizer/simplify_copy_block.sil

@@ -0,0 +1,59 @@
+// RUN: %target-sil-opt %s -simplification -simplify-instruction=copy_block | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+sil_stage canonical
+
+import Swift
+import SwiftShims
+import Builtin
+
+// CHECK-LABEL: sil [ossa] @remove_copy_block :
+// CHECK-NOT:     copy_block
+// CHECK:         apply %0
+// CHECK-NOT:     destroy_value
+// CHECK:       } // end sil function 'remove_copy_block'
+sil [ossa] @remove_copy_block : $@convention(thin) (@convention(block) @noescape () -> ()) -> () {
+bb0(%0 : @unowned $@convention(block) @noescape () -> ()):
+  %2 = copy_block %0
+  %3 = begin_borrow [lexical] %2
+  %4 = apply %3() : $@convention(block) @noescape () -> ()
+  end_borrow %3
+  destroy_value %2
+  %7 = tuple ()
+  return %7
+}
+
+// CHECK-LABEL: sil [ossa] @dont_remove_copied_block :
+// CHECK:         copy_block
+// CHECK:       } // end sil function 'dont_remove_copied_block'
+sil [ossa] @dont_remove_copied_block : $@convention(thin) (@convention(block) @noescape () -> ()) -> () {
+bb0(%0 : @unowned $@convention(block) @noescape () -> ()):
+  %2 = copy_block %0
+  %3 = begin_borrow [lexical] %2
+  %4 = apply %3() : $@convention(block) @noescape () -> ()
+  %5 = copy_value %3
+  fix_lifetime %5
+  destroy_value %5
+  end_borrow %3
+  destroy_value %2
+  %7 = tuple ()
+  return %7
+}
+
+sil [ossa] @use_block : $@convention(thin) (@convention(block) @noescape () -> ()) -> ()
+
+// CHECK-LABEL: sil [ossa] @dont_remove_escaping_block :
+// CHECK:         copy_block
+// CHECK:       } // end sil function 'dont_remove_escaping_block'
+sil [ossa] @dont_remove_escaping_block : $@convention(thin) (@convention(block) @noescape () -> ()) -> () {
+bb0(%0 : @unowned $@convention(block) @noescape () -> ()):
+  %2 = copy_block %0
+  %3 = begin_borrow [lexical] %2
+  %4 = function_ref @use_block : $@convention(thin) (@convention(block) @noescape () -> ()) -> ()
+  %5 = apply %4(%3) : $@convention(thin) (@convention(block) @noescape () -> ()) -> ()
+  end_borrow %3
+  destroy_value %2
+  %7 = tuple ()
+  return %7
+}