1 //===--- CGException.cpp - Emit LLVM Code for C++ exceptions --------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This contains code dealing with C++ exception related code generation.
12 //===----------------------------------------------------------------------===//
14 #include "CodeGenFunction.h"
15 #include "CGCleanup.h"
16 #include "CGObjCRuntime.h"
17 #include "TargetInfo.h"
18 #include "clang/AST/StmtCXX.h"
19 #include "clang/AST/StmtObjC.h"
20 #include "llvm/IR/CallSite.h"
21 #include "llvm/IR/Intrinsics.h"
23 using namespace clang;
24 using namespace CodeGen;
26 static llvm::Constant *getAllocateExceptionFn(CodeGenModule &CGM) {
27 // void *__cxa_allocate_exception(size_t thrown_size);
29 llvm::FunctionType *FTy =
30 llvm::FunctionType::get(CGM.Int8PtrTy, CGM.SizeTy, /*IsVarArgs=*/false);
32 return CGM.CreateRuntimeFunction(FTy, "__cxa_allocate_exception");
35 static llvm::Constant *getFreeExceptionFn(CodeGenModule &CGM) {
36 // void __cxa_free_exception(void *thrown_exception);
38 llvm::FunctionType *FTy =
39 llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
41 return CGM.CreateRuntimeFunction(FTy, "__cxa_free_exception");
44 static llvm::Constant *getThrowFn(CodeGenModule &CGM) {
45 // void __cxa_throw(void *thrown_exception, std::type_info *tinfo,
46 // void (*dest) (void *));
48 llvm::Type *Args[3] = { CGM.Int8PtrTy, CGM.Int8PtrTy, CGM.Int8PtrTy };
49 llvm::FunctionType *FTy =
50 llvm::FunctionType::get(CGM.VoidTy, Args, /*IsVarArgs=*/false);
52 return CGM.CreateRuntimeFunction(FTy, "__cxa_throw");
55 static llvm::Constant *getReThrowFn(CodeGenModule &CGM) {
56 // void __cxa_rethrow();
58 llvm::FunctionType *FTy =
59 llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false);
61 return CGM.CreateRuntimeFunction(FTy, "__cxa_rethrow");
64 static llvm::Constant *getGetExceptionPtrFn(CodeGenModule &CGM) {
65 // void *__cxa_get_exception_ptr(void*);
67 llvm::FunctionType *FTy =
68 llvm::FunctionType::get(CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
70 return CGM.CreateRuntimeFunction(FTy, "__cxa_get_exception_ptr");
73 static llvm::Constant *getBeginCatchFn(CodeGenModule &CGM) {
74 // void *__cxa_begin_catch(void*);
76 llvm::FunctionType *FTy =
77 llvm::FunctionType::get(CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
79 return CGM.CreateRuntimeFunction(FTy, "__cxa_begin_catch");
82 static llvm::Constant *getEndCatchFn(CodeGenModule &CGM) {
83 // void __cxa_end_catch();
85 llvm::FunctionType *FTy =
86 llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false);
88 return CGM.CreateRuntimeFunction(FTy, "__cxa_end_catch");
91 static llvm::Constant *getUnexpectedFn(CodeGenModule &CGM) {
92 // void __cxa_call_unexpected(void *thrown_exception);
94 llvm::FunctionType *FTy =
95 llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
97 return CGM.CreateRuntimeFunction(FTy, "__cxa_call_unexpected");
100 static llvm::Constant *getTerminateFn(CodeGenModule &CGM) {
101 // void __terminate();
103 llvm::FunctionType *FTy =
104 llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false);
108 // In C++, use std::terminate().
109 if (CGM.getLangOpts().CPlusPlus)
110 name = "_ZSt9terminatev"; // FIXME: mangling!
111 else if (CGM.getLangOpts().ObjC1 &&
112 CGM.getLangOpts().ObjCRuntime.hasTerminate())
113 name = "objc_terminate";
116 return CGM.CreateRuntimeFunction(FTy, name);
119 static llvm::Constant *getCatchallRethrowFn(CodeGenModule &CGM,
121 llvm::FunctionType *FTy =
122 llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
124 return CGM.CreateRuntimeFunction(FTy, Name);
128 /// The exceptions personality for a function.
129 struct EHPersonality {
130 const char *PersonalityFn;
132 // If this is non-null, this personality requires a non-standard
133 // function for rethrowing an exception after a catchall cleanup.
134 // This function must have prototype void(void*).
135 const char *CatchallRethrowFn;
137 static const EHPersonality &get(const LangOptions &Lang);
138 static const EHPersonality GNU_C;
139 static const EHPersonality GNU_C_SJLJ;
140 static const EHPersonality GNU_ObjC;
141 static const EHPersonality GNUstep_ObjC;
142 static const EHPersonality GNU_ObjCXX;
143 static const EHPersonality NeXT_ObjC;
144 static const EHPersonality GNU_CPlusPlus;
145 static const EHPersonality GNU_CPlusPlus_SJLJ;
149 const EHPersonality EHPersonality::GNU_C = { "__gcc_personality_v0", nullptr };
151 EHPersonality::GNU_C_SJLJ = { "__gcc_personality_sj0", nullptr };
153 EHPersonality::NeXT_ObjC = { "__objc_personality_v0", nullptr };
155 EHPersonality::GNU_CPlusPlus = { "__gxx_personality_v0", nullptr };
157 EHPersonality::GNU_CPlusPlus_SJLJ = { "__gxx_personality_sj0", nullptr };
159 EHPersonality::GNU_ObjC = {"__gnu_objc_personality_v0", "objc_exception_throw"};
161 EHPersonality::GNU_ObjCXX = { "__gnustep_objcxx_personality_v0", nullptr };
163 EHPersonality::GNUstep_ObjC = { "__gnustep_objc_personality_v0", nullptr };
165 static const EHPersonality &getCPersonality(const LangOptions &L) {
166 if (L.SjLjExceptions)
167 return EHPersonality::GNU_C_SJLJ;
168 return EHPersonality::GNU_C;
171 static const EHPersonality &getObjCPersonality(const LangOptions &L) {
172 switch (L.ObjCRuntime.getKind()) {
173 case ObjCRuntime::FragileMacOSX:
174 return getCPersonality(L);
175 case ObjCRuntime::MacOSX:
176 case ObjCRuntime::iOS:
177 return EHPersonality::NeXT_ObjC;
178 case ObjCRuntime::GNUstep:
179 if (L.ObjCRuntime.getVersion() >= VersionTuple(1, 7))
180 return EHPersonality::GNUstep_ObjC;
182 case ObjCRuntime::GCC:
183 case ObjCRuntime::ObjFW:
184 return EHPersonality::GNU_ObjC;
186 llvm_unreachable("bad runtime kind");
189 static const EHPersonality &getCXXPersonality(const LangOptions &L) {
190 if (L.SjLjExceptions)
191 return EHPersonality::GNU_CPlusPlus_SJLJ;
193 return EHPersonality::GNU_CPlusPlus;
196 /// Determines the personality function to use when both C++
197 /// and Objective-C exceptions are being caught.
198 static const EHPersonality &getObjCXXPersonality(const LangOptions &L) {
199 switch (L.ObjCRuntime.getKind()) {
200 // The ObjC personality defers to the C++ personality for non-ObjC
201 // handlers. Unlike the C++ case, we use the same personality
202 // function on targets using (backend-driven) SJLJ EH.
203 case ObjCRuntime::MacOSX:
204 case ObjCRuntime::iOS:
205 return EHPersonality::NeXT_ObjC;
207 // In the fragile ABI, just use C++ exception handling and hope
208 // they're not doing crazy exception mixing.
209 case ObjCRuntime::FragileMacOSX:
210 return getCXXPersonality(L);
212 // The GCC runtime's personality function inherently doesn't support
213 // mixed EH. Use the C++ personality just to avoid returning null.
214 case ObjCRuntime::GCC:
215 case ObjCRuntime::ObjFW: // XXX: this will change soon
216 return EHPersonality::GNU_ObjC;
217 case ObjCRuntime::GNUstep:
218 return EHPersonality::GNU_ObjCXX;
220 llvm_unreachable("bad runtime kind");
223 const EHPersonality &EHPersonality::get(const LangOptions &L) {
224 if (L.CPlusPlus && L.ObjC1)
225 return getObjCXXPersonality(L);
226 else if (L.CPlusPlus)
227 return getCXXPersonality(L);
229 return getObjCPersonality(L);
231 return getCPersonality(L);
234 static llvm::Constant *getPersonalityFn(CodeGenModule &CGM,
235 const EHPersonality &Personality) {
237 CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty, true),
238 Personality.PersonalityFn);
242 static llvm::Constant *getOpaquePersonalityFn(CodeGenModule &CGM,
243 const EHPersonality &Personality) {
244 llvm::Constant *Fn = getPersonalityFn(CGM, Personality);
245 return llvm::ConstantExpr::getBitCast(Fn, CGM.Int8PtrTy);
248 /// Check whether a personality function could reasonably be swapped
249 /// for a C++ personality function.
250 static bool PersonalityHasOnlyCXXUses(llvm::Constant *Fn) {
251 for (llvm::User *U : Fn->users()) {
252 // Conditionally white-list bitcasts.
253 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(U)) {
254 if (CE->getOpcode() != llvm::Instruction::BitCast) return false;
255 if (!PersonalityHasOnlyCXXUses(CE))
260 // Otherwise, it has to be a landingpad instruction.
261 llvm::LandingPadInst *LPI = dyn_cast<llvm::LandingPadInst>(U);
262 if (!LPI) return false;
264 for (unsigned I = 0, E = LPI->getNumClauses(); I != E; ++I) {
265 // Look for something that would've been returned by the ObjC
266 // runtime's GetEHType() method.
267 llvm::Value *Val = LPI->getClause(I)->stripPointerCasts();
268 if (LPI->isCatch(I)) {
269 // Check if the catch value has the ObjC prefix.
270 if (llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Val))
271 // ObjC EH selector entries are always global variables with
272 // names starting like this.
273 if (GV->getName().startswith("OBJC_EHTYPE"))
276 // Check if any of the filter values have the ObjC prefix.
277 llvm::Constant *CVal = cast<llvm::Constant>(Val);
278 for (llvm::User::op_iterator
279 II = CVal->op_begin(), IE = CVal->op_end(); II != IE; ++II) {
280 if (llvm::GlobalVariable *GV =
281 cast<llvm::GlobalVariable>((*II)->stripPointerCasts()))
282 // ObjC EH selector entries are always global variables with
283 // names starting like this.
284 if (GV->getName().startswith("OBJC_EHTYPE"))
294 /// Try to use the C++ personality function in ObjC++. Not doing this
295 /// can cause some incompatibilities with gcc, which is more
296 /// aggressive about only using the ObjC++ personality in a function
297 /// when it really needs it.
298 void CodeGenModule::SimplifyPersonality() {
299 // If we're not in ObjC++ -fexceptions, there's nothing to do.
300 if (!LangOpts.CPlusPlus || !LangOpts.ObjC1 || !LangOpts.Exceptions)
303 // Both the problem this endeavors to fix and the way the logic
304 // above works is specific to the NeXT runtime.
305 if (!LangOpts.ObjCRuntime.isNeXTFamily())
308 const EHPersonality &ObjCXX = EHPersonality::get(LangOpts);
309 const EHPersonality &CXX = getCXXPersonality(LangOpts);
313 assert(std::strcmp(ObjCXX.PersonalityFn, CXX.PersonalityFn) != 0 &&
314 "Different EHPersonalities using the same personality function.");
316 llvm::Function *Fn = getModule().getFunction(ObjCXX.PersonalityFn);
318 // Nothing to do if it's unused.
319 if (!Fn || Fn->use_empty()) return;
321 // Can't do the optimization if it has non-C++ uses.
322 if (!PersonalityHasOnlyCXXUses(Fn)) return;
324 // Create the C++ personality function and kill off the old
326 llvm::Constant *CXXFn = getPersonalityFn(*this, CXX);
328 // This can happen if the user is screwing with us.
329 if (Fn->getType() != CXXFn->getType()) return;
331 Fn->replaceAllUsesWith(CXXFn);
332 Fn->eraseFromParent();
335 /// Returns the value to inject into a selector to indicate the
336 /// presence of a catch-all.
337 static llvm::Constant *getCatchAllValue(CodeGenFunction &CGF) {
338 // Possibly we should use @llvm.eh.catch.all.value here.
339 return llvm::ConstantPointerNull::get(CGF.Int8PtrTy);
343 /// A cleanup to free the exception object if its initialization
345 struct FreeException : EHScopeStack::Cleanup {
347 FreeException(llvm::Value *exn) : exn(exn) {}
348 void Emit(CodeGenFunction &CGF, Flags flags) override {
349 CGF.EmitNounwindRuntimeCall(getFreeExceptionFn(CGF.CGM), exn);
354 // Emits an exception expression into the given location. This
355 // differs from EmitAnyExprToMem only in that, if a final copy-ctor
356 // call is required, an exception within that copy ctor causes
357 // std::terminate to be invoked.
358 static void EmitAnyExprToExn(CodeGenFunction &CGF, const Expr *e,
360 // Make sure the exception object is cleaned up if there's an
361 // exception during initialization.
362 CGF.pushFullExprCleanup<FreeException>(EHCleanup, addr);
363 EHScopeStack::stable_iterator cleanup = CGF.EHStack.stable_begin();
365 // __cxa_allocate_exception returns a void*; we need to cast this
366 // to the appropriate type for the object.
367 llvm::Type *ty = CGF.ConvertTypeForMem(e->getType())->getPointerTo();
368 llvm::Value *typedAddr = CGF.Builder.CreateBitCast(addr, ty);
370 // FIXME: this isn't quite right! If there's a final unelided call
371 // to a copy constructor, then according to [except.terminate]p1 we
372 // must call std::terminate() if that constructor throws, because
373 // technically that copy occurs after the exception expression is
374 // evaluated but before the exception is caught. But the best way
375 // to handle that is to teach EmitAggExpr to do the final copy
376 // differently if it can't be elided.
377 CGF.EmitAnyExprToMem(e, typedAddr, e->getType().getQualifiers(),
380 // Deactivate the cleanup block.
381 CGF.DeactivateCleanupBlock(cleanup, cast<llvm::Instruction>(typedAddr));
384 llvm::Value *CodeGenFunction::getExceptionSlot() {
386 ExceptionSlot = CreateTempAlloca(Int8PtrTy, "exn.slot");
387 return ExceptionSlot;
390 llvm::Value *CodeGenFunction::getEHSelectorSlot() {
392 EHSelectorSlot = CreateTempAlloca(Int32Ty, "ehselector.slot");
393 return EHSelectorSlot;
396 llvm::Value *CodeGenFunction::getExceptionFromSlot() {
397 return Builder.CreateLoad(getExceptionSlot(), "exn");
400 llvm::Value *CodeGenFunction::getSelectorFromSlot() {
401 return Builder.CreateLoad(getEHSelectorSlot(), "sel");
404 void CodeGenFunction::EmitCXXThrowExpr(const CXXThrowExpr *E,
405 bool KeepInsertionPoint) {
406 if (CGM.getTarget().getTriple().isWindowsMSVCEnvironment()) {
407 ErrorUnsupported(E, "throw expression");
411 if (!E->getSubExpr()) {
412 EmitNoreturnRuntimeCallOrInvoke(getReThrowFn(CGM),
413 ArrayRef<llvm::Value*>());
415 // throw is an expression, and the expression emitters expect us
416 // to leave ourselves at a valid insertion point.
417 if (KeepInsertionPoint)
418 EmitBlock(createBasicBlock("throw.cont"));
423 QualType ThrowType = E->getSubExpr()->getType();
425 if (ThrowType->isObjCObjectPointerType()) {
426 const Stmt *ThrowStmt = E->getSubExpr();
427 const ObjCAtThrowStmt S(E->getExprLoc(),
428 const_cast<Stmt *>(ThrowStmt));
429 CGM.getObjCRuntime().EmitThrowStmt(*this, S, false);
430 // This will clear insertion point which was not cleared in
431 // call to EmitThrowStmt.
432 if (KeepInsertionPoint)
433 EmitBlock(createBasicBlock("throw.cont"));
437 // Now allocate the exception object.
438 llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
439 uint64_t TypeSize = getContext().getTypeSizeInChars(ThrowType).getQuantity();
441 llvm::Constant *AllocExceptionFn = getAllocateExceptionFn(CGM);
442 llvm::CallInst *ExceptionPtr =
443 EmitNounwindRuntimeCall(AllocExceptionFn,
444 llvm::ConstantInt::get(SizeTy, TypeSize),
447 EmitAnyExprToExn(*this, E->getSubExpr(), ExceptionPtr);
449 // Now throw the exception.
450 llvm::Constant *TypeInfo = CGM.GetAddrOfRTTIDescriptor(ThrowType,
453 // The address of the destructor. If the exception type has a
454 // trivial destructor (or isn't a record), we just pass null.
455 llvm::Constant *Dtor = nullptr;
456 if (const RecordType *RecordTy = ThrowType->getAs<RecordType>()) {
457 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordTy->getDecl());
458 if (!Record->hasTrivialDestructor()) {
459 CXXDestructorDecl *DtorD = Record->getDestructor();
460 Dtor = CGM.GetAddrOfCXXDestructor(DtorD, Dtor_Complete);
461 Dtor = llvm::ConstantExpr::getBitCast(Dtor, Int8PtrTy);
464 if (!Dtor) Dtor = llvm::Constant::getNullValue(Int8PtrTy);
466 llvm::Value *args[] = { ExceptionPtr, TypeInfo, Dtor };
467 EmitNoreturnRuntimeCallOrInvoke(getThrowFn(CGM), args);
469 // throw is an expression, and the expression emitters expect us
470 // to leave ourselves at a valid insertion point.
471 if (KeepInsertionPoint)
472 EmitBlock(createBasicBlock("throw.cont"));
475 void CodeGenFunction::EmitStartEHSpec(const Decl *D) {
476 if (!CGM.getLangOpts().CXXExceptions)
479 const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
481 // Check if CapturedDecl is nothrow and create terminate scope for it.
482 if (const CapturedDecl* CD = dyn_cast_or_null<CapturedDecl>(D)) {
484 EHStack.pushTerminate();
488 const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
492 ExceptionSpecificationType EST = Proto->getExceptionSpecType();
493 if (isNoexceptExceptionSpec(EST)) {
494 if (Proto->getNoexceptSpec(getContext()) == FunctionProtoType::NR_Nothrow) {
495 // noexcept functions are simple terminate scopes.
496 EHStack.pushTerminate();
498 } else if (EST == EST_Dynamic || EST == EST_DynamicNone) {
499 unsigned NumExceptions = Proto->getNumExceptions();
500 EHFilterScope *Filter = EHStack.pushFilter(NumExceptions);
502 for (unsigned I = 0; I != NumExceptions; ++I) {
503 QualType Ty = Proto->getExceptionType(I);
504 QualType ExceptType = Ty.getNonReferenceType().getUnqualifiedType();
505 llvm::Value *EHType = CGM.GetAddrOfRTTIDescriptor(ExceptType,
507 Filter->setFilter(I, EHType);
512 /// Emit the dispatch block for a filter scope if necessary.
513 static void emitFilterDispatchBlock(CodeGenFunction &CGF,
514 EHFilterScope &filterScope) {
515 llvm::BasicBlock *dispatchBlock = filterScope.getCachedEHDispatchBlock();
516 if (!dispatchBlock) return;
517 if (dispatchBlock->use_empty()) {
518 delete dispatchBlock;
522 CGF.EmitBlockAfterUses(dispatchBlock);
524 // If this isn't a catch-all filter, we need to check whether we got
525 // here because the filter triggered.
526 if (filterScope.getNumFilters()) {
527 // Load the selector value.
528 llvm::Value *selector = CGF.getSelectorFromSlot();
529 llvm::BasicBlock *unexpectedBB = CGF.createBasicBlock("ehspec.unexpected");
531 llvm::Value *zero = CGF.Builder.getInt32(0);
532 llvm::Value *failsFilter =
533 CGF.Builder.CreateICmpSLT(selector, zero, "ehspec.fails");
534 CGF.Builder.CreateCondBr(failsFilter, unexpectedBB, CGF.getEHResumeBlock(false));
536 CGF.EmitBlock(unexpectedBB);
539 // Call __cxa_call_unexpected. This doesn't need to be an invoke
540 // because __cxa_call_unexpected magically filters exceptions
541 // according to the last landing pad the exception was thrown
543 llvm::Value *exn = CGF.getExceptionFromSlot();
544 CGF.EmitRuntimeCall(getUnexpectedFn(CGF.CGM), exn)
545 ->setDoesNotReturn();
546 CGF.Builder.CreateUnreachable();
549 void CodeGenFunction::EmitEndEHSpec(const Decl *D) {
550 if (!CGM.getLangOpts().CXXExceptions)
553 const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D);
555 // Check if CapturedDecl is nothrow and pop terminate scope for it.
556 if (const CapturedDecl* CD = dyn_cast_or_null<CapturedDecl>(D)) {
558 EHStack.popTerminate();
562 const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>();
566 ExceptionSpecificationType EST = Proto->getExceptionSpecType();
567 if (isNoexceptExceptionSpec(EST)) {
568 if (Proto->getNoexceptSpec(getContext()) == FunctionProtoType::NR_Nothrow) {
569 EHStack.popTerminate();
571 } else if (EST == EST_Dynamic || EST == EST_DynamicNone) {
572 EHFilterScope &filterScope = cast<EHFilterScope>(*EHStack.begin());
573 emitFilterDispatchBlock(*this, filterScope);
578 void CodeGenFunction::EmitCXXTryStmt(const CXXTryStmt &S) {
579 if (CGM.getTarget().getTriple().isWindowsMSVCEnvironment()) {
580 ErrorUnsupported(&S, "try statement");
585 EmitStmt(S.getTryBlock());
589 void CodeGenFunction::EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) {
590 unsigned NumHandlers = S.getNumHandlers();
591 EHCatchScope *CatchScope = EHStack.pushCatch(NumHandlers);
593 for (unsigned I = 0; I != NumHandlers; ++I) {
594 const CXXCatchStmt *C = S.getHandler(I);
596 llvm::BasicBlock *Handler = createBasicBlock("catch");
597 if (C->getExceptionDecl()) {
598 // FIXME: Dropping the reference type on the type into makes it
599 // impossible to correctly implement catch-by-reference
600 // semantics for pointers. Unfortunately, this is what all
601 // existing compilers do, and it's not clear that the standard
602 // personality routine is capable of doing this right. See C++ DR 388:
603 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#388
604 QualType CaughtType = C->getCaughtType();
605 CaughtType = CaughtType.getNonReferenceType().getUnqualifiedType();
607 llvm::Constant *TypeInfo = nullptr;
608 if (CaughtType->isObjCObjectPointerType())
609 TypeInfo = CGM.getObjCRuntime().GetEHType(CaughtType);
611 TypeInfo = CGM.GetAddrOfRTTIDescriptor(CaughtType, /*ForEH=*/true);
612 CatchScope->setHandler(I, TypeInfo, Handler);
614 // No exception decl indicates '...', a catch-all.
615 CatchScope->setCatchAllHandler(I, Handler);
621 CodeGenFunction::getEHDispatchBlock(EHScopeStack::stable_iterator si) {
622 // The dispatch block for the end of the scope chain is a block that
623 // just resumes unwinding.
624 if (si == EHStack.stable_end())
625 return getEHResumeBlock(true);
627 // Otherwise, we should look at the actual scope.
628 EHScope &scope = *EHStack.find(si);
630 llvm::BasicBlock *dispatchBlock = scope.getCachedEHDispatchBlock();
631 if (!dispatchBlock) {
632 switch (scope.getKind()) {
633 case EHScope::Catch: {
634 // Apply a special case to a single catch-all.
635 EHCatchScope &catchScope = cast<EHCatchScope>(scope);
636 if (catchScope.getNumHandlers() == 1 &&
637 catchScope.getHandler(0).isCatchAll()) {
638 dispatchBlock = catchScope.getHandler(0).Block;
640 // Otherwise, make a dispatch block.
642 dispatchBlock = createBasicBlock("catch.dispatch");
647 case EHScope::Cleanup:
648 dispatchBlock = createBasicBlock("ehcleanup");
651 case EHScope::Filter:
652 dispatchBlock = createBasicBlock("filter.dispatch");
655 case EHScope::Terminate:
656 dispatchBlock = getTerminateHandler();
659 scope.setCachedEHDispatchBlock(dispatchBlock);
661 return dispatchBlock;
664 /// Check whether this is a non-EH scope, i.e. a scope which doesn't
665 /// affect exception handling. Currently, the only non-EH scopes are
666 /// normal-only cleanup scopes.
667 static bool isNonEHScope(const EHScope &S) {
668 switch (S.getKind()) {
669 case EHScope::Cleanup:
670 return !cast<EHCleanupScope>(S).isEHCleanup();
671 case EHScope::Filter:
673 case EHScope::Terminate:
677 llvm_unreachable("Invalid EHScope Kind!");
680 llvm::BasicBlock *CodeGenFunction::getInvokeDestImpl() {
681 assert(EHStack.requiresLandingPad());
682 assert(!EHStack.empty());
684 if (!CGM.getLangOpts().Exceptions)
687 // Check the innermost scope for a cached landing pad. If this is
688 // a non-EH cleanup, we'll check enclosing scopes in EmitLandingPad.
689 llvm::BasicBlock *LP = EHStack.begin()->getCachedLandingPad();
692 // Build the landing pad for this scope.
693 LP = EmitLandingPad();
696 // Cache the landing pad on the innermost scope. If this is a
697 // non-EH scope, cache the landing pad on the enclosing scope, too.
698 for (EHScopeStack::iterator ir = EHStack.begin(); true; ++ir) {
699 ir->setCachedLandingPad(LP);
700 if (!isNonEHScope(*ir)) break;
706 llvm::BasicBlock *CodeGenFunction::EmitLandingPad() {
707 assert(EHStack.requiresLandingPad());
709 EHScope &innermostEHScope = *EHStack.find(EHStack.getInnermostEHScope());
710 switch (innermostEHScope.getKind()) {
711 case EHScope::Terminate:
712 return getTerminateLandingPad();
715 case EHScope::Cleanup:
716 case EHScope::Filter:
717 if (llvm::BasicBlock *lpad = innermostEHScope.getCachedLandingPad())
721 // Save the current IR generation state.
722 CGBuilderTy::InsertPoint savedIP = Builder.saveAndClearIP();
723 SaveAndRestoreLocation AutoRestoreLocation(*this, Builder);
724 if (CGDebugInfo *DI = getDebugInfo())
725 DI->EmitLocation(Builder, CurEHLocation);
727 const EHPersonality &personality = EHPersonality::get(getLangOpts());
729 // Create and configure the landing pad.
730 llvm::BasicBlock *lpad = createBasicBlock("lpad");
733 llvm::LandingPadInst *LPadInst =
734 Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty, NULL),
735 getOpaquePersonalityFn(CGM, personality), 0);
737 llvm::Value *LPadExn = Builder.CreateExtractValue(LPadInst, 0);
738 Builder.CreateStore(LPadExn, getExceptionSlot());
739 llvm::Value *LPadSel = Builder.CreateExtractValue(LPadInst, 1);
740 Builder.CreateStore(LPadSel, getEHSelectorSlot());
742 // Save the exception pointer. It's safe to use a single exception
743 // pointer per function because EH cleanups can never have nested
745 // Build the landingpad instruction.
747 // Accumulate all the handlers in scope.
748 bool hasCatchAll = false;
749 bool hasCleanup = false;
750 bool hasFilter = false;
751 SmallVector<llvm::Value*, 4> filterTypes;
752 llvm::SmallPtrSet<llvm::Value*, 4> catchTypes;
753 for (EHScopeStack::iterator I = EHStack.begin(), E = EHStack.end();
756 switch (I->getKind()) {
757 case EHScope::Cleanup:
758 // If we have a cleanup, remember that.
759 hasCleanup = (hasCleanup || cast<EHCleanupScope>(*I).isEHCleanup());
762 case EHScope::Filter: {
763 assert(I.next() == EHStack.end() && "EH filter is not end of EH stack");
764 assert(!hasCatchAll && "EH filter reached after catch-all");
766 // Filter scopes get added to the landingpad in weird ways.
767 EHFilterScope &filter = cast<EHFilterScope>(*I);
770 // Add all the filter values.
771 for (unsigned i = 0, e = filter.getNumFilters(); i != e; ++i)
772 filterTypes.push_back(filter.getFilter(i));
776 case EHScope::Terminate:
777 // Terminate scopes are basically catch-alls.
778 assert(!hasCatchAll);
786 EHCatchScope &catchScope = cast<EHCatchScope>(*I);
787 for (unsigned hi = 0, he = catchScope.getNumHandlers(); hi != he; ++hi) {
788 EHCatchScope::Handler handler = catchScope.getHandler(hi);
790 // If this is a catch-all, register that and abort.
792 assert(!hasCatchAll);
797 // Check whether we already have a handler for this type.
798 if (catchTypes.insert(handler.Type))
799 // If not, add it directly to the landingpad.
800 LPadInst->addClause(handler.Type);
805 // If we have a catch-all, add null to the landingpad.
806 assert(!(hasCatchAll && hasFilter));
808 LPadInst->addClause(getCatchAllValue(*this));
810 // If we have an EH filter, we need to add those handlers in the
811 // right place in the landingpad, which is to say, at the end.
812 } else if (hasFilter) {
813 // Create a filter expression: a constant array indicating which filter
814 // types there are. The personality routine only lands here if the filter
816 SmallVector<llvm::Constant*, 8> Filters;
817 llvm::ArrayType *AType =
818 llvm::ArrayType::get(!filterTypes.empty() ?
819 filterTypes[0]->getType() : Int8PtrTy,
822 for (unsigned i = 0, e = filterTypes.size(); i != e; ++i)
823 Filters.push_back(cast<llvm::Constant>(filterTypes[i]));
824 llvm::Constant *FilterArray = llvm::ConstantArray::get(AType, Filters);
825 LPadInst->addClause(FilterArray);
827 // Also check whether we need a cleanup.
829 LPadInst->setCleanup(true);
831 // Otherwise, signal that we at least have cleanups.
832 } else if (hasCleanup) {
833 LPadInst->setCleanup(true);
836 assert((LPadInst->getNumClauses() > 0 || LPadInst->isCleanup()) &&
837 "landingpad instruction has no clauses!");
839 // Tell the backend how to generate the landing pad.
840 Builder.CreateBr(getEHDispatchBlock(EHStack.getInnermostEHScope()));
842 // Restore the old IR generation state.
843 Builder.restoreIP(savedIP);
849 /// A cleanup to call __cxa_end_catch. In many cases, the caught
850 /// exception type lets us state definitively that the thrown exception
851 /// type does not have a destructor. In particular:
852 /// - Catch-alls tell us nothing, so we have to conservatively
853 /// assume that the thrown exception might have a destructor.
854 /// - Catches by reference behave according to their base types.
855 /// - Catches of non-record types will only trigger for exceptions
856 /// of non-record types, which never have destructors.
857 /// - Catches of record types can trigger for arbitrary subclasses
858 /// of the caught type, so we have to assume the actual thrown
859 /// exception type might have a throwing destructor, even if the
860 /// caught type's destructor is trivial or nothrow.
861 struct CallEndCatch : EHScopeStack::Cleanup {
862 CallEndCatch(bool MightThrow) : MightThrow(MightThrow) {}
865 void Emit(CodeGenFunction &CGF, Flags flags) override {
867 CGF.EmitNounwindRuntimeCall(getEndCatchFn(CGF.CGM));
871 CGF.EmitRuntimeCallOrInvoke(getEndCatchFn(CGF.CGM));
876 /// Emits a call to __cxa_begin_catch and enters a cleanup to call
879 /// \param EndMightThrow - true if __cxa_end_catch might throw
880 static llvm::Value *CallBeginCatch(CodeGenFunction &CGF,
882 bool EndMightThrow) {
883 llvm::CallInst *call =
884 CGF.EmitNounwindRuntimeCall(getBeginCatchFn(CGF.CGM), Exn);
886 CGF.EHStack.pushCleanup<CallEndCatch>(NormalAndEHCleanup, EndMightThrow);
891 /// A "special initializer" callback for initializing a catch
892 /// parameter during catch initialization.
893 static void InitCatchParam(CodeGenFunction &CGF,
894 const VarDecl &CatchParam,
895 llvm::Value *ParamAddr,
896 SourceLocation Loc) {
897 // Load the exception from where the landing pad saved it.
898 llvm::Value *Exn = CGF.getExceptionFromSlot();
900 CanQualType CatchType =
901 CGF.CGM.getContext().getCanonicalType(CatchParam.getType());
902 llvm::Type *LLVMCatchTy = CGF.ConvertTypeForMem(CatchType);
904 // If we're catching by reference, we can just cast the object
905 // pointer to the appropriate pointer.
906 if (isa<ReferenceType>(CatchType)) {
907 QualType CaughtType = cast<ReferenceType>(CatchType)->getPointeeType();
908 bool EndCatchMightThrow = CaughtType->isRecordType();
910 // __cxa_begin_catch returns the adjusted object pointer.
911 llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, EndCatchMightThrow);
913 // We have no way to tell the personality function that we're
914 // catching by reference, so if we're catching a pointer,
915 // __cxa_begin_catch will actually return that pointer by value.
916 if (const PointerType *PT = dyn_cast<PointerType>(CaughtType)) {
917 QualType PointeeType = PT->getPointeeType();
919 // When catching by reference, generally we should just ignore
920 // this by-value pointer and use the exception object instead.
921 if (!PointeeType->isRecordType()) {
923 // Exn points to the struct _Unwind_Exception header, which
924 // we have to skip past in order to reach the exception data.
925 unsigned HeaderSize =
926 CGF.CGM.getTargetCodeGenInfo().getSizeOfUnwindException();
927 AdjustedExn = CGF.Builder.CreateConstGEP1_32(Exn, HeaderSize);
929 // However, if we're catching a pointer-to-record type that won't
930 // work, because the personality function might have adjusted
931 // the pointer. There's actually no way for us to fully satisfy
932 // the language/ABI contract here: we can't use Exn because it
933 // might have the wrong adjustment, but we can't use the by-value
934 // pointer because it's off by a level of abstraction.
936 // The current solution is to dump the adjusted pointer into an
937 // alloca, which breaks language semantics (because changing the
938 // pointer doesn't change the exception) but at least works.
939 // The better solution would be to filter out non-exact matches
940 // and rethrow them, but this is tricky because the rethrow
941 // really needs to be catchable by other sites at this landing
942 // pad. The best solution is to fix the personality function.
944 // Pull the pointer for the reference type off.
946 cast<llvm::PointerType>(LLVMCatchTy)->getElementType();
948 // Create the temporary and write the adjusted pointer into it.
949 llvm::Value *ExnPtrTmp = CGF.CreateTempAlloca(PtrTy, "exn.byref.tmp");
950 llvm::Value *Casted = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
951 CGF.Builder.CreateStore(Casted, ExnPtrTmp);
953 // Bind the reference to the temporary.
954 AdjustedExn = ExnPtrTmp;
958 llvm::Value *ExnCast =
959 CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.byref");
960 CGF.Builder.CreateStore(ExnCast, ParamAddr);
964 // Scalars and complexes.
965 TypeEvaluationKind TEK = CGF.getEvaluationKind(CatchType);
966 if (TEK != TEK_Aggregate) {
967 llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, false);
969 // If the catch type is a pointer type, __cxa_begin_catch returns
970 // the pointer by value.
971 if (CatchType->hasPointerRepresentation()) {
972 llvm::Value *CastExn =
973 CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.casted");
975 switch (CatchType.getQualifiers().getObjCLifetime()) {
976 case Qualifiers::OCL_Strong:
977 CastExn = CGF.EmitARCRetainNonBlock(CastExn);
980 case Qualifiers::OCL_None:
981 case Qualifiers::OCL_ExplicitNone:
982 case Qualifiers::OCL_Autoreleasing:
983 CGF.Builder.CreateStore(CastExn, ParamAddr);
986 case Qualifiers::OCL_Weak:
987 CGF.EmitARCInitWeak(ParamAddr, CastExn);
990 llvm_unreachable("bad ownership qualifier!");
993 // Otherwise, it returns a pointer into the exception object.
995 llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
996 llvm::Value *Cast = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy);
998 LValue srcLV = CGF.MakeNaturalAlignAddrLValue(Cast, CatchType);
999 LValue destLV = CGF.MakeAddrLValue(ParamAddr, CatchType,
1000 CGF.getContext().getDeclAlign(&CatchParam));
1003 CGF.EmitStoreOfComplex(CGF.EmitLoadOfComplex(srcLV, Loc), destLV,
1007 llvm::Value *ExnLoad = CGF.EmitLoadOfScalar(srcLV, Loc);
1008 CGF.EmitStoreOfScalar(ExnLoad, destLV, /*init*/ true);
1012 llvm_unreachable("evaluation kind filtered out!");
1014 llvm_unreachable("bad evaluation kind");
1017 assert(isa<RecordType>(CatchType) && "unexpected catch type!");
1019 llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
1021 // Check for a copy expression. If we don't have a copy expression,
1022 // that means a trivial copy is okay.
1023 const Expr *copyExpr = CatchParam.getInit();
1025 llvm::Value *rawAdjustedExn = CallBeginCatch(CGF, Exn, true);
1026 llvm::Value *adjustedExn = CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy);
1027 CGF.EmitAggregateCopy(ParamAddr, adjustedExn, CatchType);
1031 // We have to call __cxa_get_exception_ptr to get the adjusted
1032 // pointer before copying.
1033 llvm::CallInst *rawAdjustedExn =
1034 CGF.EmitNounwindRuntimeCall(getGetExceptionPtrFn(CGF.CGM), Exn);
1036 // Cast that to the appropriate type.
1037 llvm::Value *adjustedExn = CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy);
1039 // The copy expression is defined in terms of an OpaqueValueExpr.
1040 // Find it and map it to the adjusted expression.
1041 CodeGenFunction::OpaqueValueMapping
1042 opaque(CGF, OpaqueValueExpr::findInCopyConstruct(copyExpr),
1043 CGF.MakeAddrLValue(adjustedExn, CatchParam.getType()));
1045 // Call the copy ctor in a terminate scope.
1046 CGF.EHStack.pushTerminate();
1048 // Perform the copy construction.
1049 CharUnits Alignment = CGF.getContext().getDeclAlign(&CatchParam);
1050 CGF.EmitAggExpr(copyExpr,
1051 AggValueSlot::forAddr(ParamAddr, Alignment, Qualifiers(),
1052 AggValueSlot::IsNotDestructed,
1053 AggValueSlot::DoesNotNeedGCBarriers,
1054 AggValueSlot::IsNotAliased));
1056 // Leave the terminate scope.
1057 CGF.EHStack.popTerminate();
1059 // Undo the opaque value mapping.
1062 // Finally we can call __cxa_begin_catch.
1063 CallBeginCatch(CGF, Exn, true);
1066 /// Begins a catch statement by initializing the catch variable and
1067 /// calling __cxa_begin_catch.
1068 static void BeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *S) {
1069 // We have to be very careful with the ordering of cleanups here:
1070 // C++ [except.throw]p4:
1071 // The destruction [of the exception temporary] occurs
1072 // immediately after the destruction of the object declared in
1073 // the exception-declaration in the handler.
1075 // So the precise ordering is:
1076 // 1. Construct catch variable.
1077 // 2. __cxa_begin_catch
1078 // 3. Enter __cxa_end_catch cleanup
1079 // 4. Enter dtor cleanup
1081 // We do this by using a slightly abnormal initialization process.
1082 // Delegation sequence:
1083 // - ExitCXXTryStmt opens a RunCleanupsScope
1084 // - EmitAutoVarAlloca creates the variable and debug info
1085 // - InitCatchParam initializes the variable from the exception
1086 // - CallBeginCatch calls __cxa_begin_catch
1087 // - CallBeginCatch enters the __cxa_end_catch cleanup
1088 // - EmitAutoVarCleanups enters the variable destructor cleanup
1089 // - EmitCXXTryStmt emits the code for the catch body
1090 // - EmitCXXTryStmt close the RunCleanupsScope
1092 VarDecl *CatchParam = S->getExceptionDecl();
1094 llvm::Value *Exn = CGF.getExceptionFromSlot();
1095 CallBeginCatch(CGF, Exn, true);
1100 CodeGenFunction::AutoVarEmission var = CGF.EmitAutoVarAlloca(*CatchParam);
1101 InitCatchParam(CGF, *CatchParam, var.getObjectAddress(CGF), S->getLocStart());
1102 CGF.EmitAutoVarCleanups(var);
1105 /// Emit the structure of the dispatch block for the given catch scope.
1106 /// It is an invariant that the dispatch block already exists.
1107 static void emitCatchDispatchBlock(CodeGenFunction &CGF,
1108 EHCatchScope &catchScope) {
1109 llvm::BasicBlock *dispatchBlock = catchScope.getCachedEHDispatchBlock();
1110 assert(dispatchBlock);
1112 // If there's only a single catch-all, getEHDispatchBlock returned
1113 // that catch-all as the dispatch block.
1114 if (catchScope.getNumHandlers() == 1 &&
1115 catchScope.getHandler(0).isCatchAll()) {
1116 assert(dispatchBlock == catchScope.getHandler(0).Block);
1120 CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveIP();
1121 CGF.EmitBlockAfterUses(dispatchBlock);
1123 // Select the right handler.
1124 llvm::Value *llvm_eh_typeid_for =
1125 CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for);
1127 // Load the selector value.
1128 llvm::Value *selector = CGF.getSelectorFromSlot();
1130 // Test against each of the exception types we claim to catch.
1131 for (unsigned i = 0, e = catchScope.getNumHandlers(); ; ++i) {
1132 assert(i < e && "ran off end of handlers!");
1133 const EHCatchScope::Handler &handler = catchScope.getHandler(i);
1135 llvm::Value *typeValue = handler.Type;
1136 assert(typeValue && "fell into catch-all case!");
1137 typeValue = CGF.Builder.CreateBitCast(typeValue, CGF.Int8PtrTy);
1139 // Figure out the next block.
1141 llvm::BasicBlock *nextBlock;
1143 // If this is the last handler, we're at the end, and the next
1144 // block is the block for the enclosing EH scope.
1146 nextBlock = CGF.getEHDispatchBlock(catchScope.getEnclosingEHScope());
1149 // If the next handler is a catch-all, we're at the end, and the
1150 // next block is that handler.
1151 } else if (catchScope.getHandler(i+1).isCatchAll()) {
1152 nextBlock = catchScope.getHandler(i+1).Block;
1155 // Otherwise, we're not at the end and we need a new block.
1157 nextBlock = CGF.createBasicBlock("catch.fallthrough");
1161 // Figure out the catch type's index in the LSDA's type table.
1162 llvm::CallInst *typeIndex =
1163 CGF.Builder.CreateCall(llvm_eh_typeid_for, typeValue);
1164 typeIndex->setDoesNotThrow();
1166 llvm::Value *matchesTypeIndex =
1167 CGF.Builder.CreateICmpEQ(selector, typeIndex, "matches");
1168 CGF.Builder.CreateCondBr(matchesTypeIndex, handler.Block, nextBlock);
1170 // If the next handler is a catch-all, we're completely done.
1172 CGF.Builder.restoreIP(savedIP);
1175 // Otherwise we need to emit and continue at that block.
1176 CGF.EmitBlock(nextBlock);
1180 void CodeGenFunction::popCatchScope() {
1181 EHCatchScope &catchScope = cast<EHCatchScope>(*EHStack.begin());
1182 if (catchScope.hasEHBranches())
1183 emitCatchDispatchBlock(*this, catchScope);
1187 void CodeGenFunction::ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) {
1188 unsigned NumHandlers = S.getNumHandlers();
1189 EHCatchScope &CatchScope = cast<EHCatchScope>(*EHStack.begin());
1190 assert(CatchScope.getNumHandlers() == NumHandlers);
1192 // If the catch was not required, bail out now.
1193 if (!CatchScope.hasEHBranches()) {
1194 CatchScope.clearHandlerBlocks();
1199 // Emit the structure of the EH dispatch for this catch.
1200 emitCatchDispatchBlock(*this, CatchScope);
1202 // Copy the handler blocks off before we pop the EH stack. Emitting
1203 // the handlers might scribble on this memory.
1204 SmallVector<EHCatchScope::Handler, 8> Handlers(NumHandlers);
1205 memcpy(Handlers.data(), CatchScope.begin(),
1206 NumHandlers * sizeof(EHCatchScope::Handler));
1210 // The fall-through block.
1211 llvm::BasicBlock *ContBB = createBasicBlock("try.cont");
1213 // We just emitted the body of the try; jump to the continue block.
1214 if (HaveInsertPoint())
1215 Builder.CreateBr(ContBB);
1217 // Determine if we need an implicit rethrow for all these catch handlers;
1218 // see the comment below.
1219 bool doImplicitRethrow = false;
1221 doImplicitRethrow = isa<CXXDestructorDecl>(CurCodeDecl) ||
1222 isa<CXXConstructorDecl>(CurCodeDecl);
1224 // Perversely, we emit the handlers backwards precisely because we
1225 // want them to appear in source order. In all of these cases, the
1226 // catch block will have exactly one predecessor, which will be a
1227 // particular block in the catch dispatch. However, in the case of
1228 // a catch-all, one of the dispatch blocks will branch to two
1229 // different handlers, and EmitBlockAfterUses will cause the second
1230 // handler to be moved before the first.
1231 for (unsigned I = NumHandlers; I != 0; --I) {
1232 llvm::BasicBlock *CatchBlock = Handlers[I-1].Block;
1233 EmitBlockAfterUses(CatchBlock);
1235 // Catch the exception if this isn't a catch-all.
1236 const CXXCatchStmt *C = S.getHandler(I-1);
1238 // Enter a cleanup scope, including the catch variable and the
1240 RunCleanupsScope CatchScope(*this);
1242 // Initialize the catch variable and set up the cleanups.
1243 BeginCatch(*this, C);
1245 // Emit the PGO counter increment.
1246 RegionCounter CatchCnt = getPGORegionCounter(C);
1247 CatchCnt.beginRegion(Builder);
1249 // Perform the body of the catch.
1250 EmitStmt(C->getHandlerBlock());
1252 // [except.handle]p11:
1253 // The currently handled exception is rethrown if control
1254 // reaches the end of a handler of the function-try-block of a
1255 // constructor or destructor.
1257 // It is important that we only do this on fallthrough and not on
1258 // return. Note that it's illegal to put a return in a
1259 // constructor function-try-block's catch handler (p14), so this
1260 // really only applies to destructors.
1261 if (doImplicitRethrow && HaveInsertPoint()) {
1262 EmitRuntimeCallOrInvoke(getReThrowFn(CGM));
1263 Builder.CreateUnreachable();
1264 Builder.ClearInsertionPoint();
1267 // Fall out through the catch cleanups.
1268 CatchScope.ForceCleanup();
1270 // Branch out of the try.
1271 if (HaveInsertPoint())
1272 Builder.CreateBr(ContBB);
1275 RegionCounter ContCnt = getPGORegionCounter(&S);
1277 ContCnt.beginRegion(Builder);
1281 struct CallEndCatchForFinally : EHScopeStack::Cleanup {
1282 llvm::Value *ForEHVar;
1283 llvm::Value *EndCatchFn;
1284 CallEndCatchForFinally(llvm::Value *ForEHVar, llvm::Value *EndCatchFn)
1285 : ForEHVar(ForEHVar), EndCatchFn(EndCatchFn) {}
1287 void Emit(CodeGenFunction &CGF, Flags flags) override {
1288 llvm::BasicBlock *EndCatchBB = CGF.createBasicBlock("finally.endcatch");
1289 llvm::BasicBlock *CleanupContBB =
1290 CGF.createBasicBlock("finally.cleanup.cont");
1292 llvm::Value *ShouldEndCatch =
1293 CGF.Builder.CreateLoad(ForEHVar, "finally.endcatch");
1294 CGF.Builder.CreateCondBr(ShouldEndCatch, EndCatchBB, CleanupContBB);
1295 CGF.EmitBlock(EndCatchBB);
1296 CGF.EmitRuntimeCallOrInvoke(EndCatchFn); // catch-all, so might throw
1297 CGF.EmitBlock(CleanupContBB);
1301 struct PerformFinally : EHScopeStack::Cleanup {
1303 llvm::Value *ForEHVar;
1304 llvm::Value *EndCatchFn;
1305 llvm::Value *RethrowFn;
1306 llvm::Value *SavedExnVar;
1308 PerformFinally(const Stmt *Body, llvm::Value *ForEHVar,
1309 llvm::Value *EndCatchFn,
1310 llvm::Value *RethrowFn, llvm::Value *SavedExnVar)
1311 : Body(Body), ForEHVar(ForEHVar), EndCatchFn(EndCatchFn),
1312 RethrowFn(RethrowFn), SavedExnVar(SavedExnVar) {}
1314 void Emit(CodeGenFunction &CGF, Flags flags) override {
1315 // Enter a cleanup to call the end-catch function if one was provided.
1317 CGF.EHStack.pushCleanup<CallEndCatchForFinally>(NormalAndEHCleanup,
1318 ForEHVar, EndCatchFn);
1320 // Save the current cleanup destination in case there are
1321 // cleanups in the finally block.
1322 llvm::Value *SavedCleanupDest =
1323 CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot(),
1324 "cleanup.dest.saved");
1326 // Emit the finally block.
1329 // If the end of the finally is reachable, check whether this was
1330 // for EH. If so, rethrow.
1331 if (CGF.HaveInsertPoint()) {
1332 llvm::BasicBlock *RethrowBB = CGF.createBasicBlock("finally.rethrow");
1333 llvm::BasicBlock *ContBB = CGF.createBasicBlock("finally.cont");
1335 llvm::Value *ShouldRethrow =
1336 CGF.Builder.CreateLoad(ForEHVar, "finally.shouldthrow");
1337 CGF.Builder.CreateCondBr(ShouldRethrow, RethrowBB, ContBB);
1339 CGF.EmitBlock(RethrowBB);
1341 CGF.EmitRuntimeCallOrInvoke(RethrowFn,
1342 CGF.Builder.CreateLoad(SavedExnVar));
1344 CGF.EmitRuntimeCallOrInvoke(RethrowFn);
1346 CGF.Builder.CreateUnreachable();
1348 CGF.EmitBlock(ContBB);
1350 // Restore the cleanup destination.
1351 CGF.Builder.CreateStore(SavedCleanupDest,
1352 CGF.getNormalCleanupDestSlot());
1355 // Leave the end-catch cleanup. As an optimization, pretend that
1356 // the fallthrough path was inaccessible; we've dynamically proven
1357 // that we're not in the EH case along that path.
1359 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
1360 CGF.PopCleanupBlock();
1361 CGF.Builder.restoreIP(SavedIP);
1364 // Now make sure we actually have an insertion point or the
1365 // cleanup gods will hate us.
1366 CGF.EnsureInsertPoint();
1371 /// Enters a finally block for an implementation using zero-cost
1372 /// exceptions. This is mostly general, but hard-codes some
1373 /// language/ABI-specific behavior in the catch-all sections.
1374 void CodeGenFunction::FinallyInfo::enter(CodeGenFunction &CGF,
1376 llvm::Constant *beginCatchFn,
1377 llvm::Constant *endCatchFn,
1378 llvm::Constant *rethrowFn) {
1379 assert((beginCatchFn != nullptr) == (endCatchFn != nullptr) &&
1380 "begin/end catch functions not paired");
1381 assert(rethrowFn && "rethrow function is required");
1383 BeginCatchFn = beginCatchFn;
1385 // The rethrow function has one of the following two types:
1388 // In the latter case we need to pass it the exception object.
1389 // But we can't use the exception slot because the @finally might
1390 // have a landing pad (which would overwrite the exception slot).
1391 llvm::FunctionType *rethrowFnTy =
1392 cast<llvm::FunctionType>(
1393 cast<llvm::PointerType>(rethrowFn->getType())->getElementType());
1394 SavedExnVar = nullptr;
1395 if (rethrowFnTy->getNumParams())
1396 SavedExnVar = CGF.CreateTempAlloca(CGF.Int8PtrTy, "finally.exn");
1398 // A finally block is a statement which must be executed on any edge
1399 // out of a given scope. Unlike a cleanup, the finally block may
1400 // contain arbitrary control flow leading out of itself. In
1401 // addition, finally blocks should always be executed, even if there
1402 // are no catch handlers higher on the stack. Therefore, we
1403 // surround the protected scope with a combination of a normal
1404 // cleanup (to catch attempts to break out of the block via normal
1405 // control flow) and an EH catch-all (semantically "outside" any try
1406 // statement to which the finally block might have been attached).
1407 // The finally block itself is generated in the context of a cleanup
1408 // which conditionally leaves the catch-all.
1410 // Jump destination for performing the finally block on an exception
1411 // edge. We'll never actually reach this block, so unreachable is
1413 RethrowDest = CGF.getJumpDestInCurrentScope(CGF.getUnreachableBlock());
1415 // Whether the finally block is being executed for EH purposes.
1416 ForEHVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), "finally.for-eh");
1417 CGF.Builder.CreateStore(CGF.Builder.getFalse(), ForEHVar);
1419 // Enter a normal cleanup which will perform the @finally block.
1420 CGF.EHStack.pushCleanup<PerformFinally>(NormalCleanup, body,
1421 ForEHVar, endCatchFn,
1422 rethrowFn, SavedExnVar);
1424 // Enter a catch-all scope.
1425 llvm::BasicBlock *catchBB = CGF.createBasicBlock("finally.catchall");
1426 EHCatchScope *catchScope = CGF.EHStack.pushCatch(1);
1427 catchScope->setCatchAllHandler(0, catchBB);
1430 void CodeGenFunction::FinallyInfo::exit(CodeGenFunction &CGF) {
1431 // Leave the finally catch-all.
1432 EHCatchScope &catchScope = cast<EHCatchScope>(*CGF.EHStack.begin());
1433 llvm::BasicBlock *catchBB = catchScope.getHandler(0).Block;
1435 CGF.popCatchScope();
1437 // If there are any references to the catch-all block, emit it.
1438 if (catchBB->use_empty()) {
1441 CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveAndClearIP();
1442 CGF.EmitBlock(catchBB);
1444 llvm::Value *exn = nullptr;
1446 // If there's a begin-catch function, call it.
1448 exn = CGF.getExceptionFromSlot();
1449 CGF.EmitNounwindRuntimeCall(BeginCatchFn, exn);
1452 // If we need to remember the exception pointer to rethrow later, do so.
1454 if (!exn) exn = CGF.getExceptionFromSlot();
1455 CGF.Builder.CreateStore(exn, SavedExnVar);
1458 // Tell the cleanups in the finally block that we're do this for EH.
1459 CGF.Builder.CreateStore(CGF.Builder.getTrue(), ForEHVar);
1461 // Thread a jump through the finally cleanup.
1462 CGF.EmitBranchThroughCleanup(RethrowDest);
1464 CGF.Builder.restoreIP(savedIP);
1467 // Finally, leave the @finally cleanup.
1468 CGF.PopCleanupBlock();
1471 /// In a terminate landing pad, should we use __clang__call_terminate
1472 /// or just a naked call to std::terminate?
1474 /// __clang_call_terminate calls __cxa_begin_catch, which then allows
1475 /// std::terminate to usefully report something about the
1476 /// violating exception.
1477 static bool useClangCallTerminate(CodeGenModule &CGM) {
1478 // Only do this for Itanium-family ABIs in C++ mode.
1479 return (CGM.getLangOpts().CPlusPlus &&
1480 CGM.getTarget().getCXXABI().isItaniumFamily());
1483 /// Get or define the following function:
1484 /// void @__clang_call_terminate(i8* %exn) nounwind noreturn
1485 /// This code is used only in C++.
1486 static llvm::Constant *getClangCallTerminateFn(CodeGenModule &CGM) {
1487 llvm::FunctionType *fnTy =
1488 llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false);
1489 llvm::Constant *fnRef =
1490 CGM.CreateRuntimeFunction(fnTy, "__clang_call_terminate");
1492 llvm::Function *fn = dyn_cast<llvm::Function>(fnRef);
1493 if (fn && fn->empty()) {
1494 fn->setDoesNotThrow();
1495 fn->setDoesNotReturn();
1497 // What we really want is to massively penalize inlining without
1498 // forbidding it completely. The difference between that and
1499 // 'noinline' is negligible.
1500 fn->addFnAttr(llvm::Attribute::NoInline);
1502 // Allow this function to be shared across translation units, but
1503 // we don't want it to turn into an exported symbol.
1504 fn->setLinkage(llvm::Function::LinkOnceODRLinkage);
1505 fn->setVisibility(llvm::Function::HiddenVisibility);
1507 // Set up the function.
1508 llvm::BasicBlock *entry =
1509 llvm::BasicBlock::Create(CGM.getLLVMContext(), "", fn);
1510 CGBuilderTy builder(entry);
1512 // Pull the exception pointer out of the parameter list.
1513 llvm::Value *exn = &*fn->arg_begin();
1515 // Call __cxa_begin_catch(exn).
1516 llvm::CallInst *catchCall = builder.CreateCall(getBeginCatchFn(CGM), exn);
1517 catchCall->setDoesNotThrow();
1518 catchCall->setCallingConv(CGM.getRuntimeCC());
1520 // Call std::terminate().
1521 llvm::CallInst *termCall = builder.CreateCall(getTerminateFn(CGM));
1522 termCall->setDoesNotThrow();
1523 termCall->setDoesNotReturn();
1524 termCall->setCallingConv(CGM.getRuntimeCC());
1526 // std::terminate cannot return.
1527 builder.CreateUnreachable();
1533 llvm::BasicBlock *CodeGenFunction::getTerminateLandingPad() {
1534 if (TerminateLandingPad)
1535 return TerminateLandingPad;
1537 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1539 // This will get inserted at the end of the function.
1540 TerminateLandingPad = createBasicBlock("terminate.lpad");
1541 Builder.SetInsertPoint(TerminateLandingPad);
1543 // Tell the backend that this is a landing pad.
1544 const EHPersonality &Personality = EHPersonality::get(CGM.getLangOpts());
1545 llvm::LandingPadInst *LPadInst =
1546 Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty, NULL),
1547 getOpaquePersonalityFn(CGM, Personality), 0);
1548 LPadInst->addClause(getCatchAllValue(*this));
1550 llvm::CallInst *terminateCall;
1551 if (useClangCallTerminate(CGM)) {
1552 // Extract out the exception pointer.
1553 llvm::Value *exn = Builder.CreateExtractValue(LPadInst, 0);
1554 terminateCall = EmitNounwindRuntimeCall(getClangCallTerminateFn(CGM), exn);
1556 terminateCall = EmitNounwindRuntimeCall(getTerminateFn(CGM));
1558 terminateCall->setDoesNotReturn();
1559 Builder.CreateUnreachable();
1561 // Restore the saved insertion state.
1562 Builder.restoreIP(SavedIP);
1564 return TerminateLandingPad;
1567 llvm::BasicBlock *CodeGenFunction::getTerminateHandler() {
1568 if (TerminateHandler)
1569 return TerminateHandler;
1571 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
1573 // Set up the terminate handler. This block is inserted at the very
1574 // end of the function by FinishFunction.
1575 TerminateHandler = createBasicBlock("terminate.handler");
1576 Builder.SetInsertPoint(TerminateHandler);
1577 llvm::CallInst *terminateCall;
1578 if (useClangCallTerminate(CGM)) {
1579 // Load the exception pointer.
1580 llvm::Value *exn = getExceptionFromSlot();
1581 terminateCall = EmitNounwindRuntimeCall(getClangCallTerminateFn(CGM), exn);
1583 terminateCall = EmitNounwindRuntimeCall(getTerminateFn(CGM));
1585 terminateCall->setDoesNotReturn();
1586 Builder.CreateUnreachable();
1588 // Restore the saved insertion state.
1589 Builder.restoreIP(SavedIP);
1591 return TerminateHandler;
1594 llvm::BasicBlock *CodeGenFunction::getEHResumeBlock(bool isCleanup) {
1595 if (EHResumeBlock) return EHResumeBlock;
1597 CGBuilderTy::InsertPoint SavedIP = Builder.saveIP();
1599 // We emit a jump to a notional label at the outermost unwind state.
1600 EHResumeBlock = createBasicBlock("eh.resume");
1601 Builder.SetInsertPoint(EHResumeBlock);
1603 const EHPersonality &Personality = EHPersonality::get(CGM.getLangOpts());
1605 // This can always be a call because we necessarily didn't find
1606 // anything on the EH stack which needs our help.
1607 const char *RethrowName = Personality.CatchallRethrowFn;
1608 if (RethrowName != nullptr && !isCleanup) {
1609 EmitRuntimeCall(getCatchallRethrowFn(CGM, RethrowName),
1610 getExceptionFromSlot())
1611 ->setDoesNotReturn();
1612 Builder.CreateUnreachable();
1613 Builder.restoreIP(SavedIP);
1614 return EHResumeBlock;
1617 // Recreate the landingpad's return value for the 'resume' instruction.
1618 llvm::Value *Exn = getExceptionFromSlot();
1619 llvm::Value *Sel = getSelectorFromSlot();
1621 llvm::Type *LPadType = llvm::StructType::get(Exn->getType(),
1622 Sel->getType(), NULL);
1623 llvm::Value *LPadVal = llvm::UndefValue::get(LPadType);
1624 LPadVal = Builder.CreateInsertValue(LPadVal, Exn, 0, "lpad.val");
1625 LPadVal = Builder.CreateInsertValue(LPadVal, Sel, 1, "lpad.val");
1627 Builder.CreateResume(LPadVal);
1628 Builder.restoreIP(SavedIP);
1629 return EHResumeBlock;
1632 void CodeGenFunction::EmitSEHTryStmt(const SEHTryStmt &S) {
1633 CGM.ErrorUnsupported(&S, "SEH __try");
1636 void CodeGenFunction::EmitSEHLeaveStmt(const SEHLeaveStmt &S) {
1637 CGM.ErrorUnsupported(&S, "SEH __leave");