Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

lib/IRGen/CallEmission.h

@@ -63,15 +63,25 @@ class CallEmission {
   /// RemainingArgsForCallee, at least between calls.
   bool EmittedCall;
 
+  /// The basic block to which the call to a potentially throwing foreign
+  /// function should jump to continue normal execution of the program.
+  llvm::BasicBlock *invokeNormalDest = nullptr;
+
+  /// The basic block to which the call to a potentially throwing foreign
+  /// function should jump to in case an exception has been thrown during the
+  /// invocation of the call.
+  llvm::BasicBlock *invokeUnwindDest = nullptr;
+
   virtual void setFromCallee();
   void emitToUnmappedMemory(Address addr);
   void emitToUnmappedExplosion(Explosion &out);
-  virtual void emitCallToUnmappedExplosion(llvm::CallInst *call, Explosion &out) = 0;
+  virtual void emitCallToUnmappedExplosion(llvm::CallBase *call,
+                                           Explosion &out) = 0;
   void emitYieldsToExplosion(Explosion &out);
   virtual FunctionPointer getCalleeFunctionPointer() = 0;
-  llvm::CallInst *emitCallSite();
+  llvm::CallBase *emitCallSite();
 
-  virtual llvm::CallInst *createCall(const FunctionPointer &fn,
+  virtual llvm::CallBase *createCall(const FunctionPointer &fn,
                                      ArrayRef<llvm::Value *> args) = 0;
 
   CallEmission(IRGenFunction &IGF, llvm::Value *selfValue, Callee &&callee)
@@ -105,7 +115,7 @@ class CallEmission {
                     bool isOutlined);
   void emitToExplosion(Explosion &out, bool isOutlined);
 
-  llvm::CallInst *emitCoroutineAsOrdinaryFunction() {
+  llvm::CallBase *emitCoroutineAsOrdinaryFunction() {
     assert(IsCoroutine);
     IsCoroutine = false;
 

lib/IRGen/Callee.h

@@ -331,6 +331,14 @@ namespace irgen {
     llvm::Type *awaitSignature = nullptr;
     bool useSignature = false;
 
+    // True when this function pointer points to a non-throwing foreign
+    // function.
+    bool isForeignNoThrow = false;
+
+    // True when this function pointer points to a foreign function that traps
+    // on exception in the always_inline thunk.
+    bool foreignCallCatchesExceptionInThunk = false;
+
     explicit FunctionPointer(Kind kind, llvm::Value *value,
                              const Signature &signature)
         : FunctionPointer(kind, value, PointerAuthInfo(), signature) {}
@@ -491,6 +499,24 @@ namespace irgen {
     bool shouldSuppressPolymorphicArguments() const {
       return kind.shouldSuppressPolymorphicArguments();
     }
+
+    void setForeignNoThrow() { isForeignNoThrow = true; }
+
+    bool canThrowForeignException() const {
+      return getForeignInfo().canThrow && !isForeignNoThrow;
+    }
+
+    void setForeignCallCatchesExceptionInThunk() {
+      foreignCallCatchesExceptionInThunk = true;
+    }
+
+    bool doesForeignCallCatchExceptionInThunk() {
+      return foreignCallCatchesExceptionInThunk;
+    }
+
+    bool shouldUseInvoke() const {
+      return canThrowForeignException() && !foreignCallCatchesExceptionInThunk;
+    }
   };
 
   class Callee {

lib/IRGen/GenCall.cpp

@@ -1984,6 +1984,9 @@ Signature SignatureExpansion::getSignature() {
   result.Attributes = Attrs;
   using ExtraData = Signature::ExtraData;
   if (FnType->getLanguage() == SILFunctionLanguage::C) {
+    // This is a potentially throwing function. The use of 'noexcept' /
+    // 'nothrow' is applied at the call site in the \c FunctionPointer class.
+    ForeignInfo.canThrow = IGM.isForeignExceptionHandlingEnabled();
     result.ExtraDataKind = ExtraData::kindForMember<ForeignFunctionInfo>();
     result.ExtraDataStorage.emplace<ForeignFunctionInfo>(result.ExtraDataKind,
                                                          ForeignInfo);
@@ -2230,9 +2233,10 @@ class SyncCallEmission final : public CallEmission {
         index, IGF.IGM.getMaximalTypeExpansionContext());
   }
 
-  llvm::CallInst *createCall(const FunctionPointer &fn,
+  llvm::CallBase *createCall(const FunctionPointer &fn,
                              ArrayRef<llvm::Value *> args) override {
-    return IGF.Builder.CreateCall(fn, Args);
+    return IGF.Builder.CreateCallOrInvoke(fn, Args, invokeNormalDest,
+                                          invokeUnwindDest);
   }
 
   void begin() override { super::begin(); }
@@ -2379,7 +2383,8 @@ class SyncCallEmission final : public CallEmission {
     }
     super::setArgs(adjusted, isOutlined, witnessMetadata);
   }
-  void emitCallToUnmappedExplosion(llvm::CallInst *call, Explosion &out) override {
+  void emitCallToUnmappedExplosion(llvm::CallBase *call,
+                                   Explosion &out) override {
     // Bail out immediately on a void result.
     llvm::Value *result = call;
     if (result->getType()->isVoidTy())
@@ -2682,7 +2687,8 @@ class AsyncCallEmission final : public CallEmission {
       saveValue(resumeParentField, fnVal, isOutlined);
     }
   }
-  void emitCallToUnmappedExplosion(llvm::CallInst *call, Explosion &out) override {
+  void emitCallToUnmappedExplosion(llvm::CallBase *call,
+                                   Explosion &out) override {
     // Bail out on a void result type.
     auto &IGM = IGF.IGM;
     llvm::Value *result = call;
@@ -2774,7 +2780,7 @@ class AsyncCallEmission final : public CallEmission {
     return IGF.getCalleeErrorResultSlot(errorType);
   }
 
-  llvm::CallInst *createCall(const FunctionPointer &fn,
+  llvm::CallBase *createCall(const FunctionPointer &fn,
                              ArrayRef<llvm::Value *> args) override {
     auto &IGM = IGF.IGM;
     auto &Builder = IGF.Builder;
@@ -2904,7 +2910,7 @@ void CallEmission::emitToUnmappedMemory(Address result) {
 }
 
 /// The private routine to ultimately emit a call or invoke instruction.
-llvm::CallInst *CallEmission::emitCallSite() {
+llvm::CallBase *CallEmission::emitCallSite() {
   assert(state == State::Emitting);
   assert(LastArgWritten == 0);
   assert(!EmittedCall);
@@ -2925,8 +2931,16 @@ llvm::CallInst *CallEmission::emitCallSite() {
       Args[i] = IGF.coerceValue(Args[i], paramTy, IGF.IGM.DataLayout);
   }
 
-  // TODO: exceptions!
+  if (fn.canThrowForeignException()) {
+    if (!fn.doesForeignCallCatchExceptionInThunk()) {
+      invokeNormalDest = IGF.createBasicBlock("invoke.cont");
+      invokeUnwindDest = IGF.createExceptionUnwindBlock();
+    } else
+      IGF.setCallsThunksWithForeignExceptionTraps();
+  }
   auto call = createCall(fn, Args);
+  if (invokeNormalDest)
+    IGF.Builder.emitBlock(invokeNormalDest);
 
   // Make coroutines calls opaque to LLVM analysis.
   if (IsCoroutine) {
@@ -2988,8 +3002,9 @@ assertTypesInByValAndStructRetAttributes(llvm::FunctionType *fnType,
   return attrList;
 }
 
-llvm::CallInst *IRBuilder::CreateCall(const FunctionPointer &fn,
-                                      ArrayRef<llvm::Value*> args) {
+llvm::CallBase *IRBuilder::CreateCallOrInvoke(
+    const FunctionPointer &fn, ArrayRef<llvm::Value *> args,
+    llvm::BasicBlock *invokeNormalDest, llvm::BasicBlock *invokeUnwindDest) {
   assert(fn.getKind() == FunctionPointer::Kind::Function);
   SmallVector<llvm::OperandBundleDef, 1> bundles;
 
@@ -3003,8 +3018,13 @@ llvm::CallInst *IRBuilder::CreateCall(const FunctionPointer &fn,
 
   assert(!isTrapIntrinsic(fn.getRawPointer()) && "Use CreateNonMergeableTrap");
   auto fnTy = cast<llvm::FunctionType>(fn.getFunctionType());
-  llvm::CallInst *call =
-      IRBuilderBase::CreateCall(fnTy, fn.getRawPointer(), args, bundles);
+  llvm::CallBase *call;
+  if (!fn.shouldUseInvoke())
+    call = IRBuilderBase::CreateCall(fnTy, fn.getRawPointer(), args, bundles);
+  else
+    call =
+        IRBuilderBase::CreateInvoke(fnTy, fn.getRawPointer(), invokeNormalDest,
+                                    invokeUnwindDest, args, bundles);
 
   llvm::AttributeList attrs = fn.getAttributes();
   // If a parameter of a function is SRet, the corresponding argument should be
@@ -3028,6 +3048,13 @@ llvm::CallInst *IRBuilder::CreateCall(const FunctionPointer &fn,
   return call;
 }
 
+llvm::CallInst *IRBuilder::CreateCall(const FunctionPointer &fn,
+                                      ArrayRef<llvm::Value *> args) {
+  assert(!fn.shouldUseInvoke());
+  return cast<llvm::CallInst>(CreateCallOrInvoke(
+      fn, args, /*invokeNormalDest=*/nullptr, /*invokeUnwindDest=*/nullptr));
+}
+
 /// Emit the result of this call to memory.
 void CallEmission::emitToMemory(Address addr,
                                 const LoadableTypeInfo &indirectedResultTI,
@@ -4425,6 +4452,40 @@ void IRGenFunction::emitBBForReturn() {
   CurFn->getBasicBlockList().push_back(ReturnBB);
 }
 
+llvm::BasicBlock *IRGenFunction::createExceptionUnwindBlock() {
+  auto *result = createBasicBlock("exception.unwind");
+  IRBuilder::SavedInsertionPointRAII insertRAII(Builder, result);
+
+  // Create a catch-all landing pad.
+  // FIXME: Refactor Clang/lib/CodeGen to call into Clang here.
+  // FIXME: MSVC support.
+  llvm::LandingPadInst *lpad = Builder.CreateLandingPad(
+      llvm::StructType::get(IGM.Int8PtrTy, IGM.Int32Ty), 0);
+  lpad->addClause(llvm::ConstantPointerNull::get(IGM.Int8PtrTy));
+
+  // The trap with a message informs the user that the exception hasn't
+  // been caught. The trap creates a new debug inline frame for the message,
+  // so ensure that the current debug location is preserved.
+  auto oldDebugLoc = Builder.getCurrentDebugLocation();
+  emitTrap(IGM.Context.LangOpts.EnableObjCInterop
+               ? "unhandled C++ / Objective-C exception"
+               : "unhandled C++ exception",
+           /*Unreachable=*/true);
+  Builder.SetCurrentDebugLocation(oldDebugLoc);
+
+  ExceptionUnwindBlocks.push_back(result);
+  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.
@@ -4475,12 +4536,42 @@ bool IRGenFunction::emitBranchToReturnBB() {
   return true;
 }
 
+llvm::Function *IRGenModule::getForeignExceptionHandlingPersonalityFunc() {
+  if (foreignExceptionHandlingPersonalityFunc)
+    return foreignExceptionHandlingPersonalityFunc;
+  foreignExceptionHandlingPersonalityFunc = llvm::Function::Create(
+      llvm::FunctionType::get(Int32Ty, true), llvm::Function::ExternalLinkage,
+      "__gxx_personality_v0", getModule());
+  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)
     EarliestIP->eraseFromParent();
   // Destroy the alloca insertion point.
   AllocaIP->eraseFromParent();
+  // Add exception unwind blocks and additional exception handling info
+  // if needed.
+  if (!ExceptionUnwindBlocks.empty() ||
+      callsAnyAlwaysInlineThunksWithForeignExceptionTraps) {
+    // The function should have an unwind table when catching exceptions.
+    CurFn->addFnAttr(llvm::Attribute::getWithUWTableKind(
+        *IGM.LLVMContext, llvm::UWTableKind::Default));
+    CurFn->setPersonalityFn(IGM.getForeignExceptionHandlingPersonalityFunc());
+  }
+  for (auto *bb : ExceptionUnwindBlocks)
+    CurFn->getBasicBlockList().push_back(bb);
 }
 
 std::pair<Address, Size>

lib/IRGen/GenDecl.cpp

@@ -3236,12 +3236,35 @@ llvm::Constant *swift::irgen::emitCXXConstructorThunkIfNeeded(
     Args.push_back(arg);
   }
 
-  subIGF.Builder.CreateCall(ctorFnType, ctorAddress, Args);
+  auto *call =
+      emitCXXConstructorCall(subIGF, ctor, ctorFnType, ctorAddress, Args);
+  if (isa<llvm::InvokeInst>(call))
+    IGM.emittedForeignFunctionThunksWithExceptionTraps.insert(thunk);
   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

@@ -579,6 +579,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);
@@ -588,7 +589,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:
@@ -653,6 +666,23 @@ namespace {
                                         IGF.IGM.DataLayout);
         args.push_back(implicitParam);
       }
+      bool canThrow = false;
+      if (IGF.IGM.isForeignExceptionHandlingEnabled()) {
+        if (auto *fpt =
+                destructor->getType()->getAs<clang::FunctionProtoType>()) {
+          if (!fpt->isNothrow())
+            canThrow = true;
+        }
+      }
+      if (canThrow) {
+        IGF.createExceptionTrapScope([&](llvm::BasicBlock *invokeNormalDest,
+                                         llvm::BasicBlock *invokeUnwindDest) {
+          IGF.Builder.createInvoke(destructorFnAddr->getFunctionType(),
+                                   destructorFnAddr, args, invokeNormalDest,
+                                   invokeUnwindDest);
+        });
+        return;
+      }
 
       IGF.Builder.CreateCall(destructorFnAddr->getFunctionType(),
                              destructorFnAddr, args);