[interop] trap on uncaught C++ destructor exceptions

Author: hyp

lib/IRGen/GenStruct.cpp

@@ -641,6 +641,21 @@ namespace {
                                         IGF.IGM.DataLayout);
         args.push_back(implicitParam);
       }
+      bool canThrow = false;
+      if (auto *fpt =
+              destructor->getType()->getAs<clang::FunctionProtoType>()) {
+        if (!fpt->isNothrow())
+          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);
+        return;
+      }
 
       IGF.Builder.CreateCall(destructorFnAddr->getFunctionType(),
                              destructorFnAddr, args);

lib/IRGen/IRBuilder.h

@@ -52,7 +52,7 @@ class IRBuilder : public IRBuilderBase {
   // Set calling convention of the call instruction using
   // the same calling convention as the callee function.
   // This ensures that they are always compatible.
-  void setCallingConvUsingCallee(llvm::CallInst *Call) {
+  void setCallingConvUsingCallee(llvm::CallBase *Call) {
     auto CalleeFn = Call->getCalledFunction();
     if (CalleeFn) {
       auto CC = CalleeFn->getCallingConv();
@@ -337,6 +337,17 @@ class IRBuilder : public IRBuilderBase {
     return Call;
   }
 
+  llvm::InvokeInst *
+  createInvoke(llvm::FunctionType *fTy, llvm::Constant *callee,
+               ArrayRef<llvm::Value *> args, llvm::BasicBlock *invokeNormalDest,
+               llvm::BasicBlock *invokeUnwindDest, const Twine &name = "") {
+    assert((!DebugInfo || getCurrentDebugLocation()) && "no debugloc on call");
+    auto call = IRBuilderBase::CreateInvoke(fTy, callee, invokeNormalDest,
+                                            invokeUnwindDest, args, name);
+    setCallingConvUsingCallee(call);
+    return call;
+  }
+
   llvm::CallBase *CreateCallOrInvoke(const FunctionPointer &fn,
                                      ArrayRef<llvm::Value *> args,
                                      llvm::BasicBlock *invokeNormalDest,

test/Interop/Cxx/exceptions/trap-on-exception-execution.swift

@@ -88,4 +88,9 @@ TrapOnExecutionTestSuite.test("TestClassWithSubscript") {
   let _ = v[1]
 }
 
+TrapOnExecutionTestSuite.test("TestClassWithThrowingDestructor") {
+  expectCrashLater()
+  let _ = ClassWithThrowingDestructor()
+}
+
 runAllTests()

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

@@ -89,6 +89,22 @@ public:
   }
 };
 
+class ClassWithDestructor {
+  int m = 0;
+public:
+  inline ~ClassWithDestructor() {
+    (void)freeFunctionNoThrow(0);
+  }
+};
+
+class ClassWithThrowingDestructor {
+  int m = 0;
+public:
+  inline ~ClassWithThrowingDestructor() noexcept(false) {
+    throw 2;
+  }
+};
+
 //--- test.swift
 
 import CxxModule
@@ -155,6 +171,14 @@ func testSubscriptThunkInvoke() -> CInt {
   return v[0]
 }
 
+func testClassWithDestructor() {
+  let _ = ClassWithDestructor()
+}
+
+func testClassWithThrowingDestructor() {
+  let _ = ClassWithThrowingDestructor()
+}
+
 let _ = testFreeFunctionNoThrowOnly()
 let _ = testFreeFunctionCalls()
 let _ = testMethodCalls()
@@ -163,6 +187,8 @@ testFuncPtrCall()
 testCFuncPtrCall()
 testProtocolConformanceThunkInvoke()
 let _ = testSubscriptThunkInvoke()
+testClassWithDestructor()
+testClassWithThrowingDestructor()
 
 // CHECK: define {{.*}} @"$s4test0A23FreeFunctionNoThrowOnlys5Int32VyF"() #[[#SWIFTMETA:]] {
 // CHECK-NEXT: :
@@ -257,7 +283,7 @@ let _ = testSubscriptThunkInvoke()
 // CHECK-NEXT: ret i32
 // CHECK-EMPTY:
 // CHECK-NEXT: [[UNWIND30]]:
-// CHECK-NEXT: %4 = landingpad { i8*, i32 }
+// CHECK-NEXT: landingpad { i8*, i32 }
 // CHECK-NEXT:    catch i8* null
 // CHECK-NEXT: call void @llvm.trap()
 // CHECK-NEXT: unreachable
@@ -270,6 +296,23 @@ let _ = testSubscriptThunkInvoke()
 // CHECK: define {{.*}} @"$s4test0A20SubscriptThunkInvokes5Int32VyF"() #[[#SWIFTUWMETA]]
 // CHECK: invoke i32 @_ZNK18ClassWithSubscriptixEi
 
+// CHECK: define {{.*}} @"$s4test0A19ClassWithDestructoryyF"() #[[#SWIFTMETA]]
+// CHECK-NOT: invoke
+// CHECK: }
+
+// CHECK: define {{.*}} @"$s4test0A27ClassWithThrowingDestructoryyF"() #[[#SWIFTUWMETA]]
+// CHECK: invoke {{.*}} @_ZN27ClassWithThrowingDestructorD{{.*}}(
+// CHECK-NEXT:  to label %[[CONT40:.*]] unwind label %[[UNWIND40:.*]]
+// CHECK: [[CONT40]]:
+// CHECK: ret void
+// CHECK-EMPTY:
+// CHECK-NEXT: [[UNWIND40]]:
+// CHECK-NEXT: landingpad { i8*, i32 }
+// CHECK-NEXT:    catch i8* null
+// CHECK-NEXT: call void @llvm.trap()
+// CHECK-NEXT: unreachable
+// CHECK-NEXT: }
+
 // CHECK: i32 @__gxx_personality_v0(...)
 
 // CHECK: attributes #[[#SWIFTMETA]] = {