[SILGen] Fix a crash when a closure is converted to a pointer to a

function returning a non-trivial C++ type

rdar://124501345

Author: ahatanaka

lib/IRGen/IRGenSIL.cpp

@@ -2338,7 +2338,9 @@ static void emitEntryPointArgumentsCOrObjC(IRGenSILFunction &IGF,
   // First, claim all the indirect results.
   ArrayRef<SILArgument *> args = emitEntryPointIndirectReturn(
       *emission, IGF, entry, funcTy, [&](SILType directResultType) -> bool {
-        return FI.getReturnInfo().isIndirect();
+        // Indirect at the IR level but direct at the SIL level.
+        return FI.getReturnInfo().isIndirect() &&
+               !funcTy->hasIndirectFormalResults();
       });
 
   unsigned nextArgTyIdx = 0;

lib/SILGen/SILGenBridging.cpp

@@ -1363,8 +1363,10 @@ emitObjCThunkArguments(SILGenFunction &SGF, SILLocation loc, SILDeclRef thunk,
   }
 
   // We don't know what to do with indirect results from the Objective-C side.
-  assert(objcFnTy->getNumIndirectFormalResults() == 0
-         && "Objective-C methods cannot have indirect results");
+  assert((SGF.F.getRepresentation() ==
+              SILFunctionType::Representation::CFunctionPointer ||
+          objcFnTy->getNumIndirectFormalResults() == 0) &&
+         "Objective-C methods cannot have indirect results");
 
   auto bridgedFormalTypes = getParameterTypes(objcFormalFnTy.getParams());
   bridgedFormalResultTy = objcFormalFnTy.getResult();
@@ -1625,12 +1627,18 @@ void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
   // stack allocation to hold the result(s), since Any is address-only.
   SmallVector<SILValue, 4> args;
   if (substConv.hasIndirectSILResults()) {
-    for (auto result : substConv.getResults()) {
-      if (!substConv.isSILIndirect(result)) {
-        continue;
+    if (F.getRepresentation() ==
+        SILFunctionType::Representation::CFunctionPointer) {
+      args.push_back(F.begin()->createFunctionArgument(
+          substConv.getSingleSILResultType(getTypeExpansionContext())));
+    } else {
+      for (auto result : substConv.getResults()) {
+        if (!substConv.isSILIndirect(result)) {
+          continue;
+        }
+        args.push_back(emitTemporaryAllocation(
+            loc, substConv.getSILType(result, getTypeExpansionContext())));
       }
-      args.push_back(emitTemporaryAllocation(
-                loc, substConv.getSILType(result, getTypeExpansionContext())));
     }
   }
 
@@ -1868,12 +1876,14 @@ void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
     if (foreignAsync) {
       result = passResultToCompletionHandler(result);
     } else {
-      if (substConv.hasIndirectSILResults()) {
-        assert(substTy->getNumResults() == 1);
-        result = args[0];
+      if (F.getRepresentation() != SILFunctionType::Representation::CFunctionPointer) {
+        if (substConv.hasIndirectSILResults()) {
+          assert(substTy->getNumResults() == 1);
+          result = args[0];
+        }
+        result = emitBridgeReturnValue(*this, loc, result, nativeFormalResultType,
+                                       bridgedFormalResultType, objcResultTy);
       }
-      result = emitBridgeReturnValue(*this, loc, result, nativeFormalResultType,
-                                     bridgedFormalResultType, objcResultTy);
     }
   } else {
     SILBasicBlock *contBB = createBasicBlock();

test/Interop/Cxx/class/Inputs/closure.h

@@ -20,4 +20,6 @@ struct ARCStrong {
 void cfuncARCStrong(void (*_Nonnull)(ARCStrong));
 #endif
 
+void cfuncReturnNonTrivial2(NonTrivial (*_Nonnull)());
+
 #endif // __CLOSURE__

test/Interop/Cxx/class/closure-thunk-irgen.swift

@@ -0,0 +1,13 @@
+// RUN: %target-swiftxx-frontend -I %S/Inputs -emit-irgen %s | %FileCheck %s
+
+// REQUIRES: OS=macosx || OS=linux-android
+
+import Closure
+
+// CHECK: define internal void @"$s4main36testClosureToFuncPtrReturnNonTrivialyyFSo0hI0VycfU_To"(ptr noalias sret(%{{.*}}) %[[V0:.*]])
+// CHECK: call swiftcc void @"$s4main36testClosureToFuncPtrReturnNonTrivialyyFSo0hI0VycfU_"(ptr noalias sret(%{{.*}}) %[[V0]])
+// CHECK: ret void
+
+public func testClosureToFuncPtrReturnNonTrivial() {
+  cfuncReturnNonTrivial2({() -> NonTrivial in return NonTrivial()});
+}

test/Interop/Cxx/class/closure-thunk.swift

@@ -19,3 +19,13 @@ import Closure
 public func testClosureToFuncPtr() {
  cfunc2({N in})
 }
+
+// CHECK: sil private [thunk] [ossa] @$s4main36testClosureToFuncPtrReturnNonTrivialyyFSo0hI0VycfU_To : $@convention(c) () -> @out NonTrivial {
+// CHECK: bb0(%[[V0:.*]] : $*NonTrivial):
+// CHECK: %[[V1:.*]] = function_ref @$s4main36testClosureToFuncPtrReturnNonTrivialyyFSo0hI0VycfU_ : $@convention(thin) () -> @out NonTrivial // user: %[[V2]]
+// CHECK: %[[V2:.*]] = apply %[[V1]](%[[V0]]) : $@convention(thin) () -> @out NonTrivial // user: %[[V3]]
+// CHECK: return %[[V2]] : $()
+
+public func testClosureToFuncPtrReturnNonTrivial() {
+  cfuncReturnNonTrivial2({() -> NonTrivial in return NonTrivial()});
+}