ClosureSpecializer: don't specialize captures of stack-allocated Objective-C blocks

Bail if the closure captures an ObjectiveC block which might _not_ be copied onto the heap, i.e optimized by SimplifyCopyBlock.
We can't do this because the optimization inserts retains+releases for captured arguments.
That's not possible for stack-allocated blocks.

Fixes a mis-compile
rdar://154241245

Author: eeckstein

lib/SILOptimizer/IPO/ClosureSpecializer.cpp

@@ -694,6 +694,19 @@ static bool isSupportedClosure(const SILInstruction *Closure) {
         return false;
       }
 
+      // Bail if it's an ObjectiveC block which might _not_ be copied onto the heap, i.e
+      // optimized by SimplifyCopyBlock. We can't do this because the optimization inserts
+      // retains+releases for captured arguments. That's not possible for stack-allocated blocks.
+      // TODO: avoid inserting retains+releases at all for captures of `partial_apply [on_stack]`
+      if (ArgTy.is<SILFunctionType>() &&
+          ArgTy.getFunctionRepresentation() == SILFunctionTypeRepresentation::Block &&
+          // A `copy_block` ensures that the block is copied onto the heap.
+          !isa<CopyBlockInst>(Arg) &&
+          // SimplifyCopyBlock only works for `partial_apply [on_stack]`.
+          PAI->isOnStack()) {
+        return false;
+      }
+
       // Only @inout/@inout_aliasable addresses are (currently) supported.
       // If our argument is an object, continue...
       if (ArgTy.isObject()) {

test/SILOptimizer/closure_specialize_block.swift

@@ -0,0 +1,20 @@
+// RUN: %target-swift-frontend -parse-as-library -O %s -emit-sil | %FileCheck %s
+
+func callClosure<R>(_ body: () -> R) -> R {
+  return body()
+}
+
+// Check that after removing a copy_block, no retains+releases are inserted for the block.
+// CHECK-LABEL: sil {{.*}}@testit :
+// CHECK-NOT:     retain
+// CHECK-NOT:     release
+// CHECK:       } // end sil function 'testit'
+@_cdecl("testit")
+public func testit(_ block: (_ index: Int) -> Int) -> Bool {
+  @inline(never)
+  func c() -> Bool {
+	  return block(0) != 0
+  }
+
+	return callClosure(c)
+}