[interop] ensure we correctly handle copy constructor invokes

Author: hyp

lib/IRGen/GenDecl.cpp

@@ -3252,26 +3252,35 @@ llvm::Constant *swift::irgen::emitCXXConstructorThunkIfNeeded(
     Args.push_back(arg);
   }
 
-  bool canThrow = IGM.isForeignExceptionHandlingEnabled();
-  if (auto *fpt = ctor->getType()->getAs<clang::FunctionProtoType>()) {
-    if (fpt->isNothrow())
-      canThrow = false;
-  }
-  if (canThrow) {
+  auto *call =
+      emitCXXConstructorCall(subIGF, ctor, ctorFnType, ctorAddress, Args);
+  if (isa<llvm::InvokeInst>(call))
     IGM.emittedForeignFunctionThunksWithExceptionTraps.insert(thunk);
-    subIGF.createExceptionTrapScope([&](llvm::BasicBlock *invokeNormalDest,
-                                        llvm::BasicBlock *invokeUnwindDest) {
-      subIGF.Builder.createInvoke(ctorFnType, ctorAddress, Args,
-                                  invokeNormalDest, invokeUnwindDest);
-    });
-  } else
-    subIGF.Builder.CreateCall(ctorFnType, ctorAddress, Args);
-
   subIGF.Builder.CreateRetVoid();
 
   return thunk;
 }
 
+llvm::CallBase *swift::irgen::emitCXXConstructorCall(
+    IRGenFunction &IGF, const clang::CXXConstructorDecl *ctor,
+    llvm::FunctionType *ctorFnType, llvm::Constant *ctorAddress,
+    llvm::ArrayRef<llvm::Value *> args) {
+  bool canThrow = IGF.IGM.isForeignExceptionHandlingEnabled();
+  if (auto *fpt = ctor->getType()->getAs<clang::FunctionProtoType>()) {
+    if (fpt->isNothrow())
+      canThrow = false;
+  }
+  if (!canThrow)
+    return IGF.Builder.CreateCall(ctorFnType, ctorAddress, args);
+  llvm::CallBase *result;
+  IGF.createExceptionTrapScope([&](llvm::BasicBlock *invokeNormalDest,
+                                   llvm::BasicBlock *invokeUnwindDest) {
+    result = IGF.Builder.createInvoke(ctorFnType, ctorAddress, args,
+                                      invokeNormalDest, invokeUnwindDest);
+  });
+  return result;
+}
+
 StackProtectorMode IRGenModule::shouldEmitStackProtector(SILFunction *f) {
   const SILOptions &opts = IRGen.SIL.getOptions();
   return (opts.EnableStackProtection && f->needsStackProtection()) ?

lib/IRGen/GenDecl.h

@@ -29,6 +29,7 @@ namespace llvm {
   class AttributeList;
   class Function;
   class FunctionType;
+  class CallBase;
 }
 namespace swift {
 namespace irgen {
@@ -69,6 +70,12 @@ namespace irgen {
   emitCXXConstructorThunkIfNeeded(IRGenModule &IGM, Signature signature,
                                   const clang::CXXConstructorDecl *ctor,
                                   StringRef name, llvm::Constant *ctorAddress);
+
+  llvm::CallBase *emitCXXConstructorCall(IRGenFunction &IGF,
+                                         const clang::CXXConstructorDecl *ctor,
+                                         llvm::FunctionType *ctorFnType,
+                                         llvm::Constant *ctorAddress,
+                                         llvm::ArrayRef<llvm::Value *> args);
 }
 }
 

lib/IRGen/GenStruct.cpp

@@ -567,6 +567,7 @@ namespace {
       auto callee = cast<llvm::Function>(clangFnAddr->stripPointerCasts());
       Signature signature = IGF.IGM.getSignature(fnType);
       std::string name = "__swift_cxx_copy_ctor" + callee->getName().str();
+      auto *origClangFnAddr = clangFnAddr;
       clangFnAddr = emitCXXConstructorThunkIfNeeded(
           IGF.IGM, signature, copyConstructor, name, clangFnAddr);
       callee = cast<llvm::Function>(clangFnAddr);
@@ -576,7 +577,19 @@ namespace {
         src = IGF.coerceValue(src, callee->getFunctionType()->getParamType(1),
                               IGF.IGM.DataLayout);
       }
-      IGF.Builder.CreateCall(callee->getFunctionType(), callee, {dest, src});
+      llvm::Value *args[] = {dest, src};
+      if (clangFnAddr == origClangFnAddr) {
+        // Ensure we can use 'invoke' to trap on uncaught exceptions when
+        // calling original copy constructor without going through the thunk.
+        emitCXXConstructorCall(IGF, copyConstructor, callee->getFunctionType(),
+                               callee, args);
+        return;
+      }
+      // Check if we're calling a thunk that traps on exception thrown from copy
+      // constructor.
+      if (IGF.IGM.emittedForeignFunctionThunksWithExceptionTraps.count(callee))
+        IGF.setCallsThunksWithForeignExceptionTraps();
+      IGF.Builder.CreateCall(callee->getFunctionType(), callee, args);
     }
 
   public:

test/Interop/Cxx/exceptions/trap-on-exception-irgen-itanium.swift

@@ -369,19 +369,15 @@ let _ = testClassWithNoThrowingConstructor()
 // CHECK-NOT: invoke
 // CHECK: }
 
-// CHECK: define {{.*}} @"$s4test0A32ClassWithThrowingCopyConstructors5Int32VyF"() #[[#SWIFTMETA]] personality
+// CHECK: define {{.*}} @"$s4test0A32ClassWithThrowingCopyConstructors5Int32VyF"() #[[#SWIFTUWMETA]] personality
 // CHECK: invoke {{.*}} @_ZN32ClassWithThrowingCopyConstructorC1ERKS_(
 // CHECK-NEXT:  to label %[[CONT41:.*]] unwind label %[[UNWIND41:.*]]
-// CHECK-EMPTY:
-// CHECK-NEXT: [[UNWIND41]]:
+
+// CHECK: [[UNWIND41]]:
 // CHECK-NEXT: landingpad { i8*, i32 }
 // CHECK-NEXT:    catch i8* null
 // CHECK-NEXT: call void @llvm.trap()
 // CHECK-NEXT: unreachable
-// CHECK-EMPTY:
-// CHECK: [[CONT41]]:
-// CHECK: ret i32
-// CHECK-NEXT: }
 
 // CHECK: define {{.*}} @"$s4test0A28ClassWithThrowingConstructors5Int32VyF"() #[[#SWIFTUWMETA]] personality
 // CHECK: invoke {{.*}} @_ZN28ClassWithThrowingConstructorC{{.*}}(