[interop] trap on uncaught C++ copy constructor exceptions

hyp · hyp · commit 8998f9769af2 · 2023-02-22T10:59:53.000-08:00
diff --git a/lib/IRGen/GenCall.cpp b/lib/IRGen/GenCall.cpp
@@ -1982,17 +1982,9 @@ Signature SignatureExpansion::getSignature() {
   result.Attributes = Attrs;
   using ExtraData = Signature::ExtraData;
   if (FnType->getLanguage() == SILFunctionLanguage::C) {
-    const auto &clangLangOpts =
-        IGM.Context.getClangModuleLoader()->getClangASTContext().getLangOpts();
-    bool exceptionHandlingEnabled = IGM.Context.LangOpts.EnableCXXInterop &&
-                                    clangLangOpts.Exceptions &&
-                                    !clangLangOpts.IgnoreExceptions;
-    // FIXME: Support exceptions on windows MSVC.
-    if (IGM.Triple.isWindowsMSVCEnvironment())
-      exceptionHandlingEnabled = false;
     // This is a potentially throwing function. The use of 'noexcept' /
     // 'nothrow' is applied at the call site in the \c FunctionPointer class.
-    ForeignInfo.canThrow = exceptionHandlingEnabled;
+    ForeignInfo.canThrow = IGM.isForeignExceptionHandlingEnabled();
     result.ExtraDataKind = ExtraData::kindForMember<ForeignFunctionInfo>();
     result.ExtraDataStorage.emplace<ForeignFunctionInfo>(result.ExtraDataKind,
                                                          ForeignInfo);
@@ -4473,6 +4465,15 @@ llvm::BasicBlock *IRGenFunction::createExceptionUnwindBlock() {
   return result;
 }
 
+void IRGenFunction::createExceptionTrapScope(
+    llvm::function_ref<void(llvm::BasicBlock *, llvm::BasicBlock *)>
+        invokeEmitter) {
+  auto *invokeNormalDest = createBasicBlock("invoke.cont");
+  auto *invokeUnwindDest = createExceptionUnwindBlock();
+  invokeEmitter(invokeNormalDest, invokeUnwindDest);
+  Builder.emitBlock(invokeNormalDest);
+}
+
 /// Emit the prologue for the function.
 void IRGenFunction::emitPrologue() {
   // Set up the IRBuilder.
@@ -4532,6 +4533,16 @@ llvm::Function *IRGenModule::getForeignExceptionHandlingPersonalityFunc() {
   return foreignExceptionHandlingPersonalityFunc;
 }
 
+bool IRGenModule::isForeignExceptionHandlingEnabled() const {
+  // FIXME: Support exceptions on windows MSVC.
+  if (Triple.isWindowsMSVCEnvironment())
+    return false;
+  const auto &clangLangOpts =
+      Context.getClangModuleLoader()->getClangASTContext().getLangOpts();
+  return Context.LangOpts.EnableCXXInterop && clangLangOpts.Exceptions &&
+         !clangLangOpts.IgnoreExceptions;
+}
+
 /// Emit the epilogue for the function.
 void IRGenFunction::emitEpilogue() {
   if (EarliestIP != AllocaIP)
diff --git a/lib/IRGen/GenDecl.cpp b/lib/IRGen/GenDecl.cpp
@@ -3252,7 +3252,20 @@ llvm::Constant *swift::irgen::emitCXXConstructorThunkIfNeeded(
     Args.push_back(arg);
   }
 
-  subIGF.Builder.CreateCall(ctorFnType, ctorAddress, Args);
+  bool canThrow = IGM.isForeignExceptionHandlingEnabled();
+  if (auto *fpt = ctor->getType()->getAs<clang::FunctionProtoType>()) {
+    if (fpt->isNothrow())
+      canThrow = false;
+  }
+  if (canThrow)
+    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;
diff --git a/lib/IRGen/GenStruct.cpp b/lib/IRGen/GenStruct.cpp
@@ -648,12 +648,12 @@ namespace {
           canThrow = true;
       }
       if (canThrow) {
-        auto *invokeNormalDest = IGF.createBasicBlock("invoke.cont");
-        auto *invokeUnwindDest = IGF.createExceptionUnwindBlock();
-        IGF.Builder.createInvoke(destructorFnAddr->getFunctionType(),
-                                 destructorFnAddr, args, invokeNormalDest,
-                                 invokeUnwindDest);
-        IGF.Builder.emitBlock(invokeNormalDest);
+        IGF.createExceptionTrapScope([&](llvm::BasicBlock *invokeNormalDest,
+                                         llvm::BasicBlock *invokeUnwindDest) {
+          IGF.Builder.createInvoke(destructorFnAddr->getFunctionType(),
+                                   destructorFnAddr, args, invokeNormalDest,
+                                   invokeUnwindDest);
+        });
         return;
       }
 
diff --git a/lib/IRGen/IRGenFunction.h b/lib/IRGen/IRGenFunction.h
@@ -105,6 +105,10 @@ class IRGenFunction {
 
   llvm::BasicBlock *createExceptionUnwindBlock();
 
+  void createExceptionTrapScope(
+      llvm::function_ref<void(llvm::BasicBlock *, llvm::BasicBlock *)>
+          invokeEmitter);
+
   void emitAllExtractValues(llvm::Value *aggValue, llvm::StructType *type,
                             Explosion &out);
 
diff --git a/lib/IRGen/IRGenModule.h b/lib/IRGen/IRGenModule.h
@@ -1807,6 +1807,8 @@ private:                                                                       \
 
   llvm::Function *getForeignExceptionHandlingPersonalityFunc();
 
+  bool isForeignExceptionHandlingEnabled() const;
+
 private:
   llvm::Constant *
   getAddrOfSharedContextDescriptor(LinkEntity entity,
diff --git a/test/Interop/Cxx/exceptions/exceptions-disabled-exception-irgen.swift b/test/Interop/Cxx/exceptions/exceptions-disabled-exception-irgen.swift
@@ -24,6 +24,13 @@ inline int freeFunctionNoThrow(int x) noexcept {
   return -x;
 }
 
+class ClassWithThrowingCopyConstructor {
+public:
+  int m = 0;
+  inline ClassWithThrowingCopyConstructor() noexcept {}
+  inline ClassWithThrowingCopyConstructor(const ClassWithThrowingCopyConstructor &) { (void)freeFunctionThrows(0); }
+};
+
 //--- test.swift
 
 import CxxModule
@@ -43,8 +50,15 @@ func testFreeFunctionCalls() -> CInt {
   return p
 }
 
+func testClassWithThrowingCopyConstructor() -> CInt {
+  let p1 = ClassWithThrowingCopyConstructor()
+  let p2 = p1
+  return p2.m
+}
+
 let _ = testFreeFunctionNoThrowOnly()
 let _ = testFreeFunctionCalls()
+let _ = testClassWithThrowingCopyConstructor()
 
 // CHECK: define {{.*}} @"$s4test0A23FreeFunctionNoThrowOnlys5Int32VyF"() #[[#SWIFTMETA:]] {
 // CHECK-NEXT: :
@@ -60,3 +74,7 @@ let _ = testFreeFunctionCalls()
 // CHECK: call i32 @{{_Z18freeFunctionThrowsi|"\?freeFunctionThrows@@YAHH@Z"}}(i32
 // CHECK: ret i32
 // CHECK-NEXT: }
+
+// CHECK: define {{.*}} @"$s4test0A32ClassWithThrowingCopyConstructors5Int32VyF"() #[[#SWIFTMETA]] {
+// CHECK-NOT: invoke
+// CHECK: }
diff --git a/test/Interop/Cxx/exceptions/trap-on-exception-execution.swift b/test/Interop/Cxx/exceptions/trap-on-exception-execution.swift
@@ -9,7 +9,7 @@
 // RUN: %target-codesign %t/trap-exceptions-no-debug
 // RUN: %target-run %t/trap-exceptions-no-debug
 
-// RUN: %target-build-swift %s -I %t/Inputs -o %t/trap-exceptions-opt -Xfrontend -enable-experimental-cxx-interop -Xfrontend -validate-tbd-against-ir=none -O
+// RUN: %target-build-swift %s -I %t/Inputs -o %t/trap-exceptions-opt -Xfrontend -enable-experimental-cxx-interop -Xfrontend -validate-tbd-against-ir=none -O -DOPTIMIZE
 // RUN: %target-codesign %t/trap-exceptions-opt
 // RUN: %target-run %t/trap-exceptions-opt
 
@@ -93,4 +93,14 @@ TrapOnExecutionTestSuite.test("TestClassWithThrowingDestructor") {
   let _ = ClassWithThrowingDestructor()
 }
 
+#if OPTIMIZE
+#else
+TrapOnExecutionTestSuite.test("TestClassWithThrowingCopyConstructor") {
+  expectCrashLater()
+  let p1 = ClassWithThrowingCopyConstructor()
+  let p2 = p1
+  expectEqual(p2.m, 0)
+}
+#endif
+
 runAllTests()
diff --git a/test/Interop/Cxx/exceptions/trap-on-exception-irgen-itanium.swift b/test/Interop/Cxx/exceptions/trap-on-exception-irgen-itanium.swift
@@ -105,6 +105,20 @@ public:
   }
 };
 
+class ClassWithCopyConstructor {
+public:
+  int m = 0;
+  inline ClassWithCopyConstructor() noexcept {}
+  inline ClassWithCopyConstructor(const ClassWithCopyConstructor &) noexcept { (void)freeFunctionNoThrow(0); }
+};
+
+class ClassWithThrowingCopyConstructor {
+public:
+  int m = 0;
+  inline ClassWithThrowingCopyConstructor() noexcept {}
+  inline ClassWithThrowingCopyConstructor(const ClassWithThrowingCopyConstructor &) { throw 2; }
+};
+
 //--- test.swift
 
 import CxxModule
@@ -179,6 +193,18 @@ func testClassWithThrowingDestructor() {
   let _ = ClassWithThrowingDestructor()
 }
 
+func testClassWithCopyConstructor() -> CInt {
+  let p1 = ClassWithCopyConstructor()
+  let p2 = p1
+  return p2.m
+}
+
+func testClassWithThrowingCopyConstructor() -> CInt {
+  let p1 = ClassWithThrowingCopyConstructor()
+  let p2 = p1
+  return p2.m
+}
+
 let _ = testFreeFunctionNoThrowOnly()
 let _ = testFreeFunctionCalls()
 let _ = testMethodCalls()
@@ -189,6 +215,8 @@ testProtocolConformanceThunkInvoke()
 let _ = testSubscriptThunkInvoke()
 testClassWithDestructor()
 testClassWithThrowingDestructor()
+let _ = testClassWithCopyConstructor()
+let _ = testClassWithThrowingCopyConstructor()
 
 // CHECK: define {{.*}} @"$s4test0A23FreeFunctionNoThrowOnlys5Int32VyF"() #[[#SWIFTMETA:]] {
 // CHECK-NEXT: :
@@ -313,6 +341,24 @@ testClassWithThrowingDestructor()
 // CHECK-NEXT: unreachable
 // CHECK-NEXT: }
 
+// CHECK: define {{.*}} @"$s4test0A24ClassWithCopyConstructors5Int32VyF"() #[[#SWIFTMETA]]
+// CHECK-NOT: invoke
+// CHECK: }
+
+// CHECK: define {{.*}} @"$s4test0A32ClassWithThrowingCopyConstructors5Int32VyF"() #[[#SWIFTMETA]] personality
+// CHECK: invoke {{.*}} @_ZN32ClassWithThrowingCopyConstructorC1ERKS_(
+// CHECK-NEXT:  to label %[[CONT41:.*]] unwind label %[[UNWIND41:.*]]
+// CHECK-EMPTY:
+// CHECK-NEXT: [[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: i32 @__gxx_personality_v0(...)
 
 // CHECK: attributes #[[#SWIFTMETA]] = {
