head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.11 netbsd-11-0-RC3:1.1.1.11 netbsd-11-0-RC2:1.1.1.11 netbsd-11-0-RC1:1.1.1.11 perseant-exfatfs-base-20250801:1.1.1.11 netbsd-11:1.1.1.11.0.10 netbsd-11-base:1.1.1.11 netbsd-10-1-RELEASE:1.1.1.11 perseant-exfatfs-base-20240630:1.1.1.11 perseant-exfatfs:1.1.1.11.0.8 perseant-exfatfs-base:1.1.1.11 netbsd-8-3-RELEASE:1.1.1.8 netbsd-9-4-RELEASE:1.1.1.10 netbsd-10-0-RELEASE:1.1.1.11 netbsd-10-0-RC6:1.1.1.11 netbsd-10-0-RC5:1.1.1.11 netbsd-10-0-RC4:1.1.1.11 netbsd-10-0-RC3:1.1.1.11 netbsd-10-0-RC2:1.1.1.11 netbsd-10-0-RC1:1.1.1.11 netbsd-10:1.1.1.11.0.6 netbsd-10-base:1.1.1.11 netbsd-9-3-RELEASE:1.1.1.10 cjep_sun2x:1.1.1.11.0.4 cjep_sun2x-base:1.1.1.11 cjep_staticlib_x-base1:1.1.1.11 netbsd-9-2-RELEASE:1.1.1.10 cjep_staticlib_x:1.1.1.11.0.2 cjep_staticlib_x-base:1.1.1.11 netbsd-9-1-RELEASE:1.1.1.10 phil-wifi-20200421:1.1.1.11 phil-wifi-20200411:1.1.1.11 phil-wifi-20200406:1.1.1.11 netbsd-8-2-RELEASE:1.1.1.8 netbsd-9-0-RELEASE:1.1.1.10 netbsd-9-0-RC2:1.1.1.10 netbsd-9-0-RC1:1.1.1.10 netbsd-9:1.1.1.10.0.2 netbsd-9-base:1.1.1.10 phil-wifi-20190609:1.1.1.10 netbsd-8-1-RELEASE:1.1.1.8 netbsd-8-1-RC1:1.1.1.8 pgoyette-compat-merge-20190127:1.1.1.9.2.1 pgoyette-compat-20190127:1.1.1.10 pgoyette-compat-20190118:1.1.1.10 pgoyette-compat-1226:1.1.1.10 pgoyette-compat-1126:1.1.1.10 pgoyette-compat-1020:1.1.1.10 pgoyette-compat-0930:1.1.1.10 pgoyette-compat-0906:1.1.1.10 netbsd-7-2-RELEASE:1.1.1.5.2.1 pgoyette-compat-0728:1.1.1.10 clang-337282:1.1.1.10 netbsd-8-0-RELEASE:1.1.1.8 phil-wifi:1.1.1.9.0.4 phil-wifi-base:1.1.1.9 pgoyette-compat-0625:1.1.1.9 netbsd-8-0-RC2:1.1.1.8 pgoyette-compat-0521:1.1.1.9 pgoyette-compat-0502:1.1.1.9 pgoyette-compat-0422:1.1.1.9 netbsd-8-0-RC1:1.1.1.8 pgoyette-compat-0415:1.1.1.9 pgoyette-compat-0407:1.1.1.9 pgoyette-compat-0330:1.1.1.9 pgoyette-compat-0322:1.1.1.9 pgoyette-compat-0315:1.1.1.9 netbsd-7-1-2-RELEASE:1.1.1.5.2.1 pgoyette-compat:1.1.1.9.0.2 pgoyette-compat-base:1.1.1.9 netbsd-7-1-1-RELEASE:1.1.1.5.2.1 clang-319952:1.1.1.9 matt-nb8-mediatek:1.1.1.8.0.10 matt-nb8-mediatek-base:1.1.1.8 clang-309604:1.1.1.9 perseant-stdc-iso10646:1.1.1.8.0.8 perseant-stdc-iso10646-base:1.1.1.8 netbsd-8:1.1.1.8.0.6 netbsd-8-base:1.1.1.8 prg-localcount2-base3:1.1.1.8 prg-localcount2-base2:1.1.1.8 prg-localcount2-base1:1.1.1.8 prg-localcount2:1.1.1.8.0.4 prg-localcount2-base:1.1.1.8 pgoyette-localcount-20170426:1.1.1.8 bouyer-socketcan-base1:1.1.1.8 pgoyette-localcount-20170320:1.1.1.8 netbsd-7-1:1.1.1.5.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.5.2.1 netbsd-7-1-RC2:1.1.1.5.2.1 clang-294123:1.1.1.8 netbsd-7-nhusb-base-20170116:1.1.1.5.2.1 bouyer-socketcan:1.1.1.8.0.2 bouyer-socketcan-base:1.1.1.8 clang-291444:1.1.1.8 pgoyette-localcount-20170107:1.1.1.7 netbsd-7-1-RC1:1.1.1.5.2.1 pgoyette-localcount-20161104:1.1.1.7 netbsd-7-0-2-RELEASE:1.1.1.5.2.1 localcount-20160914:1.1.1.7 netbsd-7-nhusb:1.1.1.5.2.1.0.4 netbsd-7-nhusb-base:1.1.1.5.2.1 clang-280599:1.1.1.7 pgoyette-localcount-20160806:1.1.1.7 pgoyette-localcount-20160726:1.1.1.7 pgoyette-localcount:1.1.1.7.0.2 pgoyette-localcount-base:1.1.1.7 netbsd-7-0-1-RELEASE:1.1.1.5.2.1 clang-261930:1.1.1.7 netbsd-7-0:1.1.1.5.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.5.2.1 netbsd-7-0-RC3:1.1.1.5.2.1 netbsd-7-0-RC2:1.1.1.5.2.1 netbsd-7-0-RC1:1.1.1.5.2.1 clang-237755:1.1.1.6 clang-232565:1.1.1.6 clang-227398:1.1.1.6 tls-maxphys-base:1.1.1.5 tls-maxphys:1.1.1.5.0.4 netbsd-7:1.1.1.5.0.2 netbsd-7-base:1.1.1.5 clang-215315:1.1.1.5 clang-209886:1.1.1.4 yamt-pagecache:1.1.1.3.0.4 yamt-pagecache-base9:1.1.1.3 tls-earlyentropy:1.1.1.3.0.2 tls-earlyentropy-base:1.1.1.4 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.3 riastradh-drm2-base3:1.1.1.3 clang-202566:1.1.1.3 clang-201163:1.1.1.3 clang-199312:1.1.1.2 clang-198450:1.1.1.1 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.15.21.26.25; author joerg; state Exp; branches; next 1.1.1.3; commitid NQXlzzA0SPkc5glx; 1.1.1.3 date 2014.02.14.20.07.09; author joerg; state Exp; branches 1.1.1.3.2.1 1.1.1.3.4.1; next 1.1.1.4; commitid annVkZ1sc17rF6px; 1.1.1.4 date 2014.05.30.18.14.40; author joerg; state Exp; branches; next 1.1.1.5; commitid 8q0kdlBlCn09GACx; 1.1.1.5 date 2014.08.10.17.08.35; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid N85tXAN6Ex9VZPLx; 1.1.1.6 date 2015.01.29.19.57.31; author joerg; state Exp; branches; next 1.1.1.7; commitid mlISSizlPKvepX7y; 1.1.1.7 date 2016.02.27.22.12.08; author joerg; state Exp; branches 1.1.1.7.2.1; next 1.1.1.8; commitid tIimz3oDlh1NpBWy; 1.1.1.8 date 2017.01.11.10.33.15; author joerg; state Exp; branches; next 1.1.1.9; commitid CNnUNfII1jgNmxBz; 1.1.1.9 date 2017.08.01.19.35.20; author joerg; state Exp; branches 1.1.1.9.2.1 1.1.1.9.4.1; next 1.1.1.10; commitid pMuDy65V0VicSx1A; 1.1.1.10 date 2018.07.17.18.30.59; author joerg; state Exp; branches; next 1.1.1.11; commitid wDzL46ALjrCZgwKA; 1.1.1.11 date 2019.11.13.22.19.21; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.3.2.1 date 2014.08.10.07.08.07; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.3.4.1 date 2014.02.14.20.07.09; author yamt; state dead; branches; next 1.1.1.3.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.3.4.2 date 2014.05.22.16.18.26; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.2.1 date 2015.06.04.20.04.27; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.5.4.1 date 2014.08.10.17.08.35; author tls; state dead; branches; next 1.1.1.5.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.5.4.2 date 2014.08.19.23.47.27; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.2.1 date 2017.03.20.06.52.37; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.9.2.1 date 2018.07.28.04.33.17; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.9.4.1 date 2019.06.10.21.45.21; author christos; state Exp; branches; next 1.1.1.9.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.9.4.2 date 2020.04.13.07.46.32; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- CGException.cpp - Emit LLVM Code for C++ exceptions --------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This contains code dealing with C++ exception related code generation. // //===----------------------------------------------------------------------===// #include "CodeGenFunction.h" #include "CGCleanup.h" #include "CGObjCRuntime.h" #include "TargetInfo.h" #include "clang/AST/StmtCXX.h" #include "clang/AST/StmtObjC.h" #include "llvm/IR/Intrinsics.h" #include "llvm/Support/CallSite.h" using namespace clang; using namespace CodeGen; static llvm::Constant *getAllocateExceptionFn(CodeGenModule &CGM) { // void *__cxa_allocate_exception(size_t thrown_size); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.Int8PtrTy, CGM.SizeTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_allocate_exception"); } static llvm::Constant *getFreeExceptionFn(CodeGenModule &CGM) { // void __cxa_free_exception(void *thrown_exception); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_free_exception"); } static llvm::Constant *getThrowFn(CodeGenModule &CGM) { // void __cxa_throw(void *thrown_exception, std::type_info *tinfo, // void (*dest) (void *)); llvm::Type *Args[3] = { CGM.Int8PtrTy, CGM.Int8PtrTy, CGM.Int8PtrTy }; llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, Args, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_throw"); } static llvm::Constant *getReThrowFn(CodeGenModule &CGM) { // void __cxa_rethrow(); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_rethrow"); } static llvm::Constant *getGetExceptionPtrFn(CodeGenModule &CGM) { // void *__cxa_get_exception_ptr(void*); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_get_exception_ptr"); } static llvm::Constant *getBeginCatchFn(CodeGenModule &CGM) { // void *__cxa_begin_catch(void*); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_begin_catch"); } static llvm::Constant *getEndCatchFn(CodeGenModule &CGM) { // void __cxa_end_catch(); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_end_catch"); } static llvm::Constant *getUnexpectedFn(CodeGenModule &CGM) { // void __cxa_call_unexpected(void *thrown_exception); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_call_unexpected"); } llvm::Constant *CodeGenFunction::getUnwindResumeFn() { llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, Int8PtrTy, /*IsVarArgs=*/false); if (CGM.getLangOpts().SjLjExceptions) return CGM.CreateRuntimeFunction(FTy, "_Unwind_SjLj_Resume"); return CGM.CreateRuntimeFunction(FTy, "_Unwind_Resume"); } llvm::Constant *CodeGenFunction::getUnwindResumeOrRethrowFn() { llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, Int8PtrTy, /*IsVarArgs=*/false); if (CGM.getLangOpts().SjLjExceptions) return CGM.CreateRuntimeFunction(FTy, "_Unwind_SjLj_Resume_or_Rethrow"); return CGM.CreateRuntimeFunction(FTy, "_Unwind_Resume_or_Rethrow"); } static llvm::Constant *getTerminateFn(CodeGenModule &CGM) { // void __terminate(); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false); StringRef name; // In C++, use std::terminate(). if (CGM.getLangOpts().CPlusPlus) name = "_ZSt9terminatev"; // FIXME: mangling! else if (CGM.getLangOpts().ObjC1 && CGM.getLangOpts().ObjCRuntime.hasTerminate()) name = "objc_terminate"; else name = "abort"; return CGM.CreateRuntimeFunction(FTy, name); } static llvm::Constant *getCatchallRethrowFn(CodeGenModule &CGM, StringRef Name) { llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, Name); } namespace { /// The exceptions personality for a function. struct EHPersonality { const char *PersonalityFn; // If this is non-null, this personality requires a non-standard // function for rethrowing an exception after a catchall cleanup. // This function must have prototype void(void*). const char *CatchallRethrowFn; static const EHPersonality &get(const LangOptions &Lang); static const EHPersonality GNU_C; static const EHPersonality GNU_C_SJLJ; static const EHPersonality GNU_ObjC; static const EHPersonality GNUstep_ObjC; static const EHPersonality GNU_ObjCXX; static const EHPersonality NeXT_ObjC; static const EHPersonality GNU_CPlusPlus; static const EHPersonality GNU_CPlusPlus_SJLJ; }; } const EHPersonality EHPersonality::GNU_C = { "__gcc_personality_v0", 0 }; const EHPersonality EHPersonality::GNU_C_SJLJ = { "__gcc_personality_sj0", 0 }; const EHPersonality EHPersonality::NeXT_ObjC = { "__objc_personality_v0", 0 }; const EHPersonality EHPersonality::GNU_CPlusPlus = { "__gxx_personality_v0", 0}; const EHPersonality EHPersonality::GNU_CPlusPlus_SJLJ = { "__gxx_personality_sj0", 0 }; const EHPersonality EHPersonality::GNU_ObjC = {"__gnu_objc_personality_v0", "objc_exception_throw"}; const EHPersonality EHPersonality::GNU_ObjCXX = { "__gnustep_objcxx_personality_v0", 0 }; const EHPersonality EHPersonality::GNUstep_ObjC = { "__gnustep_objc_personality_v0", 0 }; static const EHPersonality &getCPersonality(const LangOptions &L) { if (L.SjLjExceptions) return EHPersonality::GNU_C_SJLJ; return EHPersonality::GNU_C; } static const EHPersonality &getObjCPersonality(const LangOptions &L) { switch (L.ObjCRuntime.getKind()) { case ObjCRuntime::FragileMacOSX: return getCPersonality(L); case ObjCRuntime::MacOSX: case ObjCRuntime::iOS: return EHPersonality::NeXT_ObjC; case ObjCRuntime::GNUstep: if (L.ObjCRuntime.getVersion() >= VersionTuple(1, 7)) return EHPersonality::GNUstep_ObjC; // fallthrough case ObjCRuntime::GCC: case ObjCRuntime::ObjFW: return EHPersonality::GNU_ObjC; } llvm_unreachable("bad runtime kind"); } static const EHPersonality &getCXXPersonality(const LangOptions &L) { if (L.SjLjExceptions) return EHPersonality::GNU_CPlusPlus_SJLJ; else return EHPersonality::GNU_CPlusPlus; } /// Determines the personality function to use when both C++ /// and Objective-C exceptions are being caught. static const EHPersonality &getObjCXXPersonality(const LangOptions &L) { switch (L.ObjCRuntime.getKind()) { // The ObjC personality defers to the C++ personality for non-ObjC // handlers. Unlike the C++ case, we use the same personality // function on targets using (backend-driven) SJLJ EH. case ObjCRuntime::MacOSX: case ObjCRuntime::iOS: return EHPersonality::NeXT_ObjC; // In the fragile ABI, just use C++ exception handling and hope // they're not doing crazy exception mixing. case ObjCRuntime::FragileMacOSX: return getCXXPersonality(L); // The GCC runtime's personality function inherently doesn't support // mixed EH. Use the C++ personality just to avoid returning null. case ObjCRuntime::GCC: case ObjCRuntime::ObjFW: // XXX: this will change soon return EHPersonality::GNU_ObjC; case ObjCRuntime::GNUstep: return EHPersonality::GNU_ObjCXX; } llvm_unreachable("bad runtime kind"); } const EHPersonality &EHPersonality::get(const LangOptions &L) { if (L.CPlusPlus && L.ObjC1) return getObjCXXPersonality(L); else if (L.CPlusPlus) return getCXXPersonality(L); else if (L.ObjC1) return getObjCPersonality(L); else return getCPersonality(L); } static llvm::Constant *getPersonalityFn(CodeGenModule &CGM, const EHPersonality &Personality) { llvm::Constant *Fn = CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty, true), Personality.PersonalityFn); return Fn; } static llvm::Constant *getOpaquePersonalityFn(CodeGenModule &CGM, const EHPersonality &Personality) { llvm::Constant *Fn = getPersonalityFn(CGM, Personality); return llvm::ConstantExpr::getBitCast(Fn, CGM.Int8PtrTy); } /// Check whether a personality function could reasonably be swapped /// for a C++ personality function. static bool PersonalityHasOnlyCXXUses(llvm::Constant *Fn) { for (llvm::Constant::use_iterator I = Fn->use_begin(), E = Fn->use_end(); I != E; ++I) { llvm::User *User = *I; // Conditionally white-list bitcasts. if (llvm::ConstantExpr *CE = dyn_cast(User)) { if (CE->getOpcode() != llvm::Instruction::BitCast) return false; if (!PersonalityHasOnlyCXXUses(CE)) return false; continue; } // Otherwise, it has to be a landingpad instruction. llvm::LandingPadInst *LPI = dyn_cast(User); if (!LPI) return false; for (unsigned I = 0, E = LPI->getNumClauses(); I != E; ++I) { // Look for something that would've been returned by the ObjC // runtime's GetEHType() method. llvm::Value *Val = LPI->getClause(I)->stripPointerCasts(); if (LPI->isCatch(I)) { // Check if the catch value has the ObjC prefix. if (llvm::GlobalVariable *GV = dyn_cast(Val)) // ObjC EH selector entries are always global variables with // names starting like this. if (GV->getName().startswith("OBJC_EHTYPE")) return false; } else { // Check if any of the filter values have the ObjC prefix. llvm::Constant *CVal = cast(Val); for (llvm::User::op_iterator II = CVal->op_begin(), IE = CVal->op_end(); II != IE; ++II) { if (llvm::GlobalVariable *GV = cast((*II)->stripPointerCasts())) // ObjC EH selector entries are always global variables with // names starting like this. if (GV->getName().startswith("OBJC_EHTYPE")) return false; } } } } return true; } /// Try to use the C++ personality function in ObjC++. Not doing this /// can cause some incompatibilities with gcc, which is more /// aggressive about only using the ObjC++ personality in a function /// when it really needs it. void CodeGenModule::SimplifyPersonality() { // If we're not in ObjC++ -fexceptions, there's nothing to do. if (!LangOpts.CPlusPlus || !LangOpts.ObjC1 || !LangOpts.Exceptions) return; // Both the problem this endeavors to fix and the way the logic // above works is specific to the NeXT runtime. if (!LangOpts.ObjCRuntime.isNeXTFamily()) return; const EHPersonality &ObjCXX = EHPersonality::get(LangOpts); const EHPersonality &CXX = getCXXPersonality(LangOpts); if (&ObjCXX == &CXX) return; assert(std::strcmp(ObjCXX.PersonalityFn, CXX.PersonalityFn) != 0 && "Different EHPersonalities using the same personality function."); llvm::Function *Fn = getModule().getFunction(ObjCXX.PersonalityFn); // Nothing to do if it's unused. if (!Fn || Fn->use_empty()) return; // Can't do the optimization if it has non-C++ uses. if (!PersonalityHasOnlyCXXUses(Fn)) return; // Create the C++ personality function and kill off the old // function. llvm::Constant *CXXFn = getPersonalityFn(*this, CXX); // This can happen if the user is screwing with us. if (Fn->getType() != CXXFn->getType()) return; Fn->replaceAllUsesWith(CXXFn); Fn->eraseFromParent(); } /// Returns the value to inject into a selector to indicate the /// presence of a catch-all. static llvm::Constant *getCatchAllValue(CodeGenFunction &CGF) { // Possibly we should use @@llvm.eh.catch.all.value here. return llvm::ConstantPointerNull::get(CGF.Int8PtrTy); } namespace { /// A cleanup to free the exception object if its initialization /// throws. struct FreeException : EHScopeStack::Cleanup { llvm::Value *exn; FreeException(llvm::Value *exn) : exn(exn) {} void Emit(CodeGenFunction &CGF, Flags flags) { CGF.EmitNounwindRuntimeCall(getFreeExceptionFn(CGF.CGM), exn); } }; } // Emits an exception expression into the given location. This // differs from EmitAnyExprToMem only in that, if a final copy-ctor // call is required, an exception within that copy ctor causes // std::terminate to be invoked. static void EmitAnyExprToExn(CodeGenFunction &CGF, const Expr *e, llvm::Value *addr) { // Make sure the exception object is cleaned up if there's an // exception during initialization. CGF.pushFullExprCleanup(EHCleanup, addr); EHScopeStack::stable_iterator cleanup = CGF.EHStack.stable_begin(); // __cxa_allocate_exception returns a void*; we need to cast this // to the appropriate type for the object. llvm::Type *ty = CGF.ConvertTypeForMem(e->getType())->getPointerTo(); llvm::Value *typedAddr = CGF.Builder.CreateBitCast(addr, ty); // FIXME: this isn't quite right! If there's a final unelided call // to a copy constructor, then according to [except.terminate]p1 we // must call std::terminate() if that constructor throws, because // technically that copy occurs after the exception expression is // evaluated but before the exception is caught. But the best way // to handle that is to teach EmitAggExpr to do the final copy // differently if it can't be elided. CGF.EmitAnyExprToMem(e, typedAddr, e->getType().getQualifiers(), /*IsInit*/ true); // Deactivate the cleanup block. CGF.DeactivateCleanupBlock(cleanup, cast(typedAddr)); } llvm::Value *CodeGenFunction::getExceptionSlot() { if (!ExceptionSlot) ExceptionSlot = CreateTempAlloca(Int8PtrTy, "exn.slot"); return ExceptionSlot; } llvm::Value *CodeGenFunction::getEHSelectorSlot() { if (!EHSelectorSlot) EHSelectorSlot = CreateTempAlloca(Int32Ty, "ehselector.slot"); return EHSelectorSlot; } llvm::Value *CodeGenFunction::getExceptionFromSlot() { return Builder.CreateLoad(getExceptionSlot(), "exn"); } llvm::Value *CodeGenFunction::getSelectorFromSlot() { return Builder.CreateLoad(getEHSelectorSlot(), "sel"); } void CodeGenFunction::EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint) { if (!E->getSubExpr()) { EmitNoreturnRuntimeCallOrInvoke(getReThrowFn(CGM), ArrayRef()); // throw is an expression, and the expression emitters expect us // to leave ourselves at a valid insertion point. if (KeepInsertionPoint) EmitBlock(createBasicBlock("throw.cont")); return; } QualType ThrowType = E->getSubExpr()->getType(); if (ThrowType->isObjCObjectPointerType()) { const Stmt *ThrowStmt = E->getSubExpr(); const ObjCAtThrowStmt S(E->getExprLoc(), const_cast(ThrowStmt)); CGM.getObjCRuntime().EmitThrowStmt(*this, S, false); // This will clear insertion point which was not cleared in // call to EmitThrowStmt. if (KeepInsertionPoint) EmitBlock(createBasicBlock("throw.cont")); return; } // Now allocate the exception object. llvm::Type *SizeTy = ConvertType(getContext().getSizeType()); uint64_t TypeSize = getContext().getTypeSizeInChars(ThrowType).getQuantity(); llvm::Constant *AllocExceptionFn = getAllocateExceptionFn(CGM); llvm::CallInst *ExceptionPtr = EmitNounwindRuntimeCall(AllocExceptionFn, llvm::ConstantInt::get(SizeTy, TypeSize), "exception"); EmitAnyExprToExn(*this, E->getSubExpr(), ExceptionPtr); // Now throw the exception. llvm::Constant *TypeInfo = CGM.GetAddrOfRTTIDescriptor(ThrowType, /*ForEH=*/true); // The address of the destructor. If the exception type has a // trivial destructor (or isn't a record), we just pass null. llvm::Constant *Dtor = 0; if (const RecordType *RecordTy = ThrowType->getAs()) { CXXRecordDecl *Record = cast(RecordTy->getDecl()); if (!Record->hasTrivialDestructor()) { CXXDestructorDecl *DtorD = Record->getDestructor(); Dtor = CGM.GetAddrOfCXXDestructor(DtorD, Dtor_Complete); Dtor = llvm::ConstantExpr::getBitCast(Dtor, Int8PtrTy); } } if (!Dtor) Dtor = llvm::Constant::getNullValue(Int8PtrTy); llvm::Value *args[] = { ExceptionPtr, TypeInfo, Dtor }; EmitNoreturnRuntimeCallOrInvoke(getThrowFn(CGM), args); // throw is an expression, and the expression emitters expect us // to leave ourselves at a valid insertion point. if (KeepInsertionPoint) EmitBlock(createBasicBlock("throw.cont")); } void CodeGenFunction::EmitStartEHSpec(const Decl *D) { if (!CGM.getLangOpts().CXXExceptions) return; const FunctionDecl* FD = dyn_cast_or_null(D); if (FD == 0) return; const FunctionProtoType *Proto = FD->getType()->getAs(); if (Proto == 0) return; ExceptionSpecificationType EST = Proto->getExceptionSpecType(); if (isNoexceptExceptionSpec(EST)) { if (Proto->getNoexceptSpec(getContext()) == FunctionProtoType::NR_Nothrow) { // noexcept functions are simple terminate scopes. EHStack.pushTerminate(); } } else if (EST == EST_Dynamic || EST == EST_DynamicNone) { unsigned NumExceptions = Proto->getNumExceptions(); EHFilterScope *Filter = EHStack.pushFilter(NumExceptions); for (unsigned I = 0; I != NumExceptions; ++I) { QualType Ty = Proto->getExceptionType(I); QualType ExceptType = Ty.getNonReferenceType().getUnqualifiedType(); llvm::Value *EHType = CGM.GetAddrOfRTTIDescriptor(ExceptType, /*ForEH=*/true); Filter->setFilter(I, EHType); } } } /// Emit the dispatch block for a filter scope if necessary. static void emitFilterDispatchBlock(CodeGenFunction &CGF, EHFilterScope &filterScope) { llvm::BasicBlock *dispatchBlock = filterScope.getCachedEHDispatchBlock(); if (!dispatchBlock) return; if (dispatchBlock->use_empty()) { delete dispatchBlock; return; } CGF.EmitBlockAfterUses(dispatchBlock); // If this isn't a catch-all filter, we need to check whether we got // here because the filter triggered. if (filterScope.getNumFilters()) { // Load the selector value. llvm::Value *selector = CGF.getSelectorFromSlot(); llvm::BasicBlock *unexpectedBB = CGF.createBasicBlock("ehspec.unexpected"); llvm::Value *zero = CGF.Builder.getInt32(0); llvm::Value *failsFilter = CGF.Builder.CreateICmpSLT(selector, zero, "ehspec.fails"); CGF.Builder.CreateCondBr(failsFilter, unexpectedBB, CGF.getEHResumeBlock(false)); CGF.EmitBlock(unexpectedBB); } // Call __cxa_call_unexpected. This doesn't need to be an invoke // because __cxa_call_unexpected magically filters exceptions // according to the last landing pad the exception was thrown // into. Seriously. llvm::Value *exn = CGF.getExceptionFromSlot(); CGF.EmitRuntimeCall(getUnexpectedFn(CGF.CGM), exn) ->setDoesNotReturn(); CGF.Builder.CreateUnreachable(); } void CodeGenFunction::EmitEndEHSpec(const Decl *D) { if (!CGM.getLangOpts().CXXExceptions) return; const FunctionDecl* FD = dyn_cast_or_null(D); if (FD == 0) return; const FunctionProtoType *Proto = FD->getType()->getAs(); if (Proto == 0) return; ExceptionSpecificationType EST = Proto->getExceptionSpecType(); if (isNoexceptExceptionSpec(EST)) { if (Proto->getNoexceptSpec(getContext()) == FunctionProtoType::NR_Nothrow) { EHStack.popTerminate(); } } else if (EST == EST_Dynamic || EST == EST_DynamicNone) { EHFilterScope &filterScope = cast(*EHStack.begin()); emitFilterDispatchBlock(*this, filterScope); EHStack.popFilter(); } } void CodeGenFunction::EmitCXXTryStmt(const CXXTryStmt &S) { EnterCXXTryStmt(S); EmitStmt(S.getTryBlock()); ExitCXXTryStmt(S); } void CodeGenFunction::EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) { unsigned NumHandlers = S.getNumHandlers(); EHCatchScope *CatchScope = EHStack.pushCatch(NumHandlers); for (unsigned I = 0; I != NumHandlers; ++I) { const CXXCatchStmt *C = S.getHandler(I); llvm::BasicBlock *Handler = createBasicBlock("catch"); if (C->getExceptionDecl()) { // FIXME: Dropping the reference type on the type into makes it // impossible to correctly implement catch-by-reference // semantics for pointers. Unfortunately, this is what all // existing compilers do, and it's not clear that the standard // personality routine is capable of doing this right. See C++ DR 388: // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#388 QualType CaughtType = C->getCaughtType(); CaughtType = CaughtType.getNonReferenceType().getUnqualifiedType(); llvm::Value *TypeInfo = 0; if (CaughtType->isObjCObjectPointerType()) TypeInfo = CGM.getObjCRuntime().GetEHType(CaughtType); else TypeInfo = CGM.GetAddrOfRTTIDescriptor(CaughtType, /*ForEH=*/true); CatchScope->setHandler(I, TypeInfo, Handler); } else { // No exception decl indicates '...', a catch-all. CatchScope->setCatchAllHandler(I, Handler); } } } llvm::BasicBlock * CodeGenFunction::getEHDispatchBlock(EHScopeStack::stable_iterator si) { // The dispatch block for the end of the scope chain is a block that // just resumes unwinding. if (si == EHStack.stable_end()) return getEHResumeBlock(true); // Otherwise, we should look at the actual scope. EHScope &scope = *EHStack.find(si); llvm::BasicBlock *dispatchBlock = scope.getCachedEHDispatchBlock(); if (!dispatchBlock) { switch (scope.getKind()) { case EHScope::Catch: { // Apply a special case to a single catch-all. EHCatchScope &catchScope = cast(scope); if (catchScope.getNumHandlers() == 1 && catchScope.getHandler(0).isCatchAll()) { dispatchBlock = catchScope.getHandler(0).Block; // Otherwise, make a dispatch block. } else { dispatchBlock = createBasicBlock("catch.dispatch"); } break; } case EHScope::Cleanup: dispatchBlock = createBasicBlock("ehcleanup"); break; case EHScope::Filter: dispatchBlock = createBasicBlock("filter.dispatch"); break; case EHScope::Terminate: dispatchBlock = getTerminateHandler(); break; } scope.setCachedEHDispatchBlock(dispatchBlock); } return dispatchBlock; } /// Check whether this is a non-EH scope, i.e. a scope which doesn't /// affect exception handling. Currently, the only non-EH scopes are /// normal-only cleanup scopes. static bool isNonEHScope(const EHScope &S) { switch (S.getKind()) { case EHScope::Cleanup: return !cast(S).isEHCleanup(); case EHScope::Filter: case EHScope::Catch: case EHScope::Terminate: return false; } llvm_unreachable("Invalid EHScope Kind!"); } llvm::BasicBlock *CodeGenFunction::getInvokeDestImpl() { assert(EHStack.requiresLandingPad()); assert(!EHStack.empty()); if (!CGM.getLangOpts().Exceptions) return 0; // Check the innermost scope for a cached landing pad. If this is // a non-EH cleanup, we'll check enclosing scopes in EmitLandingPad. llvm::BasicBlock *LP = EHStack.begin()->getCachedLandingPad(); if (LP) return LP; // Build the landing pad for this scope. LP = EmitLandingPad(); assert(LP); // Cache the landing pad on the innermost scope. If this is a // non-EH scope, cache the landing pad on the enclosing scope, too. for (EHScopeStack::iterator ir = EHStack.begin(); true; ++ir) { ir->setCachedLandingPad(LP); if (!isNonEHScope(*ir)) break; } return LP; } // This code contains a hack to work around a design flaw in // LLVM's EH IR which breaks semantics after inlining. This same // hack is implemented in llvm-gcc. // // The LLVM EH abstraction is basically a thin veneer over the // traditional GCC zero-cost design: for each range of instructions // in the function, there is (at most) one "landing pad" with an // associated chain of EH actions. A language-specific personality // function interprets this chain of actions and (1) decides whether // or not to resume execution at the landing pad and (2) if so, // provides an integer indicating why it's stopping. In LLVM IR, // the association of a landing pad with a range of instructions is // achieved via an invoke instruction, the chain of actions becomes // the arguments to the @@llvm.eh.selector call, and the selector // call returns the integer indicator. Other than the required // presence of two intrinsic function calls in the landing pad, // the IR exactly describes the layout of the output code. // // A principal advantage of this design is that it is completely // language-agnostic; in theory, the LLVM optimizers can treat // landing pads neutrally, and targets need only know how to lower // the intrinsics to have a functioning exceptions system (assuming // that platform exceptions follow something approximately like the // GCC design). Unfortunately, landing pads cannot be combined in a // language-agnostic way: given selectors A and B, there is no way // to make a single landing pad which faithfully represents the // semantics of propagating an exception first through A, then // through B, without knowing how the personality will interpret the // (lowered form of the) selectors. This means that inlining has no // choice but to crudely chain invokes (i.e., to ignore invokes in // the inlined function, but to turn all unwindable calls into // invokes), which is only semantically valid if every unwind stops // at every landing pad. // // Therefore, the invoke-inline hack is to guarantee that every // landing pad has a catch-all. enum CleanupHackLevel_t { /// A level of hack that requires that all landing pads have /// catch-alls. CHL_MandatoryCatchall, /// A level of hack that requires that all landing pads handle /// cleanups. CHL_MandatoryCleanup, /// No hacks at all; ideal IR generation. CHL_Ideal }; const CleanupHackLevel_t CleanupHackLevel = CHL_MandatoryCleanup; llvm::BasicBlock *CodeGenFunction::EmitLandingPad() { assert(EHStack.requiresLandingPad()); EHScope &innermostEHScope = *EHStack.find(EHStack.getInnermostEHScope()); switch (innermostEHScope.getKind()) { case EHScope::Terminate: return getTerminateLandingPad(); case EHScope::Catch: case EHScope::Cleanup: case EHScope::Filter: if (llvm::BasicBlock *lpad = innermostEHScope.getCachedLandingPad()) return lpad; } // Save the current IR generation state. CGBuilderTy::InsertPoint savedIP = Builder.saveAndClearIP(); SourceLocation SavedLocation; if (CGDebugInfo *DI = getDebugInfo()) { SavedLocation = DI->getLocation(); DI->EmitLocation(Builder, CurEHLocation); } const EHPersonality &personality = EHPersonality::get(getLangOpts()); // Create and configure the landing pad. llvm::BasicBlock *lpad = createBasicBlock("lpad"); EmitBlock(lpad); llvm::LandingPadInst *LPadInst = Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty, NULL), getOpaquePersonalityFn(CGM, personality), 0); llvm::Value *LPadExn = Builder.CreateExtractValue(LPadInst, 0); Builder.CreateStore(LPadExn, getExceptionSlot()); llvm::Value *LPadSel = Builder.CreateExtractValue(LPadInst, 1); Builder.CreateStore(LPadSel, getEHSelectorSlot()); // Save the exception pointer. It's safe to use a single exception // pointer per function because EH cleanups can never have nested // try/catches. // Build the landingpad instruction. // Accumulate all the handlers in scope. bool hasCatchAll = false; bool hasCleanup = false; bool hasFilter = false; SmallVector filterTypes; llvm::SmallPtrSet catchTypes; for (EHScopeStack::iterator I = EHStack.begin(), E = EHStack.end(); I != E; ++I) { switch (I->getKind()) { case EHScope::Cleanup: // If we have a cleanup, remember that. hasCleanup = (hasCleanup || cast(*I).isEHCleanup()); continue; case EHScope::Filter: { assert(I.next() == EHStack.end() && "EH filter is not end of EH stack"); assert(!hasCatchAll && "EH filter reached after catch-all"); // Filter scopes get added to the landingpad in weird ways. EHFilterScope &filter = cast(*I); hasFilter = true; // Add all the filter values. for (unsigned i = 0, e = filter.getNumFilters(); i != e; ++i) filterTypes.push_back(filter.getFilter(i)); goto done; } case EHScope::Terminate: // Terminate scopes are basically catch-alls. assert(!hasCatchAll); hasCatchAll = true; goto done; case EHScope::Catch: break; } EHCatchScope &catchScope = cast(*I); for (unsigned hi = 0, he = catchScope.getNumHandlers(); hi != he; ++hi) { EHCatchScope::Handler handler = catchScope.getHandler(hi); // If this is a catch-all, register that and abort. if (!handler.Type) { assert(!hasCatchAll); hasCatchAll = true; goto done; } // Check whether we already have a handler for this type. if (catchTypes.insert(handler.Type)) // If not, add it directly to the landingpad. LPadInst->addClause(handler.Type); } } done: // If we have a catch-all, add null to the landingpad. assert(!(hasCatchAll && hasFilter)); if (hasCatchAll) { LPadInst->addClause(getCatchAllValue(*this)); // If we have an EH filter, we need to add those handlers in the // right place in the landingpad, which is to say, at the end. } else if (hasFilter) { // Create a filter expression: a constant array indicating which filter // types there are. The personality routine only lands here if the filter // doesn't match. SmallVector Filters; llvm::ArrayType *AType = llvm::ArrayType::get(!filterTypes.empty() ? filterTypes[0]->getType() : Int8PtrTy, filterTypes.size()); for (unsigned i = 0, e = filterTypes.size(); i != e; ++i) Filters.push_back(cast(filterTypes[i])); llvm::Constant *FilterArray = llvm::ConstantArray::get(AType, Filters); LPadInst->addClause(FilterArray); // Also check whether we need a cleanup. if (hasCleanup) LPadInst->setCleanup(true); // Otherwise, signal that we at least have cleanups. } else if (CleanupHackLevel == CHL_MandatoryCatchall || hasCleanup) { if (CleanupHackLevel == CHL_MandatoryCatchall) LPadInst->addClause(getCatchAllValue(*this)); else LPadInst->setCleanup(true); } assert((LPadInst->getNumClauses() > 0 || LPadInst->isCleanup()) && "landingpad instruction has no clauses!"); // Tell the backend how to generate the landing pad. Builder.CreateBr(getEHDispatchBlock(EHStack.getInnermostEHScope())); // Restore the old IR generation state. Builder.restoreIP(savedIP); if (CGDebugInfo *DI = getDebugInfo()) DI->EmitLocation(Builder, SavedLocation); return lpad; } namespace { /// A cleanup to call __cxa_end_catch. In many cases, the caught /// exception type lets us state definitively that the thrown exception /// type does not have a destructor. In particular: /// - Catch-alls tell us nothing, so we have to conservatively /// assume that the thrown exception might have a destructor. /// - Catches by reference behave according to their base types. /// - Catches of non-record types will only trigger for exceptions /// of non-record types, which never have destructors. /// - Catches of record types can trigger for arbitrary subclasses /// of the caught type, so we have to assume the actual thrown /// exception type might have a throwing destructor, even if the /// caught type's destructor is trivial or nothrow. struct CallEndCatch : EHScopeStack::Cleanup { CallEndCatch(bool MightThrow) : MightThrow(MightThrow) {} bool MightThrow; void Emit(CodeGenFunction &CGF, Flags flags) { if (!MightThrow) { CGF.EmitNounwindRuntimeCall(getEndCatchFn(CGF.CGM)); return; } CGF.EmitRuntimeCallOrInvoke(getEndCatchFn(CGF.CGM)); } }; } /// Emits a call to __cxa_begin_catch and enters a cleanup to call /// __cxa_end_catch. /// /// \param EndMightThrow - true if __cxa_end_catch might throw static llvm::Value *CallBeginCatch(CodeGenFunction &CGF, llvm::Value *Exn, bool EndMightThrow) { llvm::CallInst *call = CGF.EmitNounwindRuntimeCall(getBeginCatchFn(CGF.CGM), Exn); CGF.EHStack.pushCleanup(NormalAndEHCleanup, EndMightThrow); return call; } /// A "special initializer" callback for initializing a catch /// parameter during catch initialization. static void InitCatchParam(CodeGenFunction &CGF, const VarDecl &CatchParam, llvm::Value *ParamAddr, SourceLocation Loc) { // Load the exception from where the landing pad saved it. llvm::Value *Exn = CGF.getExceptionFromSlot(); CanQualType CatchType = CGF.CGM.getContext().getCanonicalType(CatchParam.getType()); llvm::Type *LLVMCatchTy = CGF.ConvertTypeForMem(CatchType); // If we're catching by reference, we can just cast the object // pointer to the appropriate pointer. if (isa(CatchType)) { QualType CaughtType = cast(CatchType)->getPointeeType(); bool EndCatchMightThrow = CaughtType->isRecordType(); // __cxa_begin_catch returns the adjusted object pointer. llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, EndCatchMightThrow); // We have no way to tell the personality function that we're // catching by reference, so if we're catching a pointer, // __cxa_begin_catch will actually return that pointer by value. if (const PointerType *PT = dyn_cast(CaughtType)) { QualType PointeeType = PT->getPointeeType(); // When catching by reference, generally we should just ignore // this by-value pointer and use the exception object instead. if (!PointeeType->isRecordType()) { // Exn points to the struct _Unwind_Exception header, which // we have to skip past in order to reach the exception data. unsigned HeaderSize = CGF.CGM.getTargetCodeGenInfo().getSizeOfUnwindException(); AdjustedExn = CGF.Builder.CreateConstGEP1_32(Exn, HeaderSize); // However, if we're catching a pointer-to-record type that won't // work, because the personality function might have adjusted // the pointer. There's actually no way for us to fully satisfy // the language/ABI contract here: we can't use Exn because it // might have the wrong adjustment, but we can't use the by-value // pointer because it's off by a level of abstraction. // // The current solution is to dump the adjusted pointer into an // alloca, which breaks language semantics (because changing the // pointer doesn't change the exception) but at least works. // The better solution would be to filter out non-exact matches // and rethrow them, but this is tricky because the rethrow // really needs to be catchable by other sites at this landing // pad. The best solution is to fix the personality function. } else { // Pull the pointer for the reference type off. llvm::Type *PtrTy = cast(LLVMCatchTy)->getElementType(); // Create the temporary and write the adjusted pointer into it. llvm::Value *ExnPtrTmp = CGF.CreateTempAlloca(PtrTy, "exn.byref.tmp"); llvm::Value *Casted = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy); CGF.Builder.CreateStore(Casted, ExnPtrTmp); // Bind the reference to the temporary. AdjustedExn = ExnPtrTmp; } } llvm::Value *ExnCast = CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.byref"); CGF.Builder.CreateStore(ExnCast, ParamAddr); return; } // Scalars and complexes. TypeEvaluationKind TEK = CGF.getEvaluationKind(CatchType); if (TEK != TEK_Aggregate) { llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, false); // If the catch type is a pointer type, __cxa_begin_catch returns // the pointer by value. if (CatchType->hasPointerRepresentation()) { llvm::Value *CastExn = CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.casted"); switch (CatchType.getQualifiers().getObjCLifetime()) { case Qualifiers::OCL_Strong: CastExn = CGF.EmitARCRetainNonBlock(CastExn); // fallthrough case Qualifiers::OCL_None: case Qualifiers::OCL_ExplicitNone: case Qualifiers::OCL_Autoreleasing: CGF.Builder.CreateStore(CastExn, ParamAddr); return; case Qualifiers::OCL_Weak: CGF.EmitARCInitWeak(ParamAddr, CastExn); return; } llvm_unreachable("bad ownership qualifier!"); } // Otherwise, it returns a pointer into the exception object. llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok llvm::Value *Cast = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy); LValue srcLV = CGF.MakeNaturalAlignAddrLValue(Cast, CatchType); LValue destLV = CGF.MakeAddrLValue(ParamAddr, CatchType, CGF.getContext().getDeclAlign(&CatchParam)); switch (TEK) { case TEK_Complex: CGF.EmitStoreOfComplex(CGF.EmitLoadOfComplex(srcLV, Loc), destLV, /*init*/ true); return; case TEK_Scalar: { llvm::Value *ExnLoad = CGF.EmitLoadOfScalar(srcLV, Loc); CGF.EmitStoreOfScalar(ExnLoad, destLV, /*init*/ true); return; } case TEK_Aggregate: llvm_unreachable("evaluation kind filtered out!"); } llvm_unreachable("bad evaluation kind"); } assert(isa(CatchType) && "unexpected catch type!"); llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok // Check for a copy expression. If we don't have a copy expression, // that means a trivial copy is okay. const Expr *copyExpr = CatchParam.getInit(); if (!copyExpr) { llvm::Value *rawAdjustedExn = CallBeginCatch(CGF, Exn, true); llvm::Value *adjustedExn = CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy); CGF.EmitAggregateCopy(ParamAddr, adjustedExn, CatchType); return; } // We have to call __cxa_get_exception_ptr to get the adjusted // pointer before copying. llvm::CallInst *rawAdjustedExn = CGF.EmitNounwindRuntimeCall(getGetExceptionPtrFn(CGF.CGM), Exn); // Cast that to the appropriate type. llvm::Value *adjustedExn = CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy); // The copy expression is defined in terms of an OpaqueValueExpr. // Find it and map it to the adjusted expression. CodeGenFunction::OpaqueValueMapping opaque(CGF, OpaqueValueExpr::findInCopyConstruct(copyExpr), CGF.MakeAddrLValue(adjustedExn, CatchParam.getType())); // Call the copy ctor in a terminate scope. CGF.EHStack.pushTerminate(); // Perform the copy construction. CharUnits Alignment = CGF.getContext().getDeclAlign(&CatchParam); CGF.EmitAggExpr(copyExpr, AggValueSlot::forAddr(ParamAddr, Alignment, Qualifiers(), AggValueSlot::IsNotDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased)); // Leave the terminate scope. CGF.EHStack.popTerminate(); // Undo the opaque value mapping. opaque.pop(); // Finally we can call __cxa_begin_catch. CallBeginCatch(CGF, Exn, true); } /// Begins a catch statement by initializing the catch variable and /// calling __cxa_begin_catch. static void BeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *S) { // We have to be very careful with the ordering of cleanups here: // C++ [except.throw]p4: // The destruction [of the exception temporary] occurs // immediately after the destruction of the object declared in // the exception-declaration in the handler. // // So the precise ordering is: // 1. Construct catch variable. // 2. __cxa_begin_catch // 3. Enter __cxa_end_catch cleanup // 4. Enter dtor cleanup // // We do this by using a slightly abnormal initialization process. // Delegation sequence: // - ExitCXXTryStmt opens a RunCleanupsScope // - EmitAutoVarAlloca creates the variable and debug info // - InitCatchParam initializes the variable from the exception // - CallBeginCatch calls __cxa_begin_catch // - CallBeginCatch enters the __cxa_end_catch cleanup // - EmitAutoVarCleanups enters the variable destructor cleanup // - EmitCXXTryStmt emits the code for the catch body // - EmitCXXTryStmt close the RunCleanupsScope VarDecl *CatchParam = S->getExceptionDecl(); if (!CatchParam) { llvm::Value *Exn = CGF.getExceptionFromSlot(); CallBeginCatch(CGF, Exn, true); return; } // Emit the local. CodeGenFunction::AutoVarEmission var = CGF.EmitAutoVarAlloca(*CatchParam); InitCatchParam(CGF, *CatchParam, var.getObjectAddress(CGF), S->getLocStart()); CGF.EmitAutoVarCleanups(var); } /// Emit the structure of the dispatch block for the given catch scope. /// It is an invariant that the dispatch block already exists. static void emitCatchDispatchBlock(CodeGenFunction &CGF, EHCatchScope &catchScope) { llvm::BasicBlock *dispatchBlock = catchScope.getCachedEHDispatchBlock(); assert(dispatchBlock); // If there's only a single catch-all, getEHDispatchBlock returned // that catch-all as the dispatch block. if (catchScope.getNumHandlers() == 1 && catchScope.getHandler(0).isCatchAll()) { assert(dispatchBlock == catchScope.getHandler(0).Block); return; } CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveIP(); CGF.EmitBlockAfterUses(dispatchBlock); // Select the right handler. llvm::Value *llvm_eh_typeid_for = CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for); // Load the selector value. llvm::Value *selector = CGF.getSelectorFromSlot(); // Test against each of the exception types we claim to catch. for (unsigned i = 0, e = catchScope.getNumHandlers(); ; ++i) { assert(i < e && "ran off end of handlers!"); const EHCatchScope::Handler &handler = catchScope.getHandler(i); llvm::Value *typeValue = handler.Type; assert(typeValue && "fell into catch-all case!"); typeValue = CGF.Builder.CreateBitCast(typeValue, CGF.Int8PtrTy); // Figure out the next block. bool nextIsEnd; llvm::BasicBlock *nextBlock; // If this is the last handler, we're at the end, and the next // block is the block for the enclosing EH scope. if (i + 1 == e) { nextBlock = CGF.getEHDispatchBlock(catchScope.getEnclosingEHScope()); nextIsEnd = true; // If the next handler is a catch-all, we're at the end, and the // next block is that handler. } else if (catchScope.getHandler(i+1).isCatchAll()) { nextBlock = catchScope.getHandler(i+1).Block; nextIsEnd = true; // Otherwise, we're not at the end and we need a new block. } else { nextBlock = CGF.createBasicBlock("catch.fallthrough"); nextIsEnd = false; } // Figure out the catch type's index in the LSDA's type table. llvm::CallInst *typeIndex = CGF.Builder.CreateCall(llvm_eh_typeid_for, typeValue); typeIndex->setDoesNotThrow(); llvm::Value *matchesTypeIndex = CGF.Builder.CreateICmpEQ(selector, typeIndex, "matches"); CGF.Builder.CreateCondBr(matchesTypeIndex, handler.Block, nextBlock); // If the next handler is a catch-all, we're completely done. if (nextIsEnd) { CGF.Builder.restoreIP(savedIP); return; } // Otherwise we need to emit and continue at that block. CGF.EmitBlock(nextBlock); } } void CodeGenFunction::popCatchScope() { EHCatchScope &catchScope = cast(*EHStack.begin()); if (catchScope.hasEHBranches()) emitCatchDispatchBlock(*this, catchScope); EHStack.popCatch(); } void CodeGenFunction::ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) { unsigned NumHandlers = S.getNumHandlers(); EHCatchScope &CatchScope = cast(*EHStack.begin()); assert(CatchScope.getNumHandlers() == NumHandlers); // If the catch was not required, bail out now. if (!CatchScope.hasEHBranches()) { EHStack.popCatch(); return; } // Emit the structure of the EH dispatch for this catch. emitCatchDispatchBlock(*this, CatchScope); // Copy the handler blocks off before we pop the EH stack. Emitting // the handlers might scribble on this memory. SmallVector Handlers(NumHandlers); memcpy(Handlers.data(), CatchScope.begin(), NumHandlers * sizeof(EHCatchScope::Handler)); EHStack.popCatch(); // The fall-through block. llvm::BasicBlock *ContBB = createBasicBlock("try.cont"); // We just emitted the body of the try; jump to the continue block. if (HaveInsertPoint()) Builder.CreateBr(ContBB); // Determine if we need an implicit rethrow for all these catch handlers; // see the comment below. bool doImplicitRethrow = false; if (IsFnTryBlock) doImplicitRethrow = isa(CurCodeDecl) || isa(CurCodeDecl); // Perversely, we emit the handlers backwards precisely because we // want them to appear in source order. In all of these cases, the // catch block will have exactly one predecessor, which will be a // particular block in the catch dispatch. However, in the case of // a catch-all, one of the dispatch blocks will branch to two // different handlers, and EmitBlockAfterUses will cause the second // handler to be moved before the first. for (unsigned I = NumHandlers; I != 0; --I) { llvm::BasicBlock *CatchBlock = Handlers[I-1].Block; EmitBlockAfterUses(CatchBlock); // Catch the exception if this isn't a catch-all. const CXXCatchStmt *C = S.getHandler(I-1); // Enter a cleanup scope, including the catch variable and the // end-catch. RunCleanupsScope CatchScope(*this); // Initialize the catch variable and set up the cleanups. BeginCatch(*this, C); // Perform the body of the catch. EmitStmt(C->getHandlerBlock()); // [except.handle]p11: // The currently handled exception is rethrown if control // reaches the end of a handler of the function-try-block of a // constructor or destructor. // It is important that we only do this on fallthrough and not on // return. Note that it's illegal to put a return in a // constructor function-try-block's catch handler (p14), so this // really only applies to destructors. if (doImplicitRethrow && HaveInsertPoint()) { EmitRuntimeCallOrInvoke(getReThrowFn(CGM)); Builder.CreateUnreachable(); Builder.ClearInsertionPoint(); } // Fall out through the catch cleanups. CatchScope.ForceCleanup(); // Branch out of the try. if (HaveInsertPoint()) Builder.CreateBr(ContBB); } EmitBlock(ContBB); } namespace { struct CallEndCatchForFinally : EHScopeStack::Cleanup { llvm::Value *ForEHVar; llvm::Value *EndCatchFn; CallEndCatchForFinally(llvm::Value *ForEHVar, llvm::Value *EndCatchFn) : ForEHVar(ForEHVar), EndCatchFn(EndCatchFn) {} void Emit(CodeGenFunction &CGF, Flags flags) { llvm::BasicBlock *EndCatchBB = CGF.createBasicBlock("finally.endcatch"); llvm::BasicBlock *CleanupContBB = CGF.createBasicBlock("finally.cleanup.cont"); llvm::Value *ShouldEndCatch = CGF.Builder.CreateLoad(ForEHVar, "finally.endcatch"); CGF.Builder.CreateCondBr(ShouldEndCatch, EndCatchBB, CleanupContBB); CGF.EmitBlock(EndCatchBB); CGF.EmitRuntimeCallOrInvoke(EndCatchFn); // catch-all, so might throw CGF.EmitBlock(CleanupContBB); } }; struct PerformFinally : EHScopeStack::Cleanup { const Stmt *Body; llvm::Value *ForEHVar; llvm::Value *EndCatchFn; llvm::Value *RethrowFn; llvm::Value *SavedExnVar; PerformFinally(const Stmt *Body, llvm::Value *ForEHVar, llvm::Value *EndCatchFn, llvm::Value *RethrowFn, llvm::Value *SavedExnVar) : Body(Body), ForEHVar(ForEHVar), EndCatchFn(EndCatchFn), RethrowFn(RethrowFn), SavedExnVar(SavedExnVar) {} void Emit(CodeGenFunction &CGF, Flags flags) { // Enter a cleanup to call the end-catch function if one was provided. if (EndCatchFn) CGF.EHStack.pushCleanup(NormalAndEHCleanup, ForEHVar, EndCatchFn); // Save the current cleanup destination in case there are // cleanups in the finally block. llvm::Value *SavedCleanupDest = CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot(), "cleanup.dest.saved"); // Emit the finally block. CGF.EmitStmt(Body); // If the end of the finally is reachable, check whether this was // for EH. If so, rethrow. if (CGF.HaveInsertPoint()) { llvm::BasicBlock *RethrowBB = CGF.createBasicBlock("finally.rethrow"); llvm::BasicBlock *ContBB = CGF.createBasicBlock("finally.cont"); llvm::Value *ShouldRethrow = CGF.Builder.CreateLoad(ForEHVar, "finally.shouldthrow"); CGF.Builder.CreateCondBr(ShouldRethrow, RethrowBB, ContBB); CGF.EmitBlock(RethrowBB); if (SavedExnVar) { CGF.EmitRuntimeCallOrInvoke(RethrowFn, CGF.Builder.CreateLoad(SavedExnVar)); } else { CGF.EmitRuntimeCallOrInvoke(RethrowFn); } CGF.Builder.CreateUnreachable(); CGF.EmitBlock(ContBB); // Restore the cleanup destination. CGF.Builder.CreateStore(SavedCleanupDest, CGF.getNormalCleanupDestSlot()); } // Leave the end-catch cleanup. As an optimization, pretend that // the fallthrough path was inaccessible; we've dynamically proven // that we're not in the EH case along that path. if (EndCatchFn) { CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP(); CGF.PopCleanupBlock(); CGF.Builder.restoreIP(SavedIP); } // Now make sure we actually have an insertion point or the // cleanup gods will hate us. CGF.EnsureInsertPoint(); } }; } /// Enters a finally block for an implementation using zero-cost /// exceptions. This is mostly general, but hard-codes some /// language/ABI-specific behavior in the catch-all sections. void CodeGenFunction::FinallyInfo::enter(CodeGenFunction &CGF, const Stmt *body, llvm::Constant *beginCatchFn, llvm::Constant *endCatchFn, llvm::Constant *rethrowFn) { assert((beginCatchFn != 0) == (endCatchFn != 0) && "begin/end catch functions not paired"); assert(rethrowFn && "rethrow function is required"); BeginCatchFn = beginCatchFn; // The rethrow function has one of the following two types: // void (*)() // void (*)(void*) // In the latter case we need to pass it the exception object. // But we can't use the exception slot because the @@finally might // have a landing pad (which would overwrite the exception slot). llvm::FunctionType *rethrowFnTy = cast( cast(rethrowFn->getType())->getElementType()); SavedExnVar = 0; if (rethrowFnTy->getNumParams()) SavedExnVar = CGF.CreateTempAlloca(CGF.Int8PtrTy, "finally.exn"); // A finally block is a statement which must be executed on any edge // out of a given scope. Unlike a cleanup, the finally block may // contain arbitrary control flow leading out of itself. In // addition, finally blocks should always be executed, even if there // are no catch handlers higher on the stack. Therefore, we // surround the protected scope with a combination of a normal // cleanup (to catch attempts to break out of the block via normal // control flow) and an EH catch-all (semantically "outside" any try // statement to which the finally block might have been attached). // The finally block itself is generated in the context of a cleanup // which conditionally leaves the catch-all. // Jump destination for performing the finally block on an exception // edge. We'll never actually reach this block, so unreachable is // fine. RethrowDest = CGF.getJumpDestInCurrentScope(CGF.getUnreachableBlock()); // Whether the finally block is being executed for EH purposes. ForEHVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), "finally.for-eh"); CGF.Builder.CreateStore(CGF.Builder.getFalse(), ForEHVar); // Enter a normal cleanup which will perform the @@finally block. CGF.EHStack.pushCleanup(NormalCleanup, body, ForEHVar, endCatchFn, rethrowFn, SavedExnVar); // Enter a catch-all scope. llvm::BasicBlock *catchBB = CGF.createBasicBlock("finally.catchall"); EHCatchScope *catchScope = CGF.EHStack.pushCatch(1); catchScope->setCatchAllHandler(0, catchBB); } void CodeGenFunction::FinallyInfo::exit(CodeGenFunction &CGF) { // Leave the finally catch-all. EHCatchScope &catchScope = cast(*CGF.EHStack.begin()); llvm::BasicBlock *catchBB = catchScope.getHandler(0).Block; CGF.popCatchScope(); // If there are any references to the catch-all block, emit it. if (catchBB->use_empty()) { delete catchBB; } else { CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveAndClearIP(); CGF.EmitBlock(catchBB); llvm::Value *exn = 0; // If there's a begin-catch function, call it. if (BeginCatchFn) { exn = CGF.getExceptionFromSlot(); CGF.EmitNounwindRuntimeCall(BeginCatchFn, exn); } // If we need to remember the exception pointer to rethrow later, do so. if (SavedExnVar) { if (!exn) exn = CGF.getExceptionFromSlot(); CGF.Builder.CreateStore(exn, SavedExnVar); } // Tell the cleanups in the finally block that we're do this for EH. CGF.Builder.CreateStore(CGF.Builder.getTrue(), ForEHVar); // Thread a jump through the finally cleanup. CGF.EmitBranchThroughCleanup(RethrowDest); CGF.Builder.restoreIP(savedIP); } // Finally, leave the @@finally cleanup. CGF.PopCleanupBlock(); } /// In a terminate landing pad, should we use __clang__call_terminate /// or just a naked call to std::terminate? /// /// __clang_call_terminate calls __cxa_begin_catch, which then allows /// std::terminate to usefully report something about the /// violating exception. static bool useClangCallTerminate(CodeGenModule &CGM) { // Only do this for Itanium-family ABIs in C++ mode. return (CGM.getLangOpts().CPlusPlus && CGM.getTarget().getCXXABI().isItaniumFamily()); } /// Get or define the following function: /// void @@__clang_call_terminate(i8* %exn) nounwind noreturn /// This code is used only in C++. static llvm::Constant *getClangCallTerminateFn(CodeGenModule &CGM) { llvm::FunctionType *fnTy = llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); llvm::Constant *fnRef = CGM.CreateRuntimeFunction(fnTy, "__clang_call_terminate"); llvm::Function *fn = dyn_cast(fnRef); if (fn && fn->empty()) { fn->setDoesNotThrow(); fn->setDoesNotReturn(); // What we really want is to massively penalize inlining without // forbidding it completely. The difference between that and // 'noinline' is negligible. fn->addFnAttr(llvm::Attribute::NoInline); // Allow this function to be shared across translation units, but // we don't want it to turn into an exported symbol. fn->setLinkage(llvm::Function::LinkOnceODRLinkage); fn->setVisibility(llvm::Function::HiddenVisibility); // Set up the function. llvm::BasicBlock *entry = llvm::BasicBlock::Create(CGM.getLLVMContext(), "", fn); CGBuilderTy builder(entry); // Pull the exception pointer out of the parameter list. llvm::Value *exn = &*fn->arg_begin(); // Call __cxa_begin_catch(exn). llvm::CallInst *catchCall = builder.CreateCall(getBeginCatchFn(CGM), exn); catchCall->setDoesNotThrow(); catchCall->setCallingConv(CGM.getRuntimeCC()); // Call std::terminate(). llvm::CallInst *termCall = builder.CreateCall(getTerminateFn(CGM)); termCall->setDoesNotThrow(); termCall->setDoesNotReturn(); termCall->setCallingConv(CGM.getRuntimeCC()); // std::terminate cannot return. builder.CreateUnreachable(); } return fnRef; } llvm::BasicBlock *CodeGenFunction::getTerminateLandingPad() { if (TerminateLandingPad) return TerminateLandingPad; CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); // This will get inserted at the end of the function. TerminateLandingPad = createBasicBlock("terminate.lpad"); Builder.SetInsertPoint(TerminateLandingPad); // Tell the backend that this is a landing pad. const EHPersonality &Personality = EHPersonality::get(CGM.getLangOpts()); llvm::LandingPadInst *LPadInst = Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty, NULL), getOpaquePersonalityFn(CGM, Personality), 0); LPadInst->addClause(getCatchAllValue(*this)); llvm::CallInst *terminateCall; if (useClangCallTerminate(CGM)) { // Extract out the exception pointer. llvm::Value *exn = Builder.CreateExtractValue(LPadInst, 0); terminateCall = EmitNounwindRuntimeCall(getClangCallTerminateFn(CGM), exn); } else { terminateCall = EmitNounwindRuntimeCall(getTerminateFn(CGM)); } terminateCall->setDoesNotReturn(); Builder.CreateUnreachable(); // Restore the saved insertion state. Builder.restoreIP(SavedIP); return TerminateLandingPad; } llvm::BasicBlock *CodeGenFunction::getTerminateHandler() { if (TerminateHandler) return TerminateHandler; CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); // Set up the terminate handler. This block is inserted at the very // end of the function by FinishFunction. TerminateHandler = createBasicBlock("terminate.handler"); Builder.SetInsertPoint(TerminateHandler); llvm::CallInst *terminateCall; if (useClangCallTerminate(CGM)) { // Load the exception pointer. llvm::Value *exn = getExceptionFromSlot(); terminateCall = EmitNounwindRuntimeCall(getClangCallTerminateFn(CGM), exn); } else { terminateCall = EmitNounwindRuntimeCall(getTerminateFn(CGM)); } terminateCall->setDoesNotReturn(); Builder.CreateUnreachable(); // Restore the saved insertion state. Builder.restoreIP(SavedIP); return TerminateHandler; } llvm::BasicBlock *CodeGenFunction::getEHResumeBlock(bool isCleanup) { if (EHResumeBlock) return EHResumeBlock; CGBuilderTy::InsertPoint SavedIP = Builder.saveIP(); // We emit a jump to a notional label at the outermost unwind state. EHResumeBlock = createBasicBlock("eh.resume"); Builder.SetInsertPoint(EHResumeBlock); const EHPersonality &Personality = EHPersonality::get(CGM.getLangOpts()); // This can always be a call because we necessarily didn't find // anything on the EH stack which needs our help. const char *RethrowName = Personality.CatchallRethrowFn; if (RethrowName != 0 && !isCleanup) { EmitRuntimeCall(getCatchallRethrowFn(CGM, RethrowName), getExceptionFromSlot()) ->setDoesNotReturn(); } else { switch (CleanupHackLevel) { case CHL_MandatoryCatchall: // In mandatory-catchall mode, we need to use // _Unwind_Resume_or_Rethrow, or whatever the personality's // equivalent is. EmitRuntimeCall(getUnwindResumeOrRethrowFn(), getExceptionFromSlot()) ->setDoesNotReturn(); break; case CHL_MandatoryCleanup: { // In mandatory-cleanup mode, we should use 'resume'. // Recreate the landingpad's return value for the 'resume' instruction. llvm::Value *Exn = getExceptionFromSlot(); llvm::Value *Sel = getSelectorFromSlot(); llvm::Type *LPadType = llvm::StructType::get(Exn->getType(), Sel->getType(), NULL); llvm::Value *LPadVal = llvm::UndefValue::get(LPadType); LPadVal = Builder.CreateInsertValue(LPadVal, Exn, 0, "lpad.val"); LPadVal = Builder.CreateInsertValue(LPadVal, Sel, 1, "lpad.val"); Builder.CreateResume(LPadVal); Builder.restoreIP(SavedIP); return EHResumeBlock; } case CHL_Ideal: // In an idealized mode where we don't have to worry about the // optimizer combining landing pads, we should just use // _Unwind_Resume (or the personality's equivalent). EmitRuntimeCall(getUnwindResumeFn(), getExceptionFromSlot()) ->setDoesNotReturn(); break; } } Builder.CreateUnreachable(); Builder.restoreIP(SavedIP); return EHResumeBlock; } void CodeGenFunction::EmitSEHTryStmt(const SEHTryStmt &S) { CGM.ErrorUnsupported(&S, "SEH __try"); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import Clang 3.5svn r199312 @ text @a1246 1 CatchScope.clearHandlerBlocks(); a1296 4 // Emit the PGO counter increment. RegionCounter CatchCnt = getPGORegionCounter(C); CatchCnt.beginRegion(Builder); a1322 1 RegionCounter ContCnt = getPGORegionCounter(&S); a1323 1 ContCnt.beginRegion(Builder); @ 1.1.1.3 log @Import Clang 3.5svn r201163. @ text @d769 3 a771 2 SaveAndRestoreLocation AutoRestoreLocation(*this, Builder); if (CGDebugInfo *DI = getDebugInfo()) d773 1 d895 2 @ 1.1.1.3.2.1 log @Rebase. @ text @a19 1 #include "llvm/IR/CallSite.h" d21 1 d167 4 a170 1 const EHPersonality EHPersonality::GNU_C = { "__gcc_personality_v0", nullptr }; d172 1 a172 7 EHPersonality::GNU_C_SJLJ = { "__gcc_personality_sj0", nullptr }; const EHPersonality EHPersonality::NeXT_ObjC = { "__objc_personality_v0", nullptr }; const EHPersonality EHPersonality::GNU_CPlusPlus = { "__gxx_personality_v0", nullptr }; const EHPersonality EHPersonality::GNU_CPlusPlus_SJLJ = { "__gxx_personality_sj0", nullptr }; d176 1 a176 1 EHPersonality::GNU_ObjCXX = { "__gnustep_objcxx_personality_v0", nullptr }; d178 1 a178 1 EHPersonality::GNUstep_ObjC = { "__gnustep_objc_personality_v0", nullptr }; d266 4 a269 1 for (llvm::User *U : Fn->users()) { d271 1 a271 1 if (llvm::ConstantExpr *CE = dyn_cast(U)) { d279 1 a279 1 llvm::LandingPadInst *LPI = dyn_cast(U); d366 1 a366 1 void Emit(CodeGenFunction &CGF, Flags flags) override { a423 5 if (CGM.getTarget().getTriple().isWindowsMSVCEnvironment()) { ErrorUnsupported(E, "throw expression"); return; } d468 1 a468 1 llvm::Constant *Dtor = nullptr; d493 1 a493 6 if (!FD) { // Check if CapturedDecl is nothrow and create terminate scope for it. if (const CapturedDecl* CD = dyn_cast_or_null(D)) { if (CD->isNothrow()) EHStack.pushTerminate(); } a494 1 } d496 1 a496 1 if (!Proto) d561 1 a561 6 if (!FD) { // Check if CapturedDecl is nothrow and pop terminate scope for it. if (const CapturedDecl* CD = dyn_cast_or_null(D)) { if (CD->isNothrow()) EHStack.popTerminate(); } a562 1 } d564 1 a564 1 if (!Proto) a579 5 if (CGM.getTarget().getTriple().isWindowsMSVCEnvironment()) { ErrorUnsupported(&S, "try statement"); return; } d603 1 a603 1 llvm::Value *TypeInfo = nullptr; d681 1 a681 1 return nullptr; d914 1 a914 1 void Emit(CodeGenFunction &CGF, Flags flags) override { d1336 1 a1336 1 void Emit(CodeGenFunction &CGF, Flags flags) override { d1363 1 a1363 1 void Emit(CodeGenFunction &CGF, Flags flags) override { d1428 1 a1428 1 assert((beginCatchFn != nullptr) == (endCatchFn != nullptr) && d1443 1 a1443 1 SavedExnVar = nullptr; d1493 1 a1493 1 llvm::Value *exn = nullptr; d1657 1 a1657 1 if (RethrowName != nullptr && !isCleanup) { @ 1.1.1.4 log @Import Clang 3.5svn r209886. @ text @a19 1 #include "llvm/IR/CallSite.h" d21 1 d167 4 a170 1 const EHPersonality EHPersonality::GNU_C = { "__gcc_personality_v0", nullptr }; d172 1 a172 7 EHPersonality::GNU_C_SJLJ = { "__gcc_personality_sj0", nullptr }; const EHPersonality EHPersonality::NeXT_ObjC = { "__objc_personality_v0", nullptr }; const EHPersonality EHPersonality::GNU_CPlusPlus = { "__gxx_personality_v0", nullptr }; const EHPersonality EHPersonality::GNU_CPlusPlus_SJLJ = { "__gxx_personality_sj0", nullptr }; d176 1 a176 1 EHPersonality::GNU_ObjCXX = { "__gnustep_objcxx_personality_v0", nullptr }; d178 1 a178 1 EHPersonality::GNUstep_ObjC = { "__gnustep_objc_personality_v0", nullptr }; d266 4 a269 1 for (llvm::User *U : Fn->users()) { d271 1 a271 1 if (llvm::ConstantExpr *CE = dyn_cast(U)) { d279 1 a279 1 llvm::LandingPadInst *LPI = dyn_cast(U); d366 1 a366 1 void Emit(CodeGenFunction &CGF, Flags flags) override { a423 5 if (CGM.getTarget().getTriple().isWindowsMSVCEnvironment()) { ErrorUnsupported(E, "throw expression"); return; } d468 1 a468 1 llvm::Constant *Dtor = nullptr; d493 1 a493 6 if (!FD) { // Check if CapturedDecl is nothrow and create terminate scope for it. if (const CapturedDecl* CD = dyn_cast_or_null(D)) { if (CD->isNothrow()) EHStack.pushTerminate(); } a494 1 } d496 1 a496 1 if (!Proto) d561 1 a561 6 if (!FD) { // Check if CapturedDecl is nothrow and pop terminate scope for it. if (const CapturedDecl* CD = dyn_cast_or_null(D)) { if (CD->isNothrow()) EHStack.popTerminate(); } a562 1 } d564 1 a564 1 if (!Proto) a579 5 if (CGM.getTarget().getTriple().isWindowsMSVCEnvironment()) { ErrorUnsupported(&S, "try statement"); return; } d603 1 a603 1 llvm::Value *TypeInfo = nullptr; d681 1 a681 1 return nullptr; d914 1 a914 1 void Emit(CodeGenFunction &CGF, Flags flags) override { d1336 1 a1336 1 void Emit(CodeGenFunction &CGF, Flags flags) override { d1363 1 a1363 1 void Emit(CodeGenFunction &CGF, Flags flags) override { d1428 1 a1428 1 assert((beginCatchFn != nullptr) == (endCatchFn != nullptr) && d1443 1 a1443 1 SavedExnVar = nullptr; d1493 1 a1493 1 llvm::Value *exn = nullptr; d1657 1 a1657 1 if (RethrowName != nullptr && !isCleanup) { @ 1.1.1.5 log @Import clang 3.6svn r215315. @ text @d100 18 d625 1 a625 1 llvm::Constant *TypeInfo = nullptr; d724 50 d900 5 a904 2 } else if (hasCleanup) { LPadInst->setCleanup(true); d1681 1 a1681 1 getExceptionFromSlot()) d1683 38 a1720 14 Builder.CreateUnreachable(); Builder.restoreIP(SavedIP); return EHResumeBlock; } // Recreate the landingpad's return value for the 'resume' instruction. llvm::Value *Exn = getExceptionFromSlot(); llvm::Value *Sel = getSelectorFromSlot(); llvm::Type *LPadType = llvm::StructType::get(Exn->getType(), Sel->getType(), NULL); llvm::Value *LPadVal = llvm::UndefValue::get(LPadType); LPadVal = Builder.CreateInsertValue(LPadVal, Exn, 0, "lpad.val"); LPadVal = Builder.CreateInsertValue(LPadVal, Sel, 1, "lpad.val"); a1721 1 Builder.CreateResume(LPadVal); d1723 1 a1729 4 void CodeGenFunction::EmitSEHLeaveStmt(const SEHLeaveStmt &S) { CGM.ErrorUnsupported(&S, "SEH __leave"); } @ 1.1.1.5.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @a14 1 #include "CGCXXABI.h" d55 9 d137 1 a137 1 static const EHPersonality &get(CodeGenModule &CGM); a139 1 static const EHPersonality GNU_C_SEH; a145 1 static const EHPersonality GNU_CPlusPlus_SEH; a152 2 EHPersonality::GNU_C_SEH = { "__gcc_personality_seh0", nullptr }; const EHPersonality a158 2 EHPersonality::GNU_CPlusPlus_SEH = { "__gxx_personality_seh0", nullptr }; const EHPersonality d165 1 a165 8 /// On Win64, use libgcc's SEH personality function. We fall back to dwarf on /// other platforms, unless the user asked for SjLj exceptions. static bool useLibGCCSEHPersonality(const llvm::Triple &T) { return T.isOSWindows() && T.getArch() == llvm::Triple::x86_64; } static const EHPersonality &getCPersonality(const llvm::Triple &T, const LangOptions &L) { a167 2 else if (useLibGCCSEHPersonality(T)) return EHPersonality::GNU_C_SEH; d171 1 a171 2 static const EHPersonality &getObjCPersonality(const llvm::Triple &T, const LangOptions &L) { d174 1 a174 1 return getCPersonality(T, L); d189 1 a189 2 static const EHPersonality &getCXXPersonality(const llvm::Triple &T, const LangOptions &L) { d192 2 a193 3 else if (useLibGCCSEHPersonality(T)) return EHPersonality::GNU_CPlusPlus_SEH; return EHPersonality::GNU_CPlusPlus; d198 1 a198 2 static const EHPersonality &getObjCXXPersonality(const llvm::Triple &T, const LangOptions &L) { d210 1 a210 1 return getCXXPersonality(T, L); d223 1 a223 3 const EHPersonality &EHPersonality::get(CodeGenModule &CGM) { const llvm::Triple &T = CGM.getTarget().getTriple(); const LangOptions &L = CGM.getLangOpts(); d225 1 a225 1 return getObjCXXPersonality(T, L); d227 1 a227 1 return getCXXPersonality(T, L); d229 1 a229 1 return getObjCPersonality(T, L); d231 1 a231 1 return getCPersonality(T, L); d308 2 a309 3 const EHPersonality &ObjCXX = EHPersonality::get(*this); const EHPersonality &CXX = getCXXPersonality(getTarget().getTriple(), LangOpts); d406 5 d412 2 a413 1 CGM.getCXXABI().emitRethrow(*this, /*isNoReturn*/true); a422 5 if (CGM.getTarget().getTriple().isKnownWindowsMSVCEnvironment()) { ErrorUnsupported(E, "throw expression"); return; } d460 1 a460 1 Dtor = CGM.getAddrOfCXXStructor(DtorD, StructorType::Complete); d579 1 a579 1 if (CGM.getTarget().getTriple().isKnownWindowsMSVCEnvironment()) { d604 2 a605 3 Qualifiers CaughtTypeQuals; QualType CaughtType = CGM.getContext().getUnqualifiedArrayType( C->getCaughtType().getNonReferenceType(), CaughtTypeQuals); d723 3 a725 1 ApplyDebugLocation AutoRestoreLocation(*this, CurEHLocation); d727 1 a727 1 const EHPersonality &personality = EHPersonality::get(CGM); d734 1 a734 1 Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty, nullptr), d798 1 a798 1 if (catchTypes.insert(handler.Type).second) d1262 1 a1262 1 CGM.getCXXABI().emitRethrow(*this, /*isNoReturn*/false); d1544 1 a1544 1 const EHPersonality &Personality = EHPersonality::get(CGM); d1546 1 a1546 1 Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty, nullptr), d1603 1 a1603 1 const EHPersonality &Personality = EHPersonality::get(CGM); d1622 1 a1622 1 Sel->getType(), nullptr); @ 1.1.1.6 log @Import Clang 3.6RC1 r227398. @ text @a14 1 #include "CGCXXABI.h" d55 9 d137 1 a137 1 static const EHPersonality &get(CodeGenModule &CGM); a139 1 static const EHPersonality GNU_C_SEH; a145 1 static const EHPersonality GNU_CPlusPlus_SEH; a152 2 EHPersonality::GNU_C_SEH = { "__gcc_personality_seh0", nullptr }; const EHPersonality a158 2 EHPersonality::GNU_CPlusPlus_SEH = { "__gxx_personality_seh0", nullptr }; const EHPersonality d165 1 a165 8 /// On Win64, use libgcc's SEH personality function. We fall back to dwarf on /// other platforms, unless the user asked for SjLj exceptions. static bool useLibGCCSEHPersonality(const llvm::Triple &T) { return T.isOSWindows() && T.getArch() == llvm::Triple::x86_64; } static const EHPersonality &getCPersonality(const llvm::Triple &T, const LangOptions &L) { a167 2 else if (useLibGCCSEHPersonality(T)) return EHPersonality::GNU_C_SEH; d171 1 a171 2 static const EHPersonality &getObjCPersonality(const llvm::Triple &T, const LangOptions &L) { d174 1 a174 1 return getCPersonality(T, L); d189 1 a189 2 static const EHPersonality &getCXXPersonality(const llvm::Triple &T, const LangOptions &L) { d192 2 a193 3 else if (useLibGCCSEHPersonality(T)) return EHPersonality::GNU_CPlusPlus_SEH; return EHPersonality::GNU_CPlusPlus; d198 1 a198 2 static const EHPersonality &getObjCXXPersonality(const llvm::Triple &T, const LangOptions &L) { d210 1 a210 1 return getCXXPersonality(T, L); d223 1 a223 3 const EHPersonality &EHPersonality::get(CodeGenModule &CGM) { const llvm::Triple &T = CGM.getTarget().getTriple(); const LangOptions &L = CGM.getLangOpts(); d225 1 a225 1 return getObjCXXPersonality(T, L); d227 1 a227 1 return getCXXPersonality(T, L); d229 1 a229 1 return getObjCPersonality(T, L); d231 1 a231 1 return getCPersonality(T, L); d308 2 a309 3 const EHPersonality &ObjCXX = EHPersonality::get(*this); const EHPersonality &CXX = getCXXPersonality(getTarget().getTriple(), LangOpts); d406 5 d412 2 a413 1 CGM.getCXXABI().emitRethrow(*this, /*isNoReturn*/true); a422 5 if (CGM.getTarget().getTriple().isKnownWindowsMSVCEnvironment()) { ErrorUnsupported(E, "throw expression"); return; } d460 1 a460 1 Dtor = CGM.getAddrOfCXXStructor(DtorD, StructorType::Complete); d579 1 a579 1 if (CGM.getTarget().getTriple().isKnownWindowsMSVCEnvironment()) { d604 2 a605 3 Qualifiers CaughtTypeQuals; QualType CaughtType = CGM.getContext().getUnqualifiedArrayType( C->getCaughtType().getNonReferenceType(), CaughtTypeQuals); d723 3 a725 1 ApplyDebugLocation AutoRestoreLocation(*this, CurEHLocation); d727 1 a727 1 const EHPersonality &personality = EHPersonality::get(CGM); d734 1 a734 1 Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty, nullptr), d798 1 a798 1 if (catchTypes.insert(handler.Type).second) d1262 1 a1262 1 CGM.getCXXABI().emitRethrow(*this, /*isNoReturn*/false); d1544 1 a1544 1 const EHPersonality &Personality = EHPersonality::get(CGM); d1546 1 a1546 1 Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty, nullptr), d1603 1 a1603 1 const EHPersonality &Personality = EHPersonality::get(CGM); d1622 1 a1622 1 Sel->getType(), nullptr); @ 1.1.1.7 log @Import Clang 3.8.0rc3 r261930. @ text @d1 1 a1 1 //===--- CGException.cpp - Emit LLVM Code for C++ exceptions ----*- C++ -*-===// a18 1 #include "clang/AST/Mangle.h" a20 2 #include "clang/AST/StmtVisitor.h" #include "clang/Basic/TargetBuiltins.h" a22 2 #include "llvm/IR/IntrinsicInst.h" #include "llvm/Support/SaveAndRestore.h" d27 9 d45 38 d92 1 a92 1 llvm::Constant *CodeGenModule::getTerminateFn() { d96 1 a96 1 llvm::FunctionType::get(VoidTy, /*IsVarArgs=*/false); d101 4 a104 11 if (getLangOpts().CPlusPlus && getTarget().getCXXABI().isItaniumFamily()) { name = "_ZSt9terminatev"; } else if (getLangOpts().CPlusPlus && getTarget().getCXXABI().isMicrosoft()) { if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015)) name = "__std_terminate"; else name = "\01?terminate@@@@YAXXZ"; } else if (getLangOpts().ObjC1 && getLangOpts().ObjCRuntime.hasTerminate()) d108 1 a108 1 return CreateRuntimeFunction(FTy, name); d119 24 a161 6 const EHPersonality EHPersonality::MSVC_except_handler = { "_except_handler3", nullptr }; const EHPersonality EHPersonality::MSVC_C_specific_handler = { "__C_specific_handler", nullptr }; const EHPersonality EHPersonality::MSVC_CxxFrameHandler3 = { "__CxxFrameHandler3", nullptr }; a184 1 case ObjCRuntime::WatchOS: a215 1 case ObjCRuntime::WatchOS: d234 1 a234 8 static const EHPersonality &getSEHPersonalityMSVC(const llvm::Triple &T) { if (T.getArch() == llvm::Triple::x86) return EHPersonality::MSVC_except_handler; return EHPersonality::MSVC_C_specific_handler; } const EHPersonality &EHPersonality::get(CodeGenModule &CGM, const FunctionDecl *FD) { a236 15 // Functions using SEH get an SEH personality. if (FD && FD->usesSEHTry()) return getSEHPersonalityMSVC(T); // Try to pick a personality function that is compatible with MSVC if we're // not compiling Obj-C. Obj-C users better have an Obj-C runtime that supports // the GCC-style personality function. if (T.isWindowsMSVCEnvironment() && !L.ObjC1) { if (L.SjLjExceptions) return EHPersonality::GNU_CPlusPlus_SJLJ; else return EHPersonality::MSVC_CxxFrameHandler3; } a246 4 const EHPersonality &EHPersonality::get(CodeGenFunction &CGF) { return get(CGF.CGM, dyn_cast_or_null(CGF.CurCodeDecl)); } a260 30 /// Check whether a landingpad instruction only uses C++ features. static bool LandingPadHasOnlyCXXUses(llvm::LandingPadInst *LPI) { for (unsigned I = 0, E = LPI->getNumClauses(); I != E; ++I) { // Look for something that would've been returned by the ObjC // runtime's GetEHType() method. llvm::Value *Val = LPI->getClause(I)->stripPointerCasts(); if (LPI->isCatch(I)) { // Check if the catch value has the ObjC prefix. if (llvm::GlobalVariable *GV = dyn_cast(Val)) // ObjC EH selector entries are always global variables with // names starting like this. if (GV->getName().startswith("OBJC_EHTYPE")) return false; } else { // Check if any of the filter values have the ObjC prefix. llvm::Constant *CVal = cast(Val); for (llvm::User::op_iterator II = CVal->op_begin(), IE = CVal->op_end(); II != IE; ++II) { if (llvm::GlobalVariable *GV = cast((*II)->stripPointerCasts())) // ObjC EH selector entries are always global variables with // names starting like this. if (GV->getName().startswith("OBJC_EHTYPE")) return false; } } } return true; } d273 28 a300 8 // Otherwise it must be a function. llvm::Function *F = dyn_cast(U); if (!F) return false; for (auto BB = F->begin(), E = F->end(); BB != E; ++BB) { if (BB->isLandingPad()) if (!LandingPadHasOnlyCXXUses(BB->getLandingPadInst())) return false; d321 1 a321 1 const EHPersonality &ObjCXX = EHPersonality::get(*this, /*FD=*/nullptr); d359 1 a359 1 struct FreeException final : EHScopeStack::Cleanup { d366 1 a366 1 } // end anonymous namespace d372 2 a373 1 void CodeGenFunction::EmitAnyExprToExn(const Expr *e, Address addr) { d376 2 a377 2 pushFullExprCleanup(EHCleanup, addr.getPointer()); EHScopeStack::stable_iterator cleanup = EHStack.stable_begin(); d381 2 a382 2 llvm::Type *ty = ConvertTypeForMem(e->getType())->getPointerTo(); Address typedAddr = Builder.CreateBitCast(addr, ty); d391 2 a392 2 EmitAnyExprToMem(e, typedAddr, e->getType().getQualifiers(), /*IsInit*/ true); d395 1 a395 2 DeactivateCleanupBlock(cleanup, cast(typedAddr.getPointer())); d398 1 a398 1 Address CodeGenFunction::getExceptionSlot() { d401 1 a401 1 return Address(ExceptionSlot, getPointerAlign()); d404 1 a404 1 Address CodeGenFunction::getEHSelectorSlot() { d407 1 a407 1 return Address(EHSelectorSlot, CharUnits::fromQuantity(4)); d420 55 a474 8 if (const Expr *SubExpr = E->getSubExpr()) { QualType ThrowType = SubExpr->getType(); if (ThrowType->isObjCObjectPointerType()) { const Stmt *ThrowStmt = E->getSubExpr(); const ObjCAtThrowStmt S(E->getExprLoc(), const_cast(ThrowStmt)); CGM.getObjCRuntime().EmitThrowStmt(*this, S, false); } else { CGM.getCXXABI().emitThrow(*this, E); a475 2 } else { CGM.getCXXABI().emitRethrow(*this, /*isNoReturn=*/true); d477 4 a511 4 // TODO: Revisit exception specifications for the MS ABI. There is a way to // encode these in an object file but MSVC doesn't do anything with it. if (getTarget().getCXXABI().isMicrosoft()) return; d546 2 a547 3 CGF.Builder.CreateICmpSLT(selector, zero, "ehspec.fails"); CGF.Builder.CreateCondBr(failsFilter, unexpectedBB, CGF.getEHResumeBlock(false)); a584 4 // TODO: Revisit exception specifications for the MS ABI. There is a way to // encode these in an object file but MSVC doesn't do anything with it. if (getTarget().getCXXABI().isMicrosoft()) return; d592 5 d621 1 a621 1 CatchTypeInfo TypeInfo{nullptr, 0}; d623 1 a623 1 TypeInfo.RTTI = CGM.getObjCRuntime().GetEHType(CaughtType); d625 1 a625 2 TypeInfo = CGM.getCXXABI().getAddrOfCXXCatchHandlerType( CaughtType, C->getCaughtType()); d629 1 a629 1 CatchScope->setHandler(I, CGM.getCXXABI().getCatchAllTypeInfo(), Handler); a635 3 if (EHPersonality::get(*this).usesFuncletPads()) return getMSVCDispatchBlock(si); a671 3 case EHScope::PadEnd: llvm_unreachable("PadEnd unnecessary for Itanium!"); a677 43 llvm::BasicBlock * CodeGenFunction::getMSVCDispatchBlock(EHScopeStack::stable_iterator SI) { // Returning nullptr indicates that the previous dispatch block should unwind // to caller. if (SI == EHStack.stable_end()) return nullptr; // Otherwise, we should look at the actual scope. EHScope &EHS = *EHStack.find(SI); llvm::BasicBlock *DispatchBlock = EHS.getCachedEHDispatchBlock(); if (DispatchBlock) return DispatchBlock; if (EHS.getKind() == EHScope::Terminate) DispatchBlock = getTerminateHandler(); else DispatchBlock = createBasicBlock(); CGBuilderTy Builder(*this, DispatchBlock); switch (EHS.getKind()) { case EHScope::Catch: DispatchBlock->setName("catch.dispatch"); break; case EHScope::Cleanup: DispatchBlock->setName("ehcleanup"); break; case EHScope::Filter: llvm_unreachable("exception specifications not handled yet!"); case EHScope::Terminate: DispatchBlock->setName("terminate"); break; case EHScope::PadEnd: llvm_unreachable("PadEnd dispatch block missing!"); } EHS.setCachedEHDispatchBlock(DispatchBlock); return DispatchBlock; } a687 1 case EHScope::PadEnd: d698 2 a699 9 // If exceptions are disabled, there are usually no landingpads. However, when // SEH is enabled, functions using SEH still get landingpads. const LangOptions &LO = CGM.getLangOpts(); if (!LO.Exceptions) { if (!LO.Borland && !LO.MicrosoftExt) return nullptr; if (!currentFunctionUsesSEHTry()) return nullptr; } d706 2 a707 13 const EHPersonality &Personality = EHPersonality::get(*this); if (!CurFn->hasPersonalityFn()) CurFn->setPersonalityFn(getOpaquePersonalityFn(CGM, Personality)); if (Personality.usesFuncletPads()) { // We don't need separate landing pads in the funclet model. LP = getEHDispatchBlock(EHStack.getInnermostEHScope()); } else { // Build the landing pad for this scope. LP = EmitLandingPad(); } a727 3 case EHScope::PadEnd: llvm_unreachable("PadEnd unnecessary for Itanium!"); d737 3 a739 1 auto DL = ApplyDebugLocation::CreateDefaultArtificial(*this, CurEHLocation); d745 3 a747 2 llvm::LandingPadInst *LPadInst = Builder.CreateLandingPad( llvm::StructType::get(Int8PtrTy, Int32Ty, nullptr), 0); d765 2 a766 2 for (EHScopeStack::iterator I = EHStack.begin(), E = EHStack.end(); I != E; ++I) { a795 3 case EHScope::PadEnd: llvm_unreachable("PadEnd unnecessary for Itanium!"); a800 2 assert(handler.Type.Flags == 0 && "landingpads do not support catch handler flags"); d803 1 a803 1 if (!handler.Type.RTTI) { d810 1 a810 1 if (catchTypes.insert(handler.Type.RTTI).second) d812 1 a812 1 LPadInst->addClause(handler.Type.RTTI); d860 146 a1005 16 static void emitCatchPadBlock(CodeGenFunction &CGF, EHCatchScope &CatchScope) { llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock(); assert(DispatchBlock); CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveIP(); CGF.EmitBlockAfterUses(DispatchBlock); llvm::Value *ParentPad = CGF.CurrentFuncletPad; if (!ParentPad) ParentPad = llvm::ConstantTokenNone::get(CGF.getLLVMContext()); llvm::BasicBlock *UnwindBB = CGF.getEHDispatchBlock(CatchScope.getEnclosingEHScope()); unsigned NumHandlers = CatchScope.getNumHandlers(); llvm::CatchSwitchInst *CatchSwitch = CGF.Builder.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers); d1007 2 a1008 3 // Test against each of the exception types we claim to catch. for (unsigned I = 0; I < NumHandlers; ++I) { const EHCatchScope::Handler &Handler = CatchScope.getHandler(I); d1010 15 a1024 12 CatchTypeInfo TypeInfo = Handler.Type; if (!TypeInfo.RTTI) TypeInfo.RTTI = llvm::Constant::getNullValue(CGF.VoidPtrTy); CGF.Builder.SetInsertPoint(Handler.Block); if (EHPersonality::get(CGF).isMSVCXXPersonality()) { CGF.Builder.CreateCatchPad( CatchSwitch, {TypeInfo.RTTI, CGF.Builder.getInt32(TypeInfo.Flags), llvm::Constant::getNullValue(CGF.VoidPtrTy)}); } else { CGF.Builder.CreateCatchPad(CatchSwitch, {TypeInfo.RTTI}); d1026 6 d1033 76 a1108 1 CatchSwitch->addHandler(Handler.Block); d1110 5 a1114 1 CGF.Builder.restoreIP(SavedIP); a1120 3 if (EHPersonality::get(CGF).usesFuncletPads()) return emitCatchPadBlock(CGF, catchScope); d1147 1 a1147 3 llvm::Value *typeValue = handler.Type.RTTI; assert(handler.Type.Flags == 0 && "landingpads do not support catch handler flags"); d1216 3 a1218 2 SmallVector Handlers( CatchScope.begin(), CatchScope.begin() + NumHandlers); d1255 1 a1255 3 SaveAndRestore RestoreCurrentFuncletPad( CurrentFuncletPad); CGM.getCXXABI().emitBeginCatch(*this, C); d1258 2 a1259 1 incrementProfileCounter(C); d1287 1 d1289 1 a1289 1 incrementProfileCounter(&S); d1293 1 a1293 1 struct CallEndCatchForFinally final : EHScopeStack::Cleanup { d1305 1 a1305 1 CGF.Builder.CreateFlagLoad(ForEHVar, "finally.endcatch"); d1313 1 a1313 1 struct PerformFinally final : EHScopeStack::Cleanup { d1348 1 a1348 1 CGF.Builder.CreateFlagLoad(ForEHVar, "finally.shouldthrow"); d1354 1 a1354 1 CGF.Builder.CreateAlignedLoad(SavedExnVar, CGF.getPointerAlign())); d1381 1 a1381 1 } // end anonymous namespace d1429 1 a1429 1 CGF.Builder.CreateFlagStore(false, ForEHVar); d1467 1 a1467 1 CGF.Builder.CreateAlignedStore(exn, SavedExnVar, CGF.getPointerAlign()); d1471 1 a1471 1 CGF.Builder.CreateFlagStore(true, ForEHVar); d1483 62 d1556 4 a1559 7 const EHPersonality &Personality = EHPersonality::get(*this); if (!CurFn->hasPersonalityFn()) CurFn->setPersonalityFn(getOpaquePersonalityFn(CGM, Personality)); llvm::LandingPadInst *LPadInst = Builder.CreateLandingPad( llvm::StructType::get(Int8PtrTy, Int32Ty, nullptr), 0); d1562 8 a1569 5 llvm::Value *Exn = nullptr; if (getLangOpts().CPlusPlus) Exn = Builder.CreateExtractValue(LPadInst, 0); llvm::CallInst *terminateCall = CGM.getCXXABI().emitTerminateForUnexpectedException(*this, Exn); d1589 5 a1593 6 llvm::Value *Exn = nullptr; if (EHPersonality::get(*this).usesFuncletPads()) { llvm::Value *ParentPad = CurrentFuncletPad; if (!ParentPad) ParentPad = llvm::ConstantTokenNone::get(CGM.getLLVMContext()); Builder.CreateCleanupPad(ParentPad); d1595 1 a1595 2 if (getLangOpts().CPlusPlus) Exn = getExceptionFromSlot(); a1596 2 llvm::CallInst *terminateCall = CGM.getCXXABI().emitTerminateForUnexpectedException(*this, Exn); d1615 1 a1615 1 const EHPersonality &Personality = EHPersonality::get(*this); d1622 2 a1623 1 getExceptionFromSlot())->setDoesNotReturn(); d1645 1 a1645 501 EnterSEHTryStmt(S); { JumpDest TryExit = getJumpDestInCurrentScope("__try.__leave"); SEHTryEpilogueStack.push_back(&TryExit); EmitStmt(S.getTryBlock()); SEHTryEpilogueStack.pop_back(); if (!TryExit.getBlock()->use_empty()) EmitBlock(TryExit.getBlock(), /*IsFinished=*/true); else delete TryExit.getBlock(); } ExitSEHTryStmt(S); } namespace { struct PerformSEHFinally final : EHScopeStack::Cleanup { llvm::Function *OutlinedFinally; PerformSEHFinally(llvm::Function *OutlinedFinally) : OutlinedFinally(OutlinedFinally) {} void Emit(CodeGenFunction &CGF, Flags F) override { ASTContext &Context = CGF.getContext(); CodeGenModule &CGM = CGF.CGM; CallArgList Args; // Compute the two argument values. QualType ArgTys[2] = {Context.UnsignedCharTy, Context.VoidPtrTy}; llvm::Value *LocalAddrFn = CGM.getIntrinsic(llvm::Intrinsic::localaddress); llvm::Value *FP = CGF.Builder.CreateCall(LocalAddrFn); llvm::Value *IsForEH = llvm::ConstantInt::get(CGF.ConvertType(ArgTys[0]), F.isForEHCleanup()); Args.add(RValue::get(IsForEH), ArgTys[0]); Args.add(RValue::get(FP), ArgTys[1]); // Arrange a two-arg function info and type. FunctionProtoType::ExtProtoInfo EPI; const auto *FPT = cast( Context.getFunctionType(Context.VoidTy, ArgTys, EPI)); const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeFreeFunctionCall(Args, FPT, /*chainCall=*/false); CGF.EmitCall(FnInfo, OutlinedFinally, ReturnValueSlot(), Args); } }; } // end anonymous namespace namespace { /// Find all local variable captures in the statement. struct CaptureFinder : ConstStmtVisitor { CodeGenFunction &ParentCGF; const VarDecl *ParentThis; llvm::SmallSetVector Captures; Address SEHCodeSlot = Address::invalid(); CaptureFinder(CodeGenFunction &ParentCGF, const VarDecl *ParentThis) : ParentCGF(ParentCGF), ParentThis(ParentThis) {} // Return true if we need to do any capturing work. bool foundCaptures() { return !Captures.empty() || SEHCodeSlot.isValid(); } void Visit(const Stmt *S) { // See if this is a capture, then recurse. ConstStmtVisitor::Visit(S); for (const Stmt *Child : S->children()) if (Child) Visit(Child); } void VisitDeclRefExpr(const DeclRefExpr *E) { // If this is already a capture, just make sure we capture 'this'. if (E->refersToEnclosingVariableOrCapture()) { Captures.insert(ParentThis); return; } const auto *D = dyn_cast(E->getDecl()); if (D && D->isLocalVarDeclOrParm() && D->hasLocalStorage()) Captures.insert(D); } void VisitCXXThisExpr(const CXXThisExpr *E) { Captures.insert(ParentThis); } void VisitCallExpr(const CallExpr *E) { // We only need to add parent frame allocations for these builtins in x86. if (ParentCGF.getTarget().getTriple().getArch() != llvm::Triple::x86) return; unsigned ID = E->getBuiltinCallee(); switch (ID) { case Builtin::BI__exception_code: case Builtin::BI_exception_code: // This is the simple case where we are the outermost finally. All we // have to do here is make sure we escape this and recover it in the // outlined handler. if (!SEHCodeSlot.isValid()) SEHCodeSlot = ParentCGF.SEHCodeSlotStack.back(); break; } } }; } // end anonymous namespace Address CodeGenFunction::recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF, Address ParentVar, llvm::Value *ParentFP) { llvm::CallInst *RecoverCall = nullptr; CGBuilderTy Builder(*this, AllocaInsertPt); if (auto *ParentAlloca = dyn_cast(ParentVar.getPointer())) { // Mark the variable escaped if nobody else referenced it and compute the // localescape index. auto InsertPair = ParentCGF.EscapedLocals.insert( std::make_pair(ParentAlloca, ParentCGF.EscapedLocals.size())); int FrameEscapeIdx = InsertPair.first->second; // call i8* @@llvm.localrecover(i8* bitcast(@@parentFn), i8* %fp, i32 N) llvm::Function *FrameRecoverFn = llvm::Intrinsic::getDeclaration( &CGM.getModule(), llvm::Intrinsic::localrecover); llvm::Constant *ParentI8Fn = llvm::ConstantExpr::getBitCast(ParentCGF.CurFn, Int8PtrTy); RecoverCall = Builder.CreateCall( FrameRecoverFn, {ParentI8Fn, ParentFP, llvm::ConstantInt::get(Int32Ty, FrameEscapeIdx)}); } else { // If the parent didn't have an alloca, we're doing some nested outlining. // Just clone the existing localrecover call, but tweak the FP argument to // use our FP value. All other arguments are constants. auto *ParentRecover = cast(ParentVar.getPointer()->stripPointerCasts()); assert(ParentRecover->getIntrinsicID() == llvm::Intrinsic::localrecover && "expected alloca or localrecover in parent LocalDeclMap"); RecoverCall = cast(ParentRecover->clone()); RecoverCall->setArgOperand(1, ParentFP); RecoverCall->insertBefore(AllocaInsertPt); } // Bitcast the variable, rename it, and insert it in the local decl map. llvm::Value *ChildVar = Builder.CreateBitCast(RecoverCall, ParentVar.getType()); ChildVar->setName(ParentVar.getName()); return Address(ChildVar, ParentVar.getAlignment()); } void CodeGenFunction::EmitCapturedLocals(CodeGenFunction &ParentCGF, const Stmt *OutlinedStmt, bool IsFilter) { // Find all captures in the Stmt. CaptureFinder Finder(ParentCGF, ParentCGF.CXXABIThisDecl); Finder.Visit(OutlinedStmt); // We can exit early on x86_64 when there are no captures. We just have to // save the exception code in filters so that __exception_code() works. if (!Finder.foundCaptures() && CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) { if (IsFilter) EmitSEHExceptionCodeSave(ParentCGF, nullptr, nullptr); return; } llvm::Value *EntryFP = nullptr; CGBuilderTy Builder(CGM, AllocaInsertPt); if (IsFilter && CGM.getTarget().getTriple().getArch() == llvm::Triple::x86) { // 32-bit SEH filters need to be careful about FP recovery. The end of the // EH registration is passed in as the EBP physical register. We can // recover that with llvm.frameaddress(1). EntryFP = Builder.CreateCall( CGM.getIntrinsic(llvm::Intrinsic::frameaddress), {Builder.getInt32(1)}); } else { // Otherwise, for x64 and 32-bit finally functions, the parent FP is the // second parameter. auto AI = CurFn->arg_begin(); ++AI; EntryFP = &*AI; } llvm::Value *ParentFP = EntryFP; if (IsFilter) { // Given whatever FP the runtime provided us in EntryFP, recover the true // frame pointer of the parent function. We only need to do this in filters, // since finally funclets recover the parent FP for us. llvm::Function *RecoverFPIntrin = CGM.getIntrinsic(llvm::Intrinsic::x86_seh_recoverfp); llvm::Constant *ParentI8Fn = llvm::ConstantExpr::getBitCast(ParentCGF.CurFn, Int8PtrTy); ParentFP = Builder.CreateCall(RecoverFPIntrin, {ParentI8Fn, EntryFP}); } // Create llvm.localrecover calls for all captures. for (const VarDecl *VD : Finder.Captures) { if (isa(VD)) { CGM.ErrorUnsupported(VD, "'this' captured by SEH"); CXXThisValue = llvm::UndefValue::get(ConvertTypeForMem(VD->getType())); continue; } if (VD->getType()->isVariablyModifiedType()) { CGM.ErrorUnsupported(VD, "VLA captured by SEH"); continue; } assert((isa(VD) || VD->isLocalVarDeclOrParm()) && "captured non-local variable"); // If this decl hasn't been declared yet, it will be declared in the // OutlinedStmt. auto I = ParentCGF.LocalDeclMap.find(VD); if (I == ParentCGF.LocalDeclMap.end()) continue; Address ParentVar = I->second; setAddrOfLocalVar( VD, recoverAddrOfEscapedLocal(ParentCGF, ParentVar, ParentFP)); } if (Finder.SEHCodeSlot.isValid()) { SEHCodeSlotStack.push_back( recoverAddrOfEscapedLocal(ParentCGF, Finder.SEHCodeSlot, ParentFP)); } if (IsFilter) EmitSEHExceptionCodeSave(ParentCGF, ParentFP, EntryFP); } /// Arrange a function prototype that can be called by Windows exception /// handling personalities. On Win64, the prototype looks like: /// RetTy func(void *EHPtrs, void *ParentFP); void CodeGenFunction::startOutlinedSEHHelper(CodeGenFunction &ParentCGF, bool IsFilter, const Stmt *OutlinedStmt) { SourceLocation StartLoc = OutlinedStmt->getLocStart(); // Get the mangled function name. SmallString<128> Name; { llvm::raw_svector_ostream OS(Name); const Decl *ParentCodeDecl = ParentCGF.CurCodeDecl; const NamedDecl *Parent = dyn_cast_or_null(ParentCodeDecl); assert(Parent && "FIXME: handle unnamed decls (lambdas, blocks) with SEH"); MangleContext &Mangler = CGM.getCXXABI().getMangleContext(); if (IsFilter) Mangler.mangleSEHFilterExpression(Parent, OS); else Mangler.mangleSEHFinallyBlock(Parent, OS); } FunctionArgList Args; if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86 || !IsFilter) { // All SEH finally functions take two parameters. Win64 filters take two // parameters. Win32 filters take no parameters. if (IsFilter) { Args.push_back(ImplicitParamDecl::Create( getContext(), nullptr, StartLoc, &getContext().Idents.get("exception_pointers"), getContext().VoidPtrTy)); } else { Args.push_back(ImplicitParamDecl::Create( getContext(), nullptr, StartLoc, &getContext().Idents.get("abnormal_termination"), getContext().UnsignedCharTy)); } Args.push_back(ImplicitParamDecl::Create( getContext(), nullptr, StartLoc, &getContext().Idents.get("frame_pointer"), getContext().VoidPtrTy)); } QualType RetTy = IsFilter ? getContext().LongTy : getContext().VoidTy; llvm::Function *ParentFn = ParentCGF.CurFn; const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeFreeFunctionDeclaration( RetTy, Args, FunctionType::ExtInfo(), /*isVariadic=*/false); llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FnInfo); llvm::Function *Fn = llvm::Function::Create( FnTy, llvm::GlobalValue::InternalLinkage, Name.str(), &CGM.getModule()); // The filter is either in the same comdat as the function, or it's internal. if (llvm::Comdat *C = ParentFn->getComdat()) { Fn->setComdat(C); } else if (ParentFn->hasWeakLinkage() || ParentFn->hasLinkOnceLinkage()) { llvm::Comdat *C = CGM.getModule().getOrInsertComdat(ParentFn->getName()); ParentFn->setComdat(C); Fn->setComdat(C); } else { Fn->setLinkage(llvm::GlobalValue::InternalLinkage); } IsOutlinedSEHHelper = true; StartFunction(GlobalDecl(), RetTy, Fn, FnInfo, Args, OutlinedStmt->getLocStart(), OutlinedStmt->getLocStart()); CGM.SetLLVMFunctionAttributes(nullptr, FnInfo, CurFn); EmitCapturedLocals(ParentCGF, OutlinedStmt, IsFilter); } /// Create a stub filter function that will ultimately hold the code of the /// filter expression. The EH preparation passes in LLVM will outline the code /// from the main function body into this stub. llvm::Function * CodeGenFunction::GenerateSEHFilterFunction(CodeGenFunction &ParentCGF, const SEHExceptStmt &Except) { const Expr *FilterExpr = Except.getFilterExpr(); startOutlinedSEHHelper(ParentCGF, true, FilterExpr); // Emit the original filter expression, convert to i32, and return. llvm::Value *R = EmitScalarExpr(FilterExpr); R = Builder.CreateIntCast(R, ConvertType(getContext().LongTy), FilterExpr->getType()->isSignedIntegerType()); Builder.CreateStore(R, ReturnValue); FinishFunction(FilterExpr->getLocEnd()); return CurFn; } llvm::Function * CodeGenFunction::GenerateSEHFinallyFunction(CodeGenFunction &ParentCGF, const SEHFinallyStmt &Finally) { const Stmt *FinallyBlock = Finally.getBlock(); startOutlinedSEHHelper(ParentCGF, false, FinallyBlock); // Mark finally block calls as nounwind and noinline to make LLVM's job a // little easier. // FIXME: Remove these restrictions in the future. CurFn->addFnAttr(llvm::Attribute::NoUnwind); CurFn->addFnAttr(llvm::Attribute::NoInline); // Emit the original filter expression, convert to i32, and return. EmitStmt(FinallyBlock); FinishFunction(FinallyBlock->getLocEnd()); return CurFn; } void CodeGenFunction::EmitSEHExceptionCodeSave(CodeGenFunction &ParentCGF, llvm::Value *ParentFP, llvm::Value *EntryFP) { // Get the pointer to the EXCEPTION_POINTERS struct. This is returned by the // __exception_info intrinsic. if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) { // On Win64, the info is passed as the first parameter to the filter. SEHInfo = &*CurFn->arg_begin(); SEHCodeSlotStack.push_back( CreateMemTemp(getContext().IntTy, "__exception_code")); } else { // On Win32, the EBP on entry to the filter points to the end of an // exception registration object. It contains 6 32-bit fields, and the info // pointer is stored in the second field. So, GEP 20 bytes backwards and // load the pointer. SEHInfo = Builder.CreateConstInBoundsGEP1_32(Int8Ty, EntryFP, -20); SEHInfo = Builder.CreateBitCast(SEHInfo, Int8PtrTy->getPointerTo()); SEHInfo = Builder.CreateAlignedLoad(Int8PtrTy, SEHInfo, getPointerAlign()); SEHCodeSlotStack.push_back(recoverAddrOfEscapedLocal( ParentCGF, ParentCGF.SEHCodeSlotStack.back(), ParentFP)); } // Save the exception code in the exception slot to unify exception access in // the filter function and the landing pad. // struct EXCEPTION_POINTERS { // EXCEPTION_RECORD *ExceptionRecord; // CONTEXT *ContextRecord; // }; // int exceptioncode = exception_pointers->ExceptionRecord->ExceptionCode; llvm::Type *RecordTy = CGM.Int32Ty->getPointerTo(); llvm::Type *PtrsTy = llvm::StructType::get(RecordTy, CGM.VoidPtrTy, nullptr); llvm::Value *Ptrs = Builder.CreateBitCast(SEHInfo, PtrsTy->getPointerTo()); llvm::Value *Rec = Builder.CreateStructGEP(PtrsTy, Ptrs, 0); Rec = Builder.CreateAlignedLoad(Rec, getPointerAlign()); llvm::Value *Code = Builder.CreateAlignedLoad(Rec, getIntAlign()); assert(!SEHCodeSlotStack.empty() && "emitting EH code outside of __except"); Builder.CreateStore(Code, SEHCodeSlotStack.back()); } llvm::Value *CodeGenFunction::EmitSEHExceptionInfo() { // Sema should diagnose calling this builtin outside of a filter context, but // don't crash if we screw up. if (!SEHInfo) return llvm::UndefValue::get(Int8PtrTy); assert(SEHInfo->getType() == Int8PtrTy); return SEHInfo; } llvm::Value *CodeGenFunction::EmitSEHExceptionCode() { assert(!SEHCodeSlotStack.empty() && "emitting EH code outside of __except"); return Builder.CreateLoad(SEHCodeSlotStack.back()); } llvm::Value *CodeGenFunction::EmitSEHAbnormalTermination() { // Abnormal termination is just the first parameter to the outlined finally // helper. auto AI = CurFn->arg_begin(); return Builder.CreateZExt(&*AI, Int32Ty); } void CodeGenFunction::EnterSEHTryStmt(const SEHTryStmt &S) { CodeGenFunction HelperCGF(CGM, /*suppressNewContext=*/true); if (const SEHFinallyStmt *Finally = S.getFinallyHandler()) { // Outline the finally block. llvm::Function *FinallyFunc = HelperCGF.GenerateSEHFinallyFunction(*this, *Finally); // Push a cleanup for __finally blocks. EHStack.pushCleanup(NormalAndEHCleanup, FinallyFunc); return; } // Otherwise, we must have an __except block. const SEHExceptStmt *Except = S.getExceptHandler(); assert(Except); EHCatchScope *CatchScope = EHStack.pushCatch(1); SEHCodeSlotStack.push_back( CreateMemTemp(getContext().IntTy, "__exception_code")); // If the filter is known to evaluate to 1, then we can use the clause // "catch i8* null". We can't do this on x86 because the filter has to save // the exception code. llvm::Constant *C = CGM.EmitConstantExpr(Except->getFilterExpr(), getContext().IntTy, this); if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86 && C && C->isOneValue()) { CatchScope->setCatchAllHandler(0, createBasicBlock("__except")); return; } // In general, we have to emit an outlined filter function. Use the function // in place of the RTTI typeinfo global that C++ EH uses. llvm::Function *FilterFunc = HelperCGF.GenerateSEHFilterFunction(*this, *Except); llvm::Constant *OpaqueFunc = llvm::ConstantExpr::getBitCast(FilterFunc, Int8PtrTy); CatchScope->setHandler(0, OpaqueFunc, createBasicBlock("__except.ret")); } void CodeGenFunction::ExitSEHTryStmt(const SEHTryStmt &S) { // Just pop the cleanup if it's a __finally block. if (S.getFinallyHandler()) { PopCleanupBlock(); return; } // Otherwise, we must have an __except block. const SEHExceptStmt *Except = S.getExceptHandler(); assert(Except && "__try must have __finally xor __except"); EHCatchScope &CatchScope = cast(*EHStack.begin()); // Don't emit the __except block if the __try block lacked invokes. // TODO: Model unwind edges from instructions, either with iload / istore or // a try body function. if (!CatchScope.hasEHBranches()) { CatchScope.clearHandlerBlocks(); EHStack.popCatch(); SEHCodeSlotStack.pop_back(); return; } // The fall-through block. llvm::BasicBlock *ContBB = createBasicBlock("__try.cont"); // We just emitted the body of the __try; jump to the continue block. if (HaveInsertPoint()) Builder.CreateBr(ContBB); // Check if our filter function returned true. emitCatchDispatchBlock(*this, CatchScope); // Grab the block before we pop the handler. llvm::BasicBlock *CatchPadBB = CatchScope.getHandler(0).Block; EHStack.popCatch(); EmitBlockAfterUses(CatchPadBB); // __except blocks don't get outlined into funclets, so immediately do a // catchret. llvm::CatchPadInst *CPI = cast(CatchPadBB->getFirstNonPHI()); llvm::BasicBlock *ExceptBB = createBasicBlock("__except"); Builder.CreateCatchRet(CPI, ExceptBB); EmitBlock(ExceptBB); // On Win64, the exception code is returned in EAX. Copy it into the slot. if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) { llvm::Function *SEHCodeIntrin = CGM.getIntrinsic(llvm::Intrinsic::eh_exceptioncode); llvm::Value *Code = Builder.CreateCall(SEHCodeIntrin, {CPI}); Builder.CreateStore(Code, SEHCodeSlotStack.back()); } // Emit the __except body. EmitStmt(Except->getBlock()); // End the lifetime of the exception code. SEHCodeSlotStack.pop_back(); if (HaveInsertPoint()) Builder.CreateBr(ContBB); EmitBlock(ContBB); d1649 1 a1649 15 // If this code is reachable then emit a stop point (if generating // debug info). We have to do this ourselves because we are on the // "simple" statement path. if (HaveInsertPoint()) EmitStopPoint(&S); // This must be a __leave from a __finally block, which we warn on and is UB. // Just emit unreachable. if (!isSEHTryScope()) { Builder.CreateUnreachable(); Builder.ClearInsertionPoint(); return; } EmitBranchThroughCleanup(*SEHTryEpilogueStack.back()); @ 1.1.1.7.2.1 log @Sync with HEAD @ text @a99 4 EHPersonality::GNU_ObjC_SJLJ = {"__gnu_objc_personality_sj0", "objc_exception_throw"}; const EHPersonality EHPersonality::GNU_ObjC_SEH = {"__gnu_objc_personality_seh0", "objc_exception_throw"}; const EHPersonality a139 4 if (L.SjLjExceptions) return EHPersonality::GNU_ObjC_SJLJ; else if (useLibGCCSEHPersonality(T)) return EHPersonality::GNU_ObjC_SEH; d224 4 a227 3 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty, true), Personality.PersonalityFn, llvm::AttributeSet(), /*Local=*/true); d689 2 a690 4 // If exceptions are disabled and SEH is not in use, then there is no invoke // destination. SEH "works" even if exceptions are off. In practice, this // means that C++ destructors and other EH cleanups don't run, which is // consistent with MSVC's behavior. a698 4 // CUDA device code doesn't have exceptions. if (LO.CUDA && LO.CUDAIsDevice) return nullptr; a1328 2 SaveAndRestore RestoreCurrentFuncletPad( CurrentFuncletPad); d1333 1 a1333 1 CurrentFuncletPad = Builder.CreateCleanupPad(ParentPad); d1425 3 d1429 2 a1430 1 CGM.getTypes().arrangeBuiltinFunctionCall(Context.VoidTy, Args); d1432 1 a1432 2 auto Callee = CGCallee::forDirect(OutlinedFinally); CGF.EmitCall(FnInfo, Callee, ReturnValueSlot(), Args); d1626 3 a1628 2 const FunctionDecl *ParentSEHFn = ParentCGF.CurSEHParent; assert(ParentSEHFn && "No CurSEHParent!"); d1631 1 a1631 1 Mangler.mangleSEHFilterExpression(ParentSEHFn, OS); d1633 1 a1633 1 Mangler.mangleSEHFinallyBlock(ParentSEHFn, OS); d1659 2 a1660 2 const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeBuiltinFunctionDeclaration(RetTy, Args); a1679 1 CurSEHParent = ParentCGF.CurSEHParent; d1711 6 @ 1.1.1.8 log @Import Clang pre-4.0.0 r291444. @ text @a99 4 EHPersonality::GNU_ObjC_SJLJ = {"__gnu_objc_personality_sj0", "objc_exception_throw"}; const EHPersonality EHPersonality::GNU_ObjC_SEH = {"__gnu_objc_personality_seh0", "objc_exception_throw"}; const EHPersonality a139 4 if (L.SjLjExceptions) return EHPersonality::GNU_ObjC_SJLJ; else if (useLibGCCSEHPersonality(T)) return EHPersonality::GNU_ObjC_SEH; d224 4 a227 3 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty, true), Personality.PersonalityFn, llvm::AttributeSet(), /*Local=*/true); d689 2 a690 4 // If exceptions are disabled and SEH is not in use, then there is no invoke // destination. SEH "works" even if exceptions are off. In practice, this // means that C++ destructors and other EH cleanups don't run, which is // consistent with MSVC's behavior. a698 4 // CUDA device code doesn't have exceptions. if (LO.CUDA && LO.CUDAIsDevice) return nullptr; a1328 2 SaveAndRestore RestoreCurrentFuncletPad( CurrentFuncletPad); d1333 1 a1333 1 CurrentFuncletPad = Builder.CreateCleanupPad(ParentPad); d1425 3 d1429 2 a1430 1 CGM.getTypes().arrangeBuiltinFunctionCall(Context.VoidTy, Args); d1432 1 a1432 2 auto Callee = CGCallee::forDirect(OutlinedFinally); CGF.EmitCall(FnInfo, Callee, ReturnValueSlot(), Args); d1626 3 a1628 2 const FunctionDecl *ParentSEHFn = ParentCGF.CurSEHParent; assert(ParentSEHFn && "No CurSEHParent!"); d1631 1 a1631 1 Mangler.mangleSEHFilterExpression(ParentSEHFn, OS); d1633 1 a1633 1 Mangler.mangleSEHFinallyBlock(ParentSEHFn, OS); d1659 2 a1660 2 const CGFunctionInfo &FnInfo = CGM.getTypes().arrangeBuiltinFunctionDeclaration(RetTy, Args); a1679 1 CurSEHParent = ParentCGF.CurSEHParent; d1711 6 @ 1.1.1.9 log @Import clang r309604 from branches/release_50 @ text @d183 2 a184 2 case ObjCRuntime::ObjFW: return getObjCPersonality(T, L); d234 1 a234 1 llvm::AttributeList(), /*Local=*/true); d768 2 a769 2 llvm::LandingPadInst *LPadInst = Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty), 0); d1313 2 a1314 2 llvm::LandingPadInst *LPadInst = Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty), 0); d1390 2 a1391 1 llvm::Type *LPadType = llvm::StructType::get(Exn->getType(), Sel->getType()); d1653 1 a1653 1 getContext(), /*DC=*/nullptr, StartLoc, d1655 1 a1655 1 getContext().VoidPtrTy, ImplicitParamDecl::Other)); d1658 1 a1658 1 getContext(), /*DC=*/nullptr, StartLoc, d1660 1 a1660 1 getContext().UnsignedCharTy, ImplicitParamDecl::Other)); d1663 2 a1664 3 getContext(), /*DC=*/nullptr, StartLoc, &getContext().Idents.get("frame_pointer"), getContext().VoidPtrTy, ImplicitParamDecl::Other)); d1669 1 d1676 10 d1761 1 a1761 1 llvm::Type *PtrsTy = llvm::StructType::get(RecordTy, CGM.VoidPtrTy); @ 1.1.1.9.4.1 log @Sync with HEAD @ text @a17 1 #include "ConstantEmitter.h" d67 1 a67 1 name = "?terminate@@@@YAXXZ"; a112 2 const EHPersonality EHPersonality::GNU_Wasm_CPlusPlus = { "__gxx_wasm_personality_v0", nullptr }; d114 7 a120 1 static const EHPersonality &getCPersonality(const TargetInfo &Target, a121 3 const llvm::Triple &T = Target.getTriple(); if (T.isWindowsMSVCEnvironment()) return EHPersonality::MSVC_CxxFrameHandler3; d124 1 a124 3 if (L.DWARFExceptions) return EHPersonality::GNU_C; if (L.SEHExceptions) d129 1 a129 1 static const EHPersonality &getObjCPersonality(const TargetInfo &Target, a130 4 const llvm::Triple &T = Target.getTriple(); if (T.isWindowsMSVCEnvironment()) return EHPersonality::MSVC_CxxFrameHandler3; d133 1 a133 1 return getCPersonality(Target, L); d141 1 a141 1 LLVM_FALLTHROUGH; d146 1 a146 1 if (L.SEHExceptions) d153 1 a153 1 static const EHPersonality &getCXXPersonality(const TargetInfo &Target, a154 3 const llvm::Triple &T = Target.getTriple(); if (T.isWindowsMSVCEnvironment()) return EHPersonality::MSVC_CxxFrameHandler3; d157 1 a157 3 if (L.DWARFExceptions) return EHPersonality::GNU_CPlusPlus; if (L.SEHExceptions) a158 5 // Wasm EH is a non-MVP feature for now. if (Target.hasFeature("exception-handling") && (T.getArch() == llvm::Triple::wasm32 || T.getArch() == llvm::Triple::wasm64)) return EHPersonality::GNU_Wasm_CPlusPlus; d164 1 a164 1 static const EHPersonality &getObjCXXPersonality(const TargetInfo &Target, a165 3 if (Target.getTriple().isWindowsMSVCEnvironment()) return EHPersonality::MSVC_CxxFrameHandler3; a166 5 // In the fragile ABI, just use C++ exception handling and hope // they're not doing crazy exception mixing. case ObjCRuntime::FragileMacOSX: return getCXXPersonality(Target, L); d173 1 a173 1 return getObjCPersonality(Target, L); d175 4 a178 2 case ObjCRuntime::GNUstep: return EHPersonality::GNU_ObjCXX; d181 1 a181 1 // mixed EH. Use the ObjC personality just to avoid returning null. d184 3 a186 1 return getObjCPersonality(Target, L); a200 1 const TargetInfo &Target = CGM.getTarget(); d206 18 a223 5 if (L.ObjC1) return L.CPlusPlus ? getObjCXXPersonality(Target, L) : getObjCPersonality(Target, L); return L.CPlusPlus ? getCXXPersonality(Target, L) : getCPersonality(Target, L); d227 1 a227 6 const auto *FD = CGF.CurCodeDecl; // For outlined finallys and filters, use the SEH personality in case they // contain more SEH. This mostly only affects finallys. Filters could // hypothetically use gnu statement expressions to sneak in nested SEH. FD = FD ? FD : CGF.CurSEHParent; return get(CGF.CGM, dyn_cast_or_null(FD)); d314 2 a315 1 const EHPersonality &CXX = getCXXPersonality(getTarget(), LangOpts); d449 5 a453 3 if (isNoexceptExceptionSpec(EST) && Proto->canThrow() == CT_Cannot) { // noexcept functions are simple terminate scopes. EHStack.pushTerminate(); d528 4 a531 2 if (isNoexceptExceptionSpec(EST) && Proto->canThrow() == CT_Cannot) { EHStack.popTerminate(); d585 1 a585 1 return getFuncletEHDispatchBlock(si); d633 1 a633 1 CodeGenFunction::getFuncletEHDispatchBlock(EHScopeStack::stable_iterator SI) { d647 1 a647 1 DispatchBlock = getTerminateFunclet(); a926 109 // Wasm uses Windows-style EH instructions, but it merges all catch clauses into // one big catchpad, within which we use Itanium's landingpad-style selector // comparison instructions. static void emitWasmCatchPadBlock(CodeGenFunction &CGF, EHCatchScope &CatchScope) { llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock(); assert(DispatchBlock); CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveIP(); CGF.EmitBlockAfterUses(DispatchBlock); llvm::Value *ParentPad = CGF.CurrentFuncletPad; if (!ParentPad) ParentPad = llvm::ConstantTokenNone::get(CGF.getLLVMContext()); llvm::BasicBlock *UnwindBB = CGF.getEHDispatchBlock(CatchScope.getEnclosingEHScope()); unsigned NumHandlers = CatchScope.getNumHandlers(); llvm::CatchSwitchInst *CatchSwitch = CGF.Builder.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers); // We don't use a landingpad instruction, so generate intrinsic calls to // provide exception and selector values. llvm::BasicBlock *WasmCatchStartBlock = CGF.createBasicBlock("catch.start"); CatchSwitch->addHandler(WasmCatchStartBlock); CGF.EmitBlockAfterUses(WasmCatchStartBlock); // Create a catchpad instruction. SmallVector CatchTypes; for (unsigned I = 0, E = NumHandlers; I < E; ++I) { const EHCatchScope::Handler &Handler = CatchScope.getHandler(I); CatchTypeInfo TypeInfo = Handler.Type; if (!TypeInfo.RTTI) TypeInfo.RTTI = llvm::Constant::getNullValue(CGF.VoidPtrTy); CatchTypes.push_back(TypeInfo.RTTI); } auto *CPI = CGF.Builder.CreateCatchPad(CatchSwitch, CatchTypes); // Create calls to wasm.get.exception and wasm.get.ehselector intrinsics. // Before they are lowered appropriately later, they provide values for the // exception and selector. llvm::Value *GetExnFn = CGF.CGM.getIntrinsic(llvm::Intrinsic::wasm_get_exception); llvm::Value *GetSelectorFn = CGF.CGM.getIntrinsic(llvm::Intrinsic::wasm_get_ehselector); llvm::CallInst *Exn = CGF.Builder.CreateCall(GetExnFn, CPI); CGF.Builder.CreateStore(Exn, CGF.getExceptionSlot()); llvm::CallInst *Selector = CGF.Builder.CreateCall(GetSelectorFn, CPI); llvm::Value *TypeIDFn = CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for); // If there's only a single catch-all, branch directly to its handler. if (CatchScope.getNumHandlers() == 1 && CatchScope.getHandler(0).isCatchAll()) { CGF.Builder.CreateBr(CatchScope.getHandler(0).Block); CGF.Builder.restoreIP(SavedIP); return; } // Test against each of the exception types we claim to catch. for (unsigned I = 0, E = NumHandlers;; ++I) { assert(I < E && "ran off end of handlers!"); const EHCatchScope::Handler &Handler = CatchScope.getHandler(I); CatchTypeInfo TypeInfo = Handler.Type; if (!TypeInfo.RTTI) TypeInfo.RTTI = llvm::Constant::getNullValue(CGF.VoidPtrTy); // Figure out the next block. llvm::BasicBlock *NextBlock; bool EmitNextBlock = false, NextIsEnd = false; // If this is the last handler, we're at the end, and the next block is a // block that contains a call to the rethrow function, so we can unwind to // the enclosing EH scope. The call itself will be generated later. if (I + 1 == E) { NextBlock = CGF.createBasicBlock("rethrow"); EmitNextBlock = true; NextIsEnd = true; // If the next handler is a catch-all, we're at the end, and the // next block is that handler. } else if (CatchScope.getHandler(I + 1).isCatchAll()) { NextBlock = CatchScope.getHandler(I + 1).Block; NextIsEnd = true; // Otherwise, we're not at the end and we need a new block. } else { NextBlock = CGF.createBasicBlock("catch.fallthrough"); EmitNextBlock = true; } // Figure out the catch type's index in the LSDA's type table. llvm::CallInst *TypeIndex = CGF.Builder.CreateCall(TypeIDFn, TypeInfo.RTTI); TypeIndex->setDoesNotThrow(); llvm::Value *MatchesTypeIndex = CGF.Builder.CreateICmpEQ(Selector, TypeIndex, "matches"); CGF.Builder.CreateCondBr(MatchesTypeIndex, Handler.Block, NextBlock); if (EmitNextBlock) CGF.EmitBlock(NextBlock); if (NextIsEnd) break; } CGF.Builder.restoreIP(SavedIP); } a930 2 if (EHPersonality::get(CGF).isWasmPersonality()) return emitWasmCatchPadBlock(CGF, catchScope); a1017 1 llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock(); a1049 16 // Wasm uses Windows-style EH instructions, but merges all catch clauses into // one big catchpad. So we save the old funclet pad here before we traverse // each catch handler. SaveAndRestore RestoreCurrentFuncletPad( CurrentFuncletPad); llvm::BasicBlock *WasmCatchStartBlock = nullptr; if (EHPersonality::get(*this).isWasmPersonality()) { auto *CatchSwitch = cast(DispatchBlock->getFirstNonPHI()); WasmCatchStartBlock = CatchSwitch->hasUnwindDest() ? CatchSwitch->getSuccessor(1) : CatchSwitch->getSuccessor(0); auto *CPI = cast(WasmCatchStartBlock->getFirstNonPHI()); CurrentFuncletPad = CPI; } a1056 1 bool HasCatchAll = false; a1057 1 HasCatchAll |= Handlers[I - 1].isCatchAll(); a1101 21 // Because in wasm we merge all catch clauses into one big catchpad, in case // none of the types in catch handlers matches after we test against each of // them, we should unwind to the next EH enclosing scope. We generate a call // to rethrow function here to do that. if (EHPersonality::get(*this).isWasmPersonality() && !HasCatchAll) { assert(WasmCatchStartBlock); // Navigate for the "rethrow" block we created in emitWasmCatchPadBlock(). // Wasm uses landingpad-style conditional branches to compare selectors, so // we follow the false destination for each of the cond branches to reach // the rethrow block. llvm::BasicBlock *RethrowBlock = WasmCatchStartBlock; while (llvm::TerminatorInst *TI = RethrowBlock->getTerminator()) { auto *BI = cast(TI); assert(BI->isConditional()); RethrowBlock = BI->getSuccessor(1); } assert(RethrowBlock != WasmCatchStartBlock && RethrowBlock->empty()); Builder.SetInsertPoint(RethrowBlock); CGM.getCXXABI().emitRethrow(*this, /*isNoReturn=*/true); } d1335 2 a1339 1 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); a1340 1 a1341 30 if (getLangOpts().CPlusPlus) Exn = getExceptionFromSlot(); llvm::CallInst *terminateCall = CGM.getCXXABI().emitTerminateForUnexpectedException(*this, Exn); terminateCall->setDoesNotReturn(); Builder.CreateUnreachable(); // Restore the saved insertion state. Builder.restoreIP(SavedIP); return TerminateHandler; } llvm::BasicBlock *CodeGenFunction::getTerminateFunclet() { assert(EHPersonality::get(*this).usesFuncletPads() && "use getTerminateLandingPad for non-funclet EH"); llvm::BasicBlock *&TerminateFunclet = TerminateFunclets[CurrentFuncletPad]; if (TerminateFunclet) return TerminateFunclet; CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); // Set up the terminate handler. This block is inserted at the very // end of the function by FinishFunction. TerminateFunclet = createBasicBlock("terminate.handler"); Builder.SetInsertPoint(TerminateFunclet); // Create the cleanuppad using the current parent pad as its token. Use 'none' // if this is a top-level terminate scope, which is the common case. d1344 8 a1351 14 llvm::Value *ParentPad = CurrentFuncletPad; if (!ParentPad) ParentPad = llvm::ConstantTokenNone::get(CGM.getLLVMContext()); CurrentFuncletPad = Builder.CreateCleanupPad(ParentPad); // Emit the __std_terminate call. llvm::Value *Exn = nullptr; // In case of wasm personality, we need to pass the exception value to // __clang_call_terminate function. if (getLangOpts().CPlusPlus && EHPersonality::get(*this).isWasmPersonality()) { llvm::Value *GetExnFn = CGM.getIntrinsic(llvm::Intrinsic::wasm_get_exception); Exn = Builder.CreateCall(GetExnFn, CurrentFuncletPad); d1361 1 a1361 1 return TerminateFunclet; d1803 1 a1803 2 ConstantEmitter(*this).tryEmitAbstract(Except->getFilterExpr(), getContext().IntTy); @ 1.1.1.9.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.9.2.1 log @Sync with HEAD @ text @a17 1 #include "ConstantEmitter.h" d67 1 a67 1 name = "?terminate@@@@YAXXZ"; a112 2 const EHPersonality EHPersonality::GNU_Wasm_CPlusPlus = { "__gxx_wasm_personality_v0", nullptr }; d114 7 a120 1 static const EHPersonality &getCPersonality(const TargetInfo &Target, a121 3 const llvm::Triple &T = Target.getTriple(); if (T.isWindowsMSVCEnvironment()) return EHPersonality::MSVC_CxxFrameHandler3; d124 1 a124 3 if (L.DWARFExceptions) return EHPersonality::GNU_C; if (L.SEHExceptions) d129 1 a129 1 static const EHPersonality &getObjCPersonality(const TargetInfo &Target, a130 4 const llvm::Triple &T = Target.getTriple(); if (T.isWindowsMSVCEnvironment()) return EHPersonality::MSVC_CxxFrameHandler3; d133 1 a133 1 return getCPersonality(Target, L); d141 1 a141 1 LLVM_FALLTHROUGH; d146 1 a146 1 if (L.SEHExceptions) d153 1 a153 1 static const EHPersonality &getCXXPersonality(const TargetInfo &Target, a154 3 const llvm::Triple &T = Target.getTriple(); if (T.isWindowsMSVCEnvironment()) return EHPersonality::MSVC_CxxFrameHandler3; d157 1 a157 3 if (L.DWARFExceptions) return EHPersonality::GNU_CPlusPlus; if (L.SEHExceptions) a158 5 // Wasm EH is a non-MVP feature for now. if (Target.hasFeature("exception-handling") && (T.getArch() == llvm::Triple::wasm32 || T.getArch() == llvm::Triple::wasm64)) return EHPersonality::GNU_Wasm_CPlusPlus; d164 1 a164 1 static const EHPersonality &getObjCXXPersonality(const TargetInfo &Target, a165 3 if (Target.getTriple().isWindowsMSVCEnvironment()) return EHPersonality::MSVC_CxxFrameHandler3; a166 5 // In the fragile ABI, just use C++ exception handling and hope // they're not doing crazy exception mixing. case ObjCRuntime::FragileMacOSX: return getCXXPersonality(Target, L); d173 1 a173 1 return getObjCPersonality(Target, L); d175 4 a178 2 case ObjCRuntime::GNUstep: return EHPersonality::GNU_ObjCXX; d181 1 a181 1 // mixed EH. Use the ObjC personality just to avoid returning null. d184 3 a186 1 return getObjCPersonality(Target, L); a200 1 const TargetInfo &Target = CGM.getTarget(); d206 18 a223 5 if (L.ObjC1) return L.CPlusPlus ? getObjCXXPersonality(Target, L) : getObjCPersonality(Target, L); return L.CPlusPlus ? getCXXPersonality(Target, L) : getCPersonality(Target, L); d227 1 a227 6 const auto *FD = CGF.CurCodeDecl; // For outlined finallys and filters, use the SEH personality in case they // contain more SEH. This mostly only affects finallys. Filters could // hypothetically use gnu statement expressions to sneak in nested SEH. FD = FD ? FD : CGF.CurSEHParent; return get(CGF.CGM, dyn_cast_or_null(FD)); d314 2 a315 1 const EHPersonality &CXX = getCXXPersonality(getTarget(), LangOpts); d449 5 a453 3 if (isNoexceptExceptionSpec(EST) && Proto->canThrow() == CT_Cannot) { // noexcept functions are simple terminate scopes. EHStack.pushTerminate(); d528 4 a531 2 if (isNoexceptExceptionSpec(EST) && Proto->canThrow() == CT_Cannot) { EHStack.popTerminate(); d585 1 a585 1 return getFuncletEHDispatchBlock(si); d633 1 a633 1 CodeGenFunction::getFuncletEHDispatchBlock(EHScopeStack::stable_iterator SI) { d647 1 a647 1 DispatchBlock = getTerminateFunclet(); a926 109 // Wasm uses Windows-style EH instructions, but it merges all catch clauses into // one big catchpad, within which we use Itanium's landingpad-style selector // comparison instructions. static void emitWasmCatchPadBlock(CodeGenFunction &CGF, EHCatchScope &CatchScope) { llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock(); assert(DispatchBlock); CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveIP(); CGF.EmitBlockAfterUses(DispatchBlock); llvm::Value *ParentPad = CGF.CurrentFuncletPad; if (!ParentPad) ParentPad = llvm::ConstantTokenNone::get(CGF.getLLVMContext()); llvm::BasicBlock *UnwindBB = CGF.getEHDispatchBlock(CatchScope.getEnclosingEHScope()); unsigned NumHandlers = CatchScope.getNumHandlers(); llvm::CatchSwitchInst *CatchSwitch = CGF.Builder.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers); // We don't use a landingpad instruction, so generate intrinsic calls to // provide exception and selector values. llvm::BasicBlock *WasmCatchStartBlock = CGF.createBasicBlock("catch.start"); CatchSwitch->addHandler(WasmCatchStartBlock); CGF.EmitBlockAfterUses(WasmCatchStartBlock); // Create a catchpad instruction. SmallVector CatchTypes; for (unsigned I = 0, E = NumHandlers; I < E; ++I) { const EHCatchScope::Handler &Handler = CatchScope.getHandler(I); CatchTypeInfo TypeInfo = Handler.Type; if (!TypeInfo.RTTI) TypeInfo.RTTI = llvm::Constant::getNullValue(CGF.VoidPtrTy); CatchTypes.push_back(TypeInfo.RTTI); } auto *CPI = CGF.Builder.CreateCatchPad(CatchSwitch, CatchTypes); // Create calls to wasm.get.exception and wasm.get.ehselector intrinsics. // Before they are lowered appropriately later, they provide values for the // exception and selector. llvm::Value *GetExnFn = CGF.CGM.getIntrinsic(llvm::Intrinsic::wasm_get_exception); llvm::Value *GetSelectorFn = CGF.CGM.getIntrinsic(llvm::Intrinsic::wasm_get_ehselector); llvm::CallInst *Exn = CGF.Builder.CreateCall(GetExnFn, CPI); CGF.Builder.CreateStore(Exn, CGF.getExceptionSlot()); llvm::CallInst *Selector = CGF.Builder.CreateCall(GetSelectorFn, CPI); llvm::Value *TypeIDFn = CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for); // If there's only a single catch-all, branch directly to its handler. if (CatchScope.getNumHandlers() == 1 && CatchScope.getHandler(0).isCatchAll()) { CGF.Builder.CreateBr(CatchScope.getHandler(0).Block); CGF.Builder.restoreIP(SavedIP); return; } // Test against each of the exception types we claim to catch. for (unsigned I = 0, E = NumHandlers;; ++I) { assert(I < E && "ran off end of handlers!"); const EHCatchScope::Handler &Handler = CatchScope.getHandler(I); CatchTypeInfo TypeInfo = Handler.Type; if (!TypeInfo.RTTI) TypeInfo.RTTI = llvm::Constant::getNullValue(CGF.VoidPtrTy); // Figure out the next block. llvm::BasicBlock *NextBlock; bool EmitNextBlock = false, NextIsEnd = false; // If this is the last handler, we're at the end, and the next block is a // block that contains a call to the rethrow function, so we can unwind to // the enclosing EH scope. The call itself will be generated later. if (I + 1 == E) { NextBlock = CGF.createBasicBlock("rethrow"); EmitNextBlock = true; NextIsEnd = true; // If the next handler is a catch-all, we're at the end, and the // next block is that handler. } else if (CatchScope.getHandler(I + 1).isCatchAll()) { NextBlock = CatchScope.getHandler(I + 1).Block; NextIsEnd = true; // Otherwise, we're not at the end and we need a new block. } else { NextBlock = CGF.createBasicBlock("catch.fallthrough"); EmitNextBlock = true; } // Figure out the catch type's index in the LSDA's type table. llvm::CallInst *TypeIndex = CGF.Builder.CreateCall(TypeIDFn, TypeInfo.RTTI); TypeIndex->setDoesNotThrow(); llvm::Value *MatchesTypeIndex = CGF.Builder.CreateICmpEQ(Selector, TypeIndex, "matches"); CGF.Builder.CreateCondBr(MatchesTypeIndex, Handler.Block, NextBlock); if (EmitNextBlock) CGF.EmitBlock(NextBlock); if (NextIsEnd) break; } CGF.Builder.restoreIP(SavedIP); } a930 2 if (EHPersonality::get(CGF).isWasmPersonality()) return emitWasmCatchPadBlock(CGF, catchScope); a1017 1 llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock(); a1049 16 // Wasm uses Windows-style EH instructions, but merges all catch clauses into // one big catchpad. So we save the old funclet pad here before we traverse // each catch handler. SaveAndRestore RestoreCurrentFuncletPad( CurrentFuncletPad); llvm::BasicBlock *WasmCatchStartBlock = nullptr; if (EHPersonality::get(*this).isWasmPersonality()) { auto *CatchSwitch = cast(DispatchBlock->getFirstNonPHI()); WasmCatchStartBlock = CatchSwitch->hasUnwindDest() ? CatchSwitch->getSuccessor(1) : CatchSwitch->getSuccessor(0); auto *CPI = cast(WasmCatchStartBlock->getFirstNonPHI()); CurrentFuncletPad = CPI; } a1056 1 bool HasCatchAll = false; a1057 1 HasCatchAll |= Handlers[I - 1].isCatchAll(); a1101 21 // Because in wasm we merge all catch clauses into one big catchpad, in case // none of the types in catch handlers matches after we test against each of // them, we should unwind to the next EH enclosing scope. We generate a call // to rethrow function here to do that. if (EHPersonality::get(*this).isWasmPersonality() && !HasCatchAll) { assert(WasmCatchStartBlock); // Navigate for the "rethrow" block we created in emitWasmCatchPadBlock(). // Wasm uses landingpad-style conditional branches to compare selectors, so // we follow the false destination for each of the cond branches to reach // the rethrow block. llvm::BasicBlock *RethrowBlock = WasmCatchStartBlock; while (llvm::TerminatorInst *TI = RethrowBlock->getTerminator()) { auto *BI = cast(TI); assert(BI->isConditional()); RethrowBlock = BI->getSuccessor(1); } assert(RethrowBlock != WasmCatchStartBlock && RethrowBlock->empty()); Builder.SetInsertPoint(RethrowBlock); CGM.getCXXABI().emitRethrow(*this, /*isNoReturn=*/true); } d1335 2 a1339 1 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); a1340 1 a1341 30 if (getLangOpts().CPlusPlus) Exn = getExceptionFromSlot(); llvm::CallInst *terminateCall = CGM.getCXXABI().emitTerminateForUnexpectedException(*this, Exn); terminateCall->setDoesNotReturn(); Builder.CreateUnreachable(); // Restore the saved insertion state. Builder.restoreIP(SavedIP); return TerminateHandler; } llvm::BasicBlock *CodeGenFunction::getTerminateFunclet() { assert(EHPersonality::get(*this).usesFuncletPads() && "use getTerminateLandingPad for non-funclet EH"); llvm::BasicBlock *&TerminateFunclet = TerminateFunclets[CurrentFuncletPad]; if (TerminateFunclet) return TerminateFunclet; CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); // Set up the terminate handler. This block is inserted at the very // end of the function by FinishFunction. TerminateFunclet = createBasicBlock("terminate.handler"); Builder.SetInsertPoint(TerminateFunclet); // Create the cleanuppad using the current parent pad as its token. Use 'none' // if this is a top-level terminate scope, which is the common case. d1344 8 a1351 14 llvm::Value *ParentPad = CurrentFuncletPad; if (!ParentPad) ParentPad = llvm::ConstantTokenNone::get(CGM.getLLVMContext()); CurrentFuncletPad = Builder.CreateCleanupPad(ParentPad); // Emit the __std_terminate call. llvm::Value *Exn = nullptr; // In case of wasm personality, we need to pass the exception value to // __clang_call_terminate function. if (getLangOpts().CPlusPlus && EHPersonality::get(*this).isWasmPersonality()) { llvm::Value *GetExnFn = CGM.getIntrinsic(llvm::Intrinsic::wasm_get_exception); Exn = Builder.CreateCall(GetExnFn, CurrentFuncletPad); d1361 1 a1361 1 return TerminateFunclet; d1803 1 a1803 2 ConstantEmitter(*this).tryEmitAbstract(Except->getFilterExpr(), getContext().IntTy); @ 1.1.1.10 log @Import clang r337282 from trunk @ text @a17 1 #include "ConstantEmitter.h" d67 1 a67 1 name = "?terminate@@@@YAXXZ"; a112 2 const EHPersonality EHPersonality::GNU_Wasm_CPlusPlus = { "__gxx_wasm_personality_v0", nullptr }; d114 7 a120 1 static const EHPersonality &getCPersonality(const TargetInfo &Target, a121 3 const llvm::Triple &T = Target.getTriple(); if (T.isWindowsMSVCEnvironment()) return EHPersonality::MSVC_CxxFrameHandler3; d124 1 a124 3 if (L.DWARFExceptions) return EHPersonality::GNU_C; if (L.SEHExceptions) d129 1 a129 1 static const EHPersonality &getObjCPersonality(const TargetInfo &Target, a130 4 const llvm::Triple &T = Target.getTriple(); if (T.isWindowsMSVCEnvironment()) return EHPersonality::MSVC_CxxFrameHandler3; d133 1 a133 1 return getCPersonality(Target, L); d141 1 a141 1 LLVM_FALLTHROUGH; d146 1 a146 1 if (L.SEHExceptions) d153 1 a153 1 static const EHPersonality &getCXXPersonality(const TargetInfo &Target, a154 3 const llvm::Triple &T = Target.getTriple(); if (T.isWindowsMSVCEnvironment()) return EHPersonality::MSVC_CxxFrameHandler3; d157 1 a157 3 if (L.DWARFExceptions) return EHPersonality::GNU_CPlusPlus; if (L.SEHExceptions) a158 5 // Wasm EH is a non-MVP feature for now. if (Target.hasFeature("exception-handling") && (T.getArch() == llvm::Triple::wasm32 || T.getArch() == llvm::Triple::wasm64)) return EHPersonality::GNU_Wasm_CPlusPlus; d164 1 a164 1 static const EHPersonality &getObjCXXPersonality(const TargetInfo &Target, a165 3 if (Target.getTriple().isWindowsMSVCEnvironment()) return EHPersonality::MSVC_CxxFrameHandler3; a166 5 // In the fragile ABI, just use C++ exception handling and hope // they're not doing crazy exception mixing. case ObjCRuntime::FragileMacOSX: return getCXXPersonality(Target, L); d173 1 a173 1 return getObjCPersonality(Target, L); d175 4 a178 2 case ObjCRuntime::GNUstep: return EHPersonality::GNU_ObjCXX; d181 1 a181 1 // mixed EH. Use the ObjC personality just to avoid returning null. d184 3 a186 1 return getObjCPersonality(Target, L); a200 1 const TargetInfo &Target = CGM.getTarget(); d206 18 a223 5 if (L.ObjC1) return L.CPlusPlus ? getObjCXXPersonality(Target, L) : getObjCPersonality(Target, L); return L.CPlusPlus ? getCXXPersonality(Target, L) : getCPersonality(Target, L); d227 1 a227 6 const auto *FD = CGF.CurCodeDecl; // For outlined finallys and filters, use the SEH personality in case they // contain more SEH. This mostly only affects finallys. Filters could // hypothetically use gnu statement expressions to sneak in nested SEH. FD = FD ? FD : CGF.CurSEHParent; return get(CGF.CGM, dyn_cast_or_null(FD)); d314 2 a315 1 const EHPersonality &CXX = getCXXPersonality(getTarget(), LangOpts); d449 5 a453 3 if (isNoexceptExceptionSpec(EST) && Proto->canThrow() == CT_Cannot) { // noexcept functions are simple terminate scopes. EHStack.pushTerminate(); d528 4 a531 2 if (isNoexceptExceptionSpec(EST) && Proto->canThrow() == CT_Cannot) { EHStack.popTerminate(); d585 1 a585 1 return getFuncletEHDispatchBlock(si); d633 1 a633 1 CodeGenFunction::getFuncletEHDispatchBlock(EHScopeStack::stable_iterator SI) { d647 1 a647 1 DispatchBlock = getTerminateFunclet(); a926 109 // Wasm uses Windows-style EH instructions, but it merges all catch clauses into // one big catchpad, within which we use Itanium's landingpad-style selector // comparison instructions. static void emitWasmCatchPadBlock(CodeGenFunction &CGF, EHCatchScope &CatchScope) { llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock(); assert(DispatchBlock); CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveIP(); CGF.EmitBlockAfterUses(DispatchBlock); llvm::Value *ParentPad = CGF.CurrentFuncletPad; if (!ParentPad) ParentPad = llvm::ConstantTokenNone::get(CGF.getLLVMContext()); llvm::BasicBlock *UnwindBB = CGF.getEHDispatchBlock(CatchScope.getEnclosingEHScope()); unsigned NumHandlers = CatchScope.getNumHandlers(); llvm::CatchSwitchInst *CatchSwitch = CGF.Builder.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers); // We don't use a landingpad instruction, so generate intrinsic calls to // provide exception and selector values. llvm::BasicBlock *WasmCatchStartBlock = CGF.createBasicBlock("catch.start"); CatchSwitch->addHandler(WasmCatchStartBlock); CGF.EmitBlockAfterUses(WasmCatchStartBlock); // Create a catchpad instruction. SmallVector CatchTypes; for (unsigned I = 0, E = NumHandlers; I < E; ++I) { const EHCatchScope::Handler &Handler = CatchScope.getHandler(I); CatchTypeInfo TypeInfo = Handler.Type; if (!TypeInfo.RTTI) TypeInfo.RTTI = llvm::Constant::getNullValue(CGF.VoidPtrTy); CatchTypes.push_back(TypeInfo.RTTI); } auto *CPI = CGF.Builder.CreateCatchPad(CatchSwitch, CatchTypes); // Create calls to wasm.get.exception and wasm.get.ehselector intrinsics. // Before they are lowered appropriately later, they provide values for the // exception and selector. llvm::Value *GetExnFn = CGF.CGM.getIntrinsic(llvm::Intrinsic::wasm_get_exception); llvm::Value *GetSelectorFn = CGF.CGM.getIntrinsic(llvm::Intrinsic::wasm_get_ehselector); llvm::CallInst *Exn = CGF.Builder.CreateCall(GetExnFn, CPI); CGF.Builder.CreateStore(Exn, CGF.getExceptionSlot()); llvm::CallInst *Selector = CGF.Builder.CreateCall(GetSelectorFn, CPI); llvm::Value *TypeIDFn = CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for); // If there's only a single catch-all, branch directly to its handler. if (CatchScope.getNumHandlers() == 1 && CatchScope.getHandler(0).isCatchAll()) { CGF.Builder.CreateBr(CatchScope.getHandler(0).Block); CGF.Builder.restoreIP(SavedIP); return; } // Test against each of the exception types we claim to catch. for (unsigned I = 0, E = NumHandlers;; ++I) { assert(I < E && "ran off end of handlers!"); const EHCatchScope::Handler &Handler = CatchScope.getHandler(I); CatchTypeInfo TypeInfo = Handler.Type; if (!TypeInfo.RTTI) TypeInfo.RTTI = llvm::Constant::getNullValue(CGF.VoidPtrTy); // Figure out the next block. llvm::BasicBlock *NextBlock; bool EmitNextBlock = false, NextIsEnd = false; // If this is the last handler, we're at the end, and the next block is a // block that contains a call to the rethrow function, so we can unwind to // the enclosing EH scope. The call itself will be generated later. if (I + 1 == E) { NextBlock = CGF.createBasicBlock("rethrow"); EmitNextBlock = true; NextIsEnd = true; // If the next handler is a catch-all, we're at the end, and the // next block is that handler. } else if (CatchScope.getHandler(I + 1).isCatchAll()) { NextBlock = CatchScope.getHandler(I + 1).Block; NextIsEnd = true; // Otherwise, we're not at the end and we need a new block. } else { NextBlock = CGF.createBasicBlock("catch.fallthrough"); EmitNextBlock = true; } // Figure out the catch type's index in the LSDA's type table. llvm::CallInst *TypeIndex = CGF.Builder.CreateCall(TypeIDFn, TypeInfo.RTTI); TypeIndex->setDoesNotThrow(); llvm::Value *MatchesTypeIndex = CGF.Builder.CreateICmpEQ(Selector, TypeIndex, "matches"); CGF.Builder.CreateCondBr(MatchesTypeIndex, Handler.Block, NextBlock); if (EmitNextBlock) CGF.EmitBlock(NextBlock); if (NextIsEnd) break; } CGF.Builder.restoreIP(SavedIP); } a930 2 if (EHPersonality::get(CGF).isWasmPersonality()) return emitWasmCatchPadBlock(CGF, catchScope); a1017 1 llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock(); a1049 16 // Wasm uses Windows-style EH instructions, but merges all catch clauses into // one big catchpad. So we save the old funclet pad here before we traverse // each catch handler. SaveAndRestore RestoreCurrentFuncletPad( CurrentFuncletPad); llvm::BasicBlock *WasmCatchStartBlock = nullptr; if (EHPersonality::get(*this).isWasmPersonality()) { auto *CatchSwitch = cast(DispatchBlock->getFirstNonPHI()); WasmCatchStartBlock = CatchSwitch->hasUnwindDest() ? CatchSwitch->getSuccessor(1) : CatchSwitch->getSuccessor(0); auto *CPI = cast(WasmCatchStartBlock->getFirstNonPHI()); CurrentFuncletPad = CPI; } a1056 1 bool HasCatchAll = false; a1057 1 HasCatchAll |= Handlers[I - 1].isCatchAll(); a1101 21 // Because in wasm we merge all catch clauses into one big catchpad, in case // none of the types in catch handlers matches after we test against each of // them, we should unwind to the next EH enclosing scope. We generate a call // to rethrow function here to do that. if (EHPersonality::get(*this).isWasmPersonality() && !HasCatchAll) { assert(WasmCatchStartBlock); // Navigate for the "rethrow" block we created in emitWasmCatchPadBlock(). // Wasm uses landingpad-style conditional branches to compare selectors, so // we follow the false destination for each of the cond branches to reach // the rethrow block. llvm::BasicBlock *RethrowBlock = WasmCatchStartBlock; while (llvm::TerminatorInst *TI = RethrowBlock->getTerminator()) { auto *BI = cast(TI); assert(BI->isConditional()); RethrowBlock = BI->getSuccessor(1); } assert(RethrowBlock != WasmCatchStartBlock && RethrowBlock->empty()); Builder.SetInsertPoint(RethrowBlock); CGM.getCXXABI().emitRethrow(*this, /*isNoReturn=*/true); } d1335 2 a1339 1 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); a1340 1 a1341 30 if (getLangOpts().CPlusPlus) Exn = getExceptionFromSlot(); llvm::CallInst *terminateCall = CGM.getCXXABI().emitTerminateForUnexpectedException(*this, Exn); terminateCall->setDoesNotReturn(); Builder.CreateUnreachable(); // Restore the saved insertion state. Builder.restoreIP(SavedIP); return TerminateHandler; } llvm::BasicBlock *CodeGenFunction::getTerminateFunclet() { assert(EHPersonality::get(*this).usesFuncletPads() && "use getTerminateLandingPad for non-funclet EH"); llvm::BasicBlock *&TerminateFunclet = TerminateFunclets[CurrentFuncletPad]; if (TerminateFunclet) return TerminateFunclet; CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); // Set up the terminate handler. This block is inserted at the very // end of the function by FinishFunction. TerminateFunclet = createBasicBlock("terminate.handler"); Builder.SetInsertPoint(TerminateFunclet); // Create the cleanuppad using the current parent pad as its token. Use 'none' // if this is a top-level terminate scope, which is the common case. d1344 8 a1351 14 llvm::Value *ParentPad = CurrentFuncletPad; if (!ParentPad) ParentPad = llvm::ConstantTokenNone::get(CGM.getLLVMContext()); CurrentFuncletPad = Builder.CreateCleanupPad(ParentPad); // Emit the __std_terminate call. llvm::Value *Exn = nullptr; // In case of wasm personality, we need to pass the exception value to // __clang_call_terminate function. if (getLangOpts().CPlusPlus && EHPersonality::get(*this).isWasmPersonality()) { llvm::Value *GetExnFn = CGM.getIntrinsic(llvm::Intrinsic::wasm_get_exception); Exn = Builder.CreateCall(GetExnFn, CurrentFuncletPad); d1361 1 a1361 1 return TerminateFunclet; d1803 1 a1803 2 ConstantEmitter(*this).tryEmitAbstract(Except->getFilterExpr(), getContext().IntTy); @ 1.1.1.11 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.5.4.1 log @file CGException.cpp was added on branch tls-maxphys on 2014-08-19 23:47:27 +0000 @ text @d1 1638 @ 1.1.1.5.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 1638 //===--- CGException.cpp - Emit LLVM Code for C++ exceptions --------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This contains code dealing with C++ exception related code generation. // //===----------------------------------------------------------------------===// #include "CodeGenFunction.h" #include "CGCleanup.h" #include "CGObjCRuntime.h" #include "TargetInfo.h" #include "clang/AST/StmtCXX.h" #include "clang/AST/StmtObjC.h" #include "llvm/IR/CallSite.h" #include "llvm/IR/Intrinsics.h" using namespace clang; using namespace CodeGen; static llvm::Constant *getAllocateExceptionFn(CodeGenModule &CGM) { // void *__cxa_allocate_exception(size_t thrown_size); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.Int8PtrTy, CGM.SizeTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_allocate_exception"); } static llvm::Constant *getFreeExceptionFn(CodeGenModule &CGM) { // void __cxa_free_exception(void *thrown_exception); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_free_exception"); } static llvm::Constant *getThrowFn(CodeGenModule &CGM) { // void __cxa_throw(void *thrown_exception, std::type_info *tinfo, // void (*dest) (void *)); llvm::Type *Args[3] = { CGM.Int8PtrTy, CGM.Int8PtrTy, CGM.Int8PtrTy }; llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, Args, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_throw"); } static llvm::Constant *getReThrowFn(CodeGenModule &CGM) { // void __cxa_rethrow(); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_rethrow"); } static llvm::Constant *getGetExceptionPtrFn(CodeGenModule &CGM) { // void *__cxa_get_exception_ptr(void*); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_get_exception_ptr"); } static llvm::Constant *getBeginCatchFn(CodeGenModule &CGM) { // void *__cxa_begin_catch(void*); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_begin_catch"); } static llvm::Constant *getEndCatchFn(CodeGenModule &CGM) { // void __cxa_end_catch(); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_end_catch"); } static llvm::Constant *getUnexpectedFn(CodeGenModule &CGM) { // void __cxa_call_unexpected(void *thrown_exception); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_call_unexpected"); } static llvm::Constant *getTerminateFn(CodeGenModule &CGM) { // void __terminate(); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false); StringRef name; // In C++, use std::terminate(). if (CGM.getLangOpts().CPlusPlus) name = "_ZSt9terminatev"; // FIXME: mangling! else if (CGM.getLangOpts().ObjC1 && CGM.getLangOpts().ObjCRuntime.hasTerminate()) name = "objc_terminate"; else name = "abort"; return CGM.CreateRuntimeFunction(FTy, name); } static llvm::Constant *getCatchallRethrowFn(CodeGenModule &CGM, StringRef Name) { llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, Name); } namespace { /// The exceptions personality for a function. struct EHPersonality { const char *PersonalityFn; // If this is non-null, this personality requires a non-standard // function for rethrowing an exception after a catchall cleanup. // This function must have prototype void(void*). const char *CatchallRethrowFn; static const EHPersonality &get(const LangOptions &Lang); static const EHPersonality GNU_C; static const EHPersonality GNU_C_SJLJ; static const EHPersonality GNU_ObjC; static const EHPersonality GNUstep_ObjC; static const EHPersonality GNU_ObjCXX; static const EHPersonality NeXT_ObjC; static const EHPersonality GNU_CPlusPlus; static const EHPersonality GNU_CPlusPlus_SJLJ; }; } const EHPersonality EHPersonality::GNU_C = { "__gcc_personality_v0", nullptr }; const EHPersonality EHPersonality::GNU_C_SJLJ = { "__gcc_personality_sj0", nullptr }; const EHPersonality EHPersonality::NeXT_ObjC = { "__objc_personality_v0", nullptr }; const EHPersonality EHPersonality::GNU_CPlusPlus = { "__gxx_personality_v0", nullptr }; const EHPersonality EHPersonality::GNU_CPlusPlus_SJLJ = { "__gxx_personality_sj0", nullptr }; const EHPersonality EHPersonality::GNU_ObjC = {"__gnu_objc_personality_v0", "objc_exception_throw"}; const EHPersonality EHPersonality::GNU_ObjCXX = { "__gnustep_objcxx_personality_v0", nullptr }; const EHPersonality EHPersonality::GNUstep_ObjC = { "__gnustep_objc_personality_v0", nullptr }; static const EHPersonality &getCPersonality(const LangOptions &L) { if (L.SjLjExceptions) return EHPersonality::GNU_C_SJLJ; return EHPersonality::GNU_C; } static const EHPersonality &getObjCPersonality(const LangOptions &L) { switch (L.ObjCRuntime.getKind()) { case ObjCRuntime::FragileMacOSX: return getCPersonality(L); case ObjCRuntime::MacOSX: case ObjCRuntime::iOS: return EHPersonality::NeXT_ObjC; case ObjCRuntime::GNUstep: if (L.ObjCRuntime.getVersion() >= VersionTuple(1, 7)) return EHPersonality::GNUstep_ObjC; // fallthrough case ObjCRuntime::GCC: case ObjCRuntime::ObjFW: return EHPersonality::GNU_ObjC; } llvm_unreachable("bad runtime kind"); } static const EHPersonality &getCXXPersonality(const LangOptions &L) { if (L.SjLjExceptions) return EHPersonality::GNU_CPlusPlus_SJLJ; else return EHPersonality::GNU_CPlusPlus; } /// Determines the personality function to use when both C++ /// and Objective-C exceptions are being caught. static const EHPersonality &getObjCXXPersonality(const LangOptions &L) { switch (L.ObjCRuntime.getKind()) { // The ObjC personality defers to the C++ personality for non-ObjC // handlers. Unlike the C++ case, we use the same personality // function on targets using (backend-driven) SJLJ EH. case ObjCRuntime::MacOSX: case ObjCRuntime::iOS: return EHPersonality::NeXT_ObjC; // In the fragile ABI, just use C++ exception handling and hope // they're not doing crazy exception mixing. case ObjCRuntime::FragileMacOSX: return getCXXPersonality(L); // The GCC runtime's personality function inherently doesn't support // mixed EH. Use the C++ personality just to avoid returning null. case ObjCRuntime::GCC: case ObjCRuntime::ObjFW: // XXX: this will change soon return EHPersonality::GNU_ObjC; case ObjCRuntime::GNUstep: return EHPersonality::GNU_ObjCXX; } llvm_unreachable("bad runtime kind"); } const EHPersonality &EHPersonality::get(const LangOptions &L) { if (L.CPlusPlus && L.ObjC1) return getObjCXXPersonality(L); else if (L.CPlusPlus) return getCXXPersonality(L); else if (L.ObjC1) return getObjCPersonality(L); else return getCPersonality(L); } static llvm::Constant *getPersonalityFn(CodeGenModule &CGM, const EHPersonality &Personality) { llvm::Constant *Fn = CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty, true), Personality.PersonalityFn); return Fn; } static llvm::Constant *getOpaquePersonalityFn(CodeGenModule &CGM, const EHPersonality &Personality) { llvm::Constant *Fn = getPersonalityFn(CGM, Personality); return llvm::ConstantExpr::getBitCast(Fn, CGM.Int8PtrTy); } /// Check whether a personality function could reasonably be swapped /// for a C++ personality function. static bool PersonalityHasOnlyCXXUses(llvm::Constant *Fn) { for (llvm::User *U : Fn->users()) { // Conditionally white-list bitcasts. if (llvm::ConstantExpr *CE = dyn_cast(U)) { if (CE->getOpcode() != llvm::Instruction::BitCast) return false; if (!PersonalityHasOnlyCXXUses(CE)) return false; continue; } // Otherwise, it has to be a landingpad instruction. llvm::LandingPadInst *LPI = dyn_cast(U); if (!LPI) return false; for (unsigned I = 0, E = LPI->getNumClauses(); I != E; ++I) { // Look for something that would've been returned by the ObjC // runtime's GetEHType() method. llvm::Value *Val = LPI->getClause(I)->stripPointerCasts(); if (LPI->isCatch(I)) { // Check if the catch value has the ObjC prefix. if (llvm::GlobalVariable *GV = dyn_cast(Val)) // ObjC EH selector entries are always global variables with // names starting like this. if (GV->getName().startswith("OBJC_EHTYPE")) return false; } else { // Check if any of the filter values have the ObjC prefix. llvm::Constant *CVal = cast(Val); for (llvm::User::op_iterator II = CVal->op_begin(), IE = CVal->op_end(); II != IE; ++II) { if (llvm::GlobalVariable *GV = cast((*II)->stripPointerCasts())) // ObjC EH selector entries are always global variables with // names starting like this. if (GV->getName().startswith("OBJC_EHTYPE")) return false; } } } } return true; } /// Try to use the C++ personality function in ObjC++. Not doing this /// can cause some incompatibilities with gcc, which is more /// aggressive about only using the ObjC++ personality in a function /// when it really needs it. void CodeGenModule::SimplifyPersonality() { // If we're not in ObjC++ -fexceptions, there's nothing to do. if (!LangOpts.CPlusPlus || !LangOpts.ObjC1 || !LangOpts.Exceptions) return; // Both the problem this endeavors to fix and the way the logic // above works is specific to the NeXT runtime. if (!LangOpts.ObjCRuntime.isNeXTFamily()) return; const EHPersonality &ObjCXX = EHPersonality::get(LangOpts); const EHPersonality &CXX = getCXXPersonality(LangOpts); if (&ObjCXX == &CXX) return; assert(std::strcmp(ObjCXX.PersonalityFn, CXX.PersonalityFn) != 0 && "Different EHPersonalities using the same personality function."); llvm::Function *Fn = getModule().getFunction(ObjCXX.PersonalityFn); // Nothing to do if it's unused. if (!Fn || Fn->use_empty()) return; // Can't do the optimization if it has non-C++ uses. if (!PersonalityHasOnlyCXXUses(Fn)) return; // Create the C++ personality function and kill off the old // function. llvm::Constant *CXXFn = getPersonalityFn(*this, CXX); // This can happen if the user is screwing with us. if (Fn->getType() != CXXFn->getType()) return; Fn->replaceAllUsesWith(CXXFn); Fn->eraseFromParent(); } /// Returns the value to inject into a selector to indicate the /// presence of a catch-all. static llvm::Constant *getCatchAllValue(CodeGenFunction &CGF) { // Possibly we should use @@llvm.eh.catch.all.value here. return llvm::ConstantPointerNull::get(CGF.Int8PtrTy); } namespace { /// A cleanup to free the exception object if its initialization /// throws. struct FreeException : EHScopeStack::Cleanup { llvm::Value *exn; FreeException(llvm::Value *exn) : exn(exn) {} void Emit(CodeGenFunction &CGF, Flags flags) override { CGF.EmitNounwindRuntimeCall(getFreeExceptionFn(CGF.CGM), exn); } }; } // Emits an exception expression into the given location. This // differs from EmitAnyExprToMem only in that, if a final copy-ctor // call is required, an exception within that copy ctor causes // std::terminate to be invoked. static void EmitAnyExprToExn(CodeGenFunction &CGF, const Expr *e, llvm::Value *addr) { // Make sure the exception object is cleaned up if there's an // exception during initialization. CGF.pushFullExprCleanup(EHCleanup, addr); EHScopeStack::stable_iterator cleanup = CGF.EHStack.stable_begin(); // __cxa_allocate_exception returns a void*; we need to cast this // to the appropriate type for the object. llvm::Type *ty = CGF.ConvertTypeForMem(e->getType())->getPointerTo(); llvm::Value *typedAddr = CGF.Builder.CreateBitCast(addr, ty); // FIXME: this isn't quite right! If there's a final unelided call // to a copy constructor, then according to [except.terminate]p1 we // must call std::terminate() if that constructor throws, because // technically that copy occurs after the exception expression is // evaluated but before the exception is caught. But the best way // to handle that is to teach EmitAggExpr to do the final copy // differently if it can't be elided. CGF.EmitAnyExprToMem(e, typedAddr, e->getType().getQualifiers(), /*IsInit*/ true); // Deactivate the cleanup block. CGF.DeactivateCleanupBlock(cleanup, cast(typedAddr)); } llvm::Value *CodeGenFunction::getExceptionSlot() { if (!ExceptionSlot) ExceptionSlot = CreateTempAlloca(Int8PtrTy, "exn.slot"); return ExceptionSlot; } llvm::Value *CodeGenFunction::getEHSelectorSlot() { if (!EHSelectorSlot) EHSelectorSlot = CreateTempAlloca(Int32Ty, "ehselector.slot"); return EHSelectorSlot; } llvm::Value *CodeGenFunction::getExceptionFromSlot() { return Builder.CreateLoad(getExceptionSlot(), "exn"); } llvm::Value *CodeGenFunction::getSelectorFromSlot() { return Builder.CreateLoad(getEHSelectorSlot(), "sel"); } void CodeGenFunction::EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint) { if (CGM.getTarget().getTriple().isWindowsMSVCEnvironment()) { ErrorUnsupported(E, "throw expression"); return; } if (!E->getSubExpr()) { EmitNoreturnRuntimeCallOrInvoke(getReThrowFn(CGM), ArrayRef()); // throw is an expression, and the expression emitters expect us // to leave ourselves at a valid insertion point. if (KeepInsertionPoint) EmitBlock(createBasicBlock("throw.cont")); return; } QualType ThrowType = E->getSubExpr()->getType(); if (ThrowType->isObjCObjectPointerType()) { const Stmt *ThrowStmt = E->getSubExpr(); const ObjCAtThrowStmt S(E->getExprLoc(), const_cast(ThrowStmt)); CGM.getObjCRuntime().EmitThrowStmt(*this, S, false); // This will clear insertion point which was not cleared in // call to EmitThrowStmt. if (KeepInsertionPoint) EmitBlock(createBasicBlock("throw.cont")); return; } // Now allocate the exception object. llvm::Type *SizeTy = ConvertType(getContext().getSizeType()); uint64_t TypeSize = getContext().getTypeSizeInChars(ThrowType).getQuantity(); llvm::Constant *AllocExceptionFn = getAllocateExceptionFn(CGM); llvm::CallInst *ExceptionPtr = EmitNounwindRuntimeCall(AllocExceptionFn, llvm::ConstantInt::get(SizeTy, TypeSize), "exception"); EmitAnyExprToExn(*this, E->getSubExpr(), ExceptionPtr); // Now throw the exception. llvm::Constant *TypeInfo = CGM.GetAddrOfRTTIDescriptor(ThrowType, /*ForEH=*/true); // The address of the destructor. If the exception type has a // trivial destructor (or isn't a record), we just pass null. llvm::Constant *Dtor = nullptr; if (const RecordType *RecordTy = ThrowType->getAs()) { CXXRecordDecl *Record = cast(RecordTy->getDecl()); if (!Record->hasTrivialDestructor()) { CXXDestructorDecl *DtorD = Record->getDestructor(); Dtor = CGM.GetAddrOfCXXDestructor(DtorD, Dtor_Complete); Dtor = llvm::ConstantExpr::getBitCast(Dtor, Int8PtrTy); } } if (!Dtor) Dtor = llvm::Constant::getNullValue(Int8PtrTy); llvm::Value *args[] = { ExceptionPtr, TypeInfo, Dtor }; EmitNoreturnRuntimeCallOrInvoke(getThrowFn(CGM), args); // throw is an expression, and the expression emitters expect us // to leave ourselves at a valid insertion point. if (KeepInsertionPoint) EmitBlock(createBasicBlock("throw.cont")); } void CodeGenFunction::EmitStartEHSpec(const Decl *D) { if (!CGM.getLangOpts().CXXExceptions) return; const FunctionDecl* FD = dyn_cast_or_null(D); if (!FD) { // Check if CapturedDecl is nothrow and create terminate scope for it. if (const CapturedDecl* CD = dyn_cast_or_null(D)) { if (CD->isNothrow()) EHStack.pushTerminate(); } return; } const FunctionProtoType *Proto = FD->getType()->getAs(); if (!Proto) return; ExceptionSpecificationType EST = Proto->getExceptionSpecType(); if (isNoexceptExceptionSpec(EST)) { if (Proto->getNoexceptSpec(getContext()) == FunctionProtoType::NR_Nothrow) { // noexcept functions are simple terminate scopes. EHStack.pushTerminate(); } } else if (EST == EST_Dynamic || EST == EST_DynamicNone) { unsigned NumExceptions = Proto->getNumExceptions(); EHFilterScope *Filter = EHStack.pushFilter(NumExceptions); for (unsigned I = 0; I != NumExceptions; ++I) { QualType Ty = Proto->getExceptionType(I); QualType ExceptType = Ty.getNonReferenceType().getUnqualifiedType(); llvm::Value *EHType = CGM.GetAddrOfRTTIDescriptor(ExceptType, /*ForEH=*/true); Filter->setFilter(I, EHType); } } } /// Emit the dispatch block for a filter scope if necessary. static void emitFilterDispatchBlock(CodeGenFunction &CGF, EHFilterScope &filterScope) { llvm::BasicBlock *dispatchBlock = filterScope.getCachedEHDispatchBlock(); if (!dispatchBlock) return; if (dispatchBlock->use_empty()) { delete dispatchBlock; return; } CGF.EmitBlockAfterUses(dispatchBlock); // If this isn't a catch-all filter, we need to check whether we got // here because the filter triggered. if (filterScope.getNumFilters()) { // Load the selector value. llvm::Value *selector = CGF.getSelectorFromSlot(); llvm::BasicBlock *unexpectedBB = CGF.createBasicBlock("ehspec.unexpected"); llvm::Value *zero = CGF.Builder.getInt32(0); llvm::Value *failsFilter = CGF.Builder.CreateICmpSLT(selector, zero, "ehspec.fails"); CGF.Builder.CreateCondBr(failsFilter, unexpectedBB, CGF.getEHResumeBlock(false)); CGF.EmitBlock(unexpectedBB); } // Call __cxa_call_unexpected. This doesn't need to be an invoke // because __cxa_call_unexpected magically filters exceptions // according to the last landing pad the exception was thrown // into. Seriously. llvm::Value *exn = CGF.getExceptionFromSlot(); CGF.EmitRuntimeCall(getUnexpectedFn(CGF.CGM), exn) ->setDoesNotReturn(); CGF.Builder.CreateUnreachable(); } void CodeGenFunction::EmitEndEHSpec(const Decl *D) { if (!CGM.getLangOpts().CXXExceptions) return; const FunctionDecl* FD = dyn_cast_or_null(D); if (!FD) { // Check if CapturedDecl is nothrow and pop terminate scope for it. if (const CapturedDecl* CD = dyn_cast_or_null(D)) { if (CD->isNothrow()) EHStack.popTerminate(); } return; } const FunctionProtoType *Proto = FD->getType()->getAs(); if (!Proto) return; ExceptionSpecificationType EST = Proto->getExceptionSpecType(); if (isNoexceptExceptionSpec(EST)) { if (Proto->getNoexceptSpec(getContext()) == FunctionProtoType::NR_Nothrow) { EHStack.popTerminate(); } } else if (EST == EST_Dynamic || EST == EST_DynamicNone) { EHFilterScope &filterScope = cast(*EHStack.begin()); emitFilterDispatchBlock(*this, filterScope); EHStack.popFilter(); } } void CodeGenFunction::EmitCXXTryStmt(const CXXTryStmt &S) { if (CGM.getTarget().getTriple().isWindowsMSVCEnvironment()) { ErrorUnsupported(&S, "try statement"); return; } EnterCXXTryStmt(S); EmitStmt(S.getTryBlock()); ExitCXXTryStmt(S); } void CodeGenFunction::EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) { unsigned NumHandlers = S.getNumHandlers(); EHCatchScope *CatchScope = EHStack.pushCatch(NumHandlers); for (unsigned I = 0; I != NumHandlers; ++I) { const CXXCatchStmt *C = S.getHandler(I); llvm::BasicBlock *Handler = createBasicBlock("catch"); if (C->getExceptionDecl()) { // FIXME: Dropping the reference type on the type into makes it // impossible to correctly implement catch-by-reference // semantics for pointers. Unfortunately, this is what all // existing compilers do, and it's not clear that the standard // personality routine is capable of doing this right. See C++ DR 388: // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#388 QualType CaughtType = C->getCaughtType(); CaughtType = CaughtType.getNonReferenceType().getUnqualifiedType(); llvm::Constant *TypeInfo = nullptr; if (CaughtType->isObjCObjectPointerType()) TypeInfo = CGM.getObjCRuntime().GetEHType(CaughtType); else TypeInfo = CGM.GetAddrOfRTTIDescriptor(CaughtType, /*ForEH=*/true); CatchScope->setHandler(I, TypeInfo, Handler); } else { // No exception decl indicates '...', a catch-all. CatchScope->setCatchAllHandler(I, Handler); } } } llvm::BasicBlock * CodeGenFunction::getEHDispatchBlock(EHScopeStack::stable_iterator si) { // The dispatch block for the end of the scope chain is a block that // just resumes unwinding. if (si == EHStack.stable_end()) return getEHResumeBlock(true); // Otherwise, we should look at the actual scope. EHScope &scope = *EHStack.find(si); llvm::BasicBlock *dispatchBlock = scope.getCachedEHDispatchBlock(); if (!dispatchBlock) { switch (scope.getKind()) { case EHScope::Catch: { // Apply a special case to a single catch-all. EHCatchScope &catchScope = cast(scope); if (catchScope.getNumHandlers() == 1 && catchScope.getHandler(0).isCatchAll()) { dispatchBlock = catchScope.getHandler(0).Block; // Otherwise, make a dispatch block. } else { dispatchBlock = createBasicBlock("catch.dispatch"); } break; } case EHScope::Cleanup: dispatchBlock = createBasicBlock("ehcleanup"); break; case EHScope::Filter: dispatchBlock = createBasicBlock("filter.dispatch"); break; case EHScope::Terminate: dispatchBlock = getTerminateHandler(); break; } scope.setCachedEHDispatchBlock(dispatchBlock); } return dispatchBlock; } /// Check whether this is a non-EH scope, i.e. a scope which doesn't /// affect exception handling. Currently, the only non-EH scopes are /// normal-only cleanup scopes. static bool isNonEHScope(const EHScope &S) { switch (S.getKind()) { case EHScope::Cleanup: return !cast(S).isEHCleanup(); case EHScope::Filter: case EHScope::Catch: case EHScope::Terminate: return false; } llvm_unreachable("Invalid EHScope Kind!"); } llvm::BasicBlock *CodeGenFunction::getInvokeDestImpl() { assert(EHStack.requiresLandingPad()); assert(!EHStack.empty()); if (!CGM.getLangOpts().Exceptions) return nullptr; // Check the innermost scope for a cached landing pad. If this is // a non-EH cleanup, we'll check enclosing scopes in EmitLandingPad. llvm::BasicBlock *LP = EHStack.begin()->getCachedLandingPad(); if (LP) return LP; // Build the landing pad for this scope. LP = EmitLandingPad(); assert(LP); // Cache the landing pad on the innermost scope. If this is a // non-EH scope, cache the landing pad on the enclosing scope, too. for (EHScopeStack::iterator ir = EHStack.begin(); true; ++ir) { ir->setCachedLandingPad(LP); if (!isNonEHScope(*ir)) break; } return LP; } llvm::BasicBlock *CodeGenFunction::EmitLandingPad() { assert(EHStack.requiresLandingPad()); EHScope &innermostEHScope = *EHStack.find(EHStack.getInnermostEHScope()); switch (innermostEHScope.getKind()) { case EHScope::Terminate: return getTerminateLandingPad(); case EHScope::Catch: case EHScope::Cleanup: case EHScope::Filter: if (llvm::BasicBlock *lpad = innermostEHScope.getCachedLandingPad()) return lpad; } // Save the current IR generation state. CGBuilderTy::InsertPoint savedIP = Builder.saveAndClearIP(); SaveAndRestoreLocation AutoRestoreLocation(*this, Builder); if (CGDebugInfo *DI = getDebugInfo()) DI->EmitLocation(Builder, CurEHLocation); const EHPersonality &personality = EHPersonality::get(getLangOpts()); // Create and configure the landing pad. llvm::BasicBlock *lpad = createBasicBlock("lpad"); EmitBlock(lpad); llvm::LandingPadInst *LPadInst = Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty, NULL), getOpaquePersonalityFn(CGM, personality), 0); llvm::Value *LPadExn = Builder.CreateExtractValue(LPadInst, 0); Builder.CreateStore(LPadExn, getExceptionSlot()); llvm::Value *LPadSel = Builder.CreateExtractValue(LPadInst, 1); Builder.CreateStore(LPadSel, getEHSelectorSlot()); // Save the exception pointer. It's safe to use a single exception // pointer per function because EH cleanups can never have nested // try/catches. // Build the landingpad instruction. // Accumulate all the handlers in scope. bool hasCatchAll = false; bool hasCleanup = false; bool hasFilter = false; SmallVector filterTypes; llvm::SmallPtrSet catchTypes; for (EHScopeStack::iterator I = EHStack.begin(), E = EHStack.end(); I != E; ++I) { switch (I->getKind()) { case EHScope::Cleanup: // If we have a cleanup, remember that. hasCleanup = (hasCleanup || cast(*I).isEHCleanup()); continue; case EHScope::Filter: { assert(I.next() == EHStack.end() && "EH filter is not end of EH stack"); assert(!hasCatchAll && "EH filter reached after catch-all"); // Filter scopes get added to the landingpad in weird ways. EHFilterScope &filter = cast(*I); hasFilter = true; // Add all the filter values. for (unsigned i = 0, e = filter.getNumFilters(); i != e; ++i) filterTypes.push_back(filter.getFilter(i)); goto done; } case EHScope::Terminate: // Terminate scopes are basically catch-alls. assert(!hasCatchAll); hasCatchAll = true; goto done; case EHScope::Catch: break; } EHCatchScope &catchScope = cast(*I); for (unsigned hi = 0, he = catchScope.getNumHandlers(); hi != he; ++hi) { EHCatchScope::Handler handler = catchScope.getHandler(hi); // If this is a catch-all, register that and abort. if (!handler.Type) { assert(!hasCatchAll); hasCatchAll = true; goto done; } // Check whether we already have a handler for this type. if (catchTypes.insert(handler.Type)) // If not, add it directly to the landingpad. LPadInst->addClause(handler.Type); } } done: // If we have a catch-all, add null to the landingpad. assert(!(hasCatchAll && hasFilter)); if (hasCatchAll) { LPadInst->addClause(getCatchAllValue(*this)); // If we have an EH filter, we need to add those handlers in the // right place in the landingpad, which is to say, at the end. } else if (hasFilter) { // Create a filter expression: a constant array indicating which filter // types there are. The personality routine only lands here if the filter // doesn't match. SmallVector Filters; llvm::ArrayType *AType = llvm::ArrayType::get(!filterTypes.empty() ? filterTypes[0]->getType() : Int8PtrTy, filterTypes.size()); for (unsigned i = 0, e = filterTypes.size(); i != e; ++i) Filters.push_back(cast(filterTypes[i])); llvm::Constant *FilterArray = llvm::ConstantArray::get(AType, Filters); LPadInst->addClause(FilterArray); // Also check whether we need a cleanup. if (hasCleanup) LPadInst->setCleanup(true); // Otherwise, signal that we at least have cleanups. } else if (hasCleanup) { LPadInst->setCleanup(true); } assert((LPadInst->getNumClauses() > 0 || LPadInst->isCleanup()) && "landingpad instruction has no clauses!"); // Tell the backend how to generate the landing pad. Builder.CreateBr(getEHDispatchBlock(EHStack.getInnermostEHScope())); // Restore the old IR generation state. Builder.restoreIP(savedIP); return lpad; } namespace { /// A cleanup to call __cxa_end_catch. In many cases, the caught /// exception type lets us state definitively that the thrown exception /// type does not have a destructor. In particular: /// - Catch-alls tell us nothing, so we have to conservatively /// assume that the thrown exception might have a destructor. /// - Catches by reference behave according to their base types. /// - Catches of non-record types will only trigger for exceptions /// of non-record types, which never have destructors. /// - Catches of record types can trigger for arbitrary subclasses /// of the caught type, so we have to assume the actual thrown /// exception type might have a throwing destructor, even if the /// caught type's destructor is trivial or nothrow. struct CallEndCatch : EHScopeStack::Cleanup { CallEndCatch(bool MightThrow) : MightThrow(MightThrow) {} bool MightThrow; void Emit(CodeGenFunction &CGF, Flags flags) override { if (!MightThrow) { CGF.EmitNounwindRuntimeCall(getEndCatchFn(CGF.CGM)); return; } CGF.EmitRuntimeCallOrInvoke(getEndCatchFn(CGF.CGM)); } }; } /// Emits a call to __cxa_begin_catch and enters a cleanup to call /// __cxa_end_catch. /// /// \param EndMightThrow - true if __cxa_end_catch might throw static llvm::Value *CallBeginCatch(CodeGenFunction &CGF, llvm::Value *Exn, bool EndMightThrow) { llvm::CallInst *call = CGF.EmitNounwindRuntimeCall(getBeginCatchFn(CGF.CGM), Exn); CGF.EHStack.pushCleanup(NormalAndEHCleanup, EndMightThrow); return call; } /// A "special initializer" callback for initializing a catch /// parameter during catch initialization. static void InitCatchParam(CodeGenFunction &CGF, const VarDecl &CatchParam, llvm::Value *ParamAddr, SourceLocation Loc) { // Load the exception from where the landing pad saved it. llvm::Value *Exn = CGF.getExceptionFromSlot(); CanQualType CatchType = CGF.CGM.getContext().getCanonicalType(CatchParam.getType()); llvm::Type *LLVMCatchTy = CGF.ConvertTypeForMem(CatchType); // If we're catching by reference, we can just cast the object // pointer to the appropriate pointer. if (isa(CatchType)) { QualType CaughtType = cast(CatchType)->getPointeeType(); bool EndCatchMightThrow = CaughtType->isRecordType(); // __cxa_begin_catch returns the adjusted object pointer. llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, EndCatchMightThrow); // We have no way to tell the personality function that we're // catching by reference, so if we're catching a pointer, // __cxa_begin_catch will actually return that pointer by value. if (const PointerType *PT = dyn_cast(CaughtType)) { QualType PointeeType = PT->getPointeeType(); // When catching by reference, generally we should just ignore // this by-value pointer and use the exception object instead. if (!PointeeType->isRecordType()) { // Exn points to the struct _Unwind_Exception header, which // we have to skip past in order to reach the exception data. unsigned HeaderSize = CGF.CGM.getTargetCodeGenInfo().getSizeOfUnwindException(); AdjustedExn = CGF.Builder.CreateConstGEP1_32(Exn, HeaderSize); // However, if we're catching a pointer-to-record type that won't // work, because the personality function might have adjusted // the pointer. There's actually no way for us to fully satisfy // the language/ABI contract here: we can't use Exn because it // might have the wrong adjustment, but we can't use the by-value // pointer because it's off by a level of abstraction. // // The current solution is to dump the adjusted pointer into an // alloca, which breaks language semantics (because changing the // pointer doesn't change the exception) but at least works. // The better solution would be to filter out non-exact matches // and rethrow them, but this is tricky because the rethrow // really needs to be catchable by other sites at this landing // pad. The best solution is to fix the personality function. } else { // Pull the pointer for the reference type off. llvm::Type *PtrTy = cast(LLVMCatchTy)->getElementType(); // Create the temporary and write the adjusted pointer into it. llvm::Value *ExnPtrTmp = CGF.CreateTempAlloca(PtrTy, "exn.byref.tmp"); llvm::Value *Casted = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy); CGF.Builder.CreateStore(Casted, ExnPtrTmp); // Bind the reference to the temporary. AdjustedExn = ExnPtrTmp; } } llvm::Value *ExnCast = CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.byref"); CGF.Builder.CreateStore(ExnCast, ParamAddr); return; } // Scalars and complexes. TypeEvaluationKind TEK = CGF.getEvaluationKind(CatchType); if (TEK != TEK_Aggregate) { llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, false); // If the catch type is a pointer type, __cxa_begin_catch returns // the pointer by value. if (CatchType->hasPointerRepresentation()) { llvm::Value *CastExn = CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.casted"); switch (CatchType.getQualifiers().getObjCLifetime()) { case Qualifiers::OCL_Strong: CastExn = CGF.EmitARCRetainNonBlock(CastExn); // fallthrough case Qualifiers::OCL_None: case Qualifiers::OCL_ExplicitNone: case Qualifiers::OCL_Autoreleasing: CGF.Builder.CreateStore(CastExn, ParamAddr); return; case Qualifiers::OCL_Weak: CGF.EmitARCInitWeak(ParamAddr, CastExn); return; } llvm_unreachable("bad ownership qualifier!"); } // Otherwise, it returns a pointer into the exception object. llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok llvm::Value *Cast = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy); LValue srcLV = CGF.MakeNaturalAlignAddrLValue(Cast, CatchType); LValue destLV = CGF.MakeAddrLValue(ParamAddr, CatchType, CGF.getContext().getDeclAlign(&CatchParam)); switch (TEK) { case TEK_Complex: CGF.EmitStoreOfComplex(CGF.EmitLoadOfComplex(srcLV, Loc), destLV, /*init*/ true); return; case TEK_Scalar: { llvm::Value *ExnLoad = CGF.EmitLoadOfScalar(srcLV, Loc); CGF.EmitStoreOfScalar(ExnLoad, destLV, /*init*/ true); return; } case TEK_Aggregate: llvm_unreachable("evaluation kind filtered out!"); } llvm_unreachable("bad evaluation kind"); } assert(isa(CatchType) && "unexpected catch type!"); llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok // Check for a copy expression. If we don't have a copy expression, // that means a trivial copy is okay. const Expr *copyExpr = CatchParam.getInit(); if (!copyExpr) { llvm::Value *rawAdjustedExn = CallBeginCatch(CGF, Exn, true); llvm::Value *adjustedExn = CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy); CGF.EmitAggregateCopy(ParamAddr, adjustedExn, CatchType); return; } // We have to call __cxa_get_exception_ptr to get the adjusted // pointer before copying. llvm::CallInst *rawAdjustedExn = CGF.EmitNounwindRuntimeCall(getGetExceptionPtrFn(CGF.CGM), Exn); // Cast that to the appropriate type. llvm::Value *adjustedExn = CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy); // The copy expression is defined in terms of an OpaqueValueExpr. // Find it and map it to the adjusted expression. CodeGenFunction::OpaqueValueMapping opaque(CGF, OpaqueValueExpr::findInCopyConstruct(copyExpr), CGF.MakeAddrLValue(adjustedExn, CatchParam.getType())); // Call the copy ctor in a terminate scope. CGF.EHStack.pushTerminate(); // Perform the copy construction. CharUnits Alignment = CGF.getContext().getDeclAlign(&CatchParam); CGF.EmitAggExpr(copyExpr, AggValueSlot::forAddr(ParamAddr, Alignment, Qualifiers(), AggValueSlot::IsNotDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased)); // Leave the terminate scope. CGF.EHStack.popTerminate(); // Undo the opaque value mapping. opaque.pop(); // Finally we can call __cxa_begin_catch. CallBeginCatch(CGF, Exn, true); } /// Begins a catch statement by initializing the catch variable and /// calling __cxa_begin_catch. static void BeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *S) { // We have to be very careful with the ordering of cleanups here: // C++ [except.throw]p4: // The destruction [of the exception temporary] occurs // immediately after the destruction of the object declared in // the exception-declaration in the handler. // // So the precise ordering is: // 1. Construct catch variable. // 2. __cxa_begin_catch // 3. Enter __cxa_end_catch cleanup // 4. Enter dtor cleanup // // We do this by using a slightly abnormal initialization process. // Delegation sequence: // - ExitCXXTryStmt opens a RunCleanupsScope // - EmitAutoVarAlloca creates the variable and debug info // - InitCatchParam initializes the variable from the exception // - CallBeginCatch calls __cxa_begin_catch // - CallBeginCatch enters the __cxa_end_catch cleanup // - EmitAutoVarCleanups enters the variable destructor cleanup // - EmitCXXTryStmt emits the code for the catch body // - EmitCXXTryStmt close the RunCleanupsScope VarDecl *CatchParam = S->getExceptionDecl(); if (!CatchParam) { llvm::Value *Exn = CGF.getExceptionFromSlot(); CallBeginCatch(CGF, Exn, true); return; } // Emit the local. CodeGenFunction::AutoVarEmission var = CGF.EmitAutoVarAlloca(*CatchParam); InitCatchParam(CGF, *CatchParam, var.getObjectAddress(CGF), S->getLocStart()); CGF.EmitAutoVarCleanups(var); } /// Emit the structure of the dispatch block for the given catch scope. /// It is an invariant that the dispatch block already exists. static void emitCatchDispatchBlock(CodeGenFunction &CGF, EHCatchScope &catchScope) { llvm::BasicBlock *dispatchBlock = catchScope.getCachedEHDispatchBlock(); assert(dispatchBlock); // If there's only a single catch-all, getEHDispatchBlock returned // that catch-all as the dispatch block. if (catchScope.getNumHandlers() == 1 && catchScope.getHandler(0).isCatchAll()) { assert(dispatchBlock == catchScope.getHandler(0).Block); return; } CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveIP(); CGF.EmitBlockAfterUses(dispatchBlock); // Select the right handler. llvm::Value *llvm_eh_typeid_for = CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for); // Load the selector value. llvm::Value *selector = CGF.getSelectorFromSlot(); // Test against each of the exception types we claim to catch. for (unsigned i = 0, e = catchScope.getNumHandlers(); ; ++i) { assert(i < e && "ran off end of handlers!"); const EHCatchScope::Handler &handler = catchScope.getHandler(i); llvm::Value *typeValue = handler.Type; assert(typeValue && "fell into catch-all case!"); typeValue = CGF.Builder.CreateBitCast(typeValue, CGF.Int8PtrTy); // Figure out the next block. bool nextIsEnd; llvm::BasicBlock *nextBlock; // If this is the last handler, we're at the end, and the next // block is the block for the enclosing EH scope. if (i + 1 == e) { nextBlock = CGF.getEHDispatchBlock(catchScope.getEnclosingEHScope()); nextIsEnd = true; // If the next handler is a catch-all, we're at the end, and the // next block is that handler. } else if (catchScope.getHandler(i+1).isCatchAll()) { nextBlock = catchScope.getHandler(i+1).Block; nextIsEnd = true; // Otherwise, we're not at the end and we need a new block. } else { nextBlock = CGF.createBasicBlock("catch.fallthrough"); nextIsEnd = false; } // Figure out the catch type's index in the LSDA's type table. llvm::CallInst *typeIndex = CGF.Builder.CreateCall(llvm_eh_typeid_for, typeValue); typeIndex->setDoesNotThrow(); llvm::Value *matchesTypeIndex = CGF.Builder.CreateICmpEQ(selector, typeIndex, "matches"); CGF.Builder.CreateCondBr(matchesTypeIndex, handler.Block, nextBlock); // If the next handler is a catch-all, we're completely done. if (nextIsEnd) { CGF.Builder.restoreIP(savedIP); return; } // Otherwise we need to emit and continue at that block. CGF.EmitBlock(nextBlock); } } void CodeGenFunction::popCatchScope() { EHCatchScope &catchScope = cast(*EHStack.begin()); if (catchScope.hasEHBranches()) emitCatchDispatchBlock(*this, catchScope); EHStack.popCatch(); } void CodeGenFunction::ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) { unsigned NumHandlers = S.getNumHandlers(); EHCatchScope &CatchScope = cast(*EHStack.begin()); assert(CatchScope.getNumHandlers() == NumHandlers); // If the catch was not required, bail out now. if (!CatchScope.hasEHBranches()) { CatchScope.clearHandlerBlocks(); EHStack.popCatch(); return; } // Emit the structure of the EH dispatch for this catch. emitCatchDispatchBlock(*this, CatchScope); // Copy the handler blocks off before we pop the EH stack. Emitting // the handlers might scribble on this memory. SmallVector Handlers(NumHandlers); memcpy(Handlers.data(), CatchScope.begin(), NumHandlers * sizeof(EHCatchScope::Handler)); EHStack.popCatch(); // The fall-through block. llvm::BasicBlock *ContBB = createBasicBlock("try.cont"); // We just emitted the body of the try; jump to the continue block. if (HaveInsertPoint()) Builder.CreateBr(ContBB); // Determine if we need an implicit rethrow for all these catch handlers; // see the comment below. bool doImplicitRethrow = false; if (IsFnTryBlock) doImplicitRethrow = isa(CurCodeDecl) || isa(CurCodeDecl); // Perversely, we emit the handlers backwards precisely because we // want them to appear in source order. In all of these cases, the // catch block will have exactly one predecessor, which will be a // particular block in the catch dispatch. However, in the case of // a catch-all, one of the dispatch blocks will branch to two // different handlers, and EmitBlockAfterUses will cause the second // handler to be moved before the first. for (unsigned I = NumHandlers; I != 0; --I) { llvm::BasicBlock *CatchBlock = Handlers[I-1].Block; EmitBlockAfterUses(CatchBlock); // Catch the exception if this isn't a catch-all. const CXXCatchStmt *C = S.getHandler(I-1); // Enter a cleanup scope, including the catch variable and the // end-catch. RunCleanupsScope CatchScope(*this); // Initialize the catch variable and set up the cleanups. BeginCatch(*this, C); // Emit the PGO counter increment. RegionCounter CatchCnt = getPGORegionCounter(C); CatchCnt.beginRegion(Builder); // Perform the body of the catch. EmitStmt(C->getHandlerBlock()); // [except.handle]p11: // The currently handled exception is rethrown if control // reaches the end of a handler of the function-try-block of a // constructor or destructor. // It is important that we only do this on fallthrough and not on // return. Note that it's illegal to put a return in a // constructor function-try-block's catch handler (p14), so this // really only applies to destructors. if (doImplicitRethrow && HaveInsertPoint()) { EmitRuntimeCallOrInvoke(getReThrowFn(CGM)); Builder.CreateUnreachable(); Builder.ClearInsertionPoint(); } // Fall out through the catch cleanups. CatchScope.ForceCleanup(); // Branch out of the try. if (HaveInsertPoint()) Builder.CreateBr(ContBB); } RegionCounter ContCnt = getPGORegionCounter(&S); EmitBlock(ContBB); ContCnt.beginRegion(Builder); } namespace { struct CallEndCatchForFinally : EHScopeStack::Cleanup { llvm::Value *ForEHVar; llvm::Value *EndCatchFn; CallEndCatchForFinally(llvm::Value *ForEHVar, llvm::Value *EndCatchFn) : ForEHVar(ForEHVar), EndCatchFn(EndCatchFn) {} void Emit(CodeGenFunction &CGF, Flags flags) override { llvm::BasicBlock *EndCatchBB = CGF.createBasicBlock("finally.endcatch"); llvm::BasicBlock *CleanupContBB = CGF.createBasicBlock("finally.cleanup.cont"); llvm::Value *ShouldEndCatch = CGF.Builder.CreateLoad(ForEHVar, "finally.endcatch"); CGF.Builder.CreateCondBr(ShouldEndCatch, EndCatchBB, CleanupContBB); CGF.EmitBlock(EndCatchBB); CGF.EmitRuntimeCallOrInvoke(EndCatchFn); // catch-all, so might throw CGF.EmitBlock(CleanupContBB); } }; struct PerformFinally : EHScopeStack::Cleanup { const Stmt *Body; llvm::Value *ForEHVar; llvm::Value *EndCatchFn; llvm::Value *RethrowFn; llvm::Value *SavedExnVar; PerformFinally(const Stmt *Body, llvm::Value *ForEHVar, llvm::Value *EndCatchFn, llvm::Value *RethrowFn, llvm::Value *SavedExnVar) : Body(Body), ForEHVar(ForEHVar), EndCatchFn(EndCatchFn), RethrowFn(RethrowFn), SavedExnVar(SavedExnVar) {} void Emit(CodeGenFunction &CGF, Flags flags) override { // Enter a cleanup to call the end-catch function if one was provided. if (EndCatchFn) CGF.EHStack.pushCleanup(NormalAndEHCleanup, ForEHVar, EndCatchFn); // Save the current cleanup destination in case there are // cleanups in the finally block. llvm::Value *SavedCleanupDest = CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot(), "cleanup.dest.saved"); // Emit the finally block. CGF.EmitStmt(Body); // If the end of the finally is reachable, check whether this was // for EH. If so, rethrow. if (CGF.HaveInsertPoint()) { llvm::BasicBlock *RethrowBB = CGF.createBasicBlock("finally.rethrow"); llvm::BasicBlock *ContBB = CGF.createBasicBlock("finally.cont"); llvm::Value *ShouldRethrow = CGF.Builder.CreateLoad(ForEHVar, "finally.shouldthrow"); CGF.Builder.CreateCondBr(ShouldRethrow, RethrowBB, ContBB); CGF.EmitBlock(RethrowBB); if (SavedExnVar) { CGF.EmitRuntimeCallOrInvoke(RethrowFn, CGF.Builder.CreateLoad(SavedExnVar)); } else { CGF.EmitRuntimeCallOrInvoke(RethrowFn); } CGF.Builder.CreateUnreachable(); CGF.EmitBlock(ContBB); // Restore the cleanup destination. CGF.Builder.CreateStore(SavedCleanupDest, CGF.getNormalCleanupDestSlot()); } // Leave the end-catch cleanup. As an optimization, pretend that // the fallthrough path was inaccessible; we've dynamically proven // that we're not in the EH case along that path. if (EndCatchFn) { CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP(); CGF.PopCleanupBlock(); CGF.Builder.restoreIP(SavedIP); } // Now make sure we actually have an insertion point or the // cleanup gods will hate us. CGF.EnsureInsertPoint(); } }; } /// Enters a finally block for an implementation using zero-cost /// exceptions. This is mostly general, but hard-codes some /// language/ABI-specific behavior in the catch-all sections. void CodeGenFunction::FinallyInfo::enter(CodeGenFunction &CGF, const Stmt *body, llvm::Constant *beginCatchFn, llvm::Constant *endCatchFn, llvm::Constant *rethrowFn) { assert((beginCatchFn != nullptr) == (endCatchFn != nullptr) && "begin/end catch functions not paired"); assert(rethrowFn && "rethrow function is required"); BeginCatchFn = beginCatchFn; // The rethrow function has one of the following two types: // void (*)() // void (*)(void*) // In the latter case we need to pass it the exception object. // But we can't use the exception slot because the @@finally might // have a landing pad (which would overwrite the exception slot). llvm::FunctionType *rethrowFnTy = cast( cast(rethrowFn->getType())->getElementType()); SavedExnVar = nullptr; if (rethrowFnTy->getNumParams()) SavedExnVar = CGF.CreateTempAlloca(CGF.Int8PtrTy, "finally.exn"); // A finally block is a statement which must be executed on any edge // out of a given scope. Unlike a cleanup, the finally block may // contain arbitrary control flow leading out of itself. In // addition, finally blocks should always be executed, even if there // are no catch handlers higher on the stack. Therefore, we // surround the protected scope with a combination of a normal // cleanup (to catch attempts to break out of the block via normal // control flow) and an EH catch-all (semantically "outside" any try // statement to which the finally block might have been attached). // The finally block itself is generated in the context of a cleanup // which conditionally leaves the catch-all. // Jump destination for performing the finally block on an exception // edge. We'll never actually reach this block, so unreachable is // fine. RethrowDest = CGF.getJumpDestInCurrentScope(CGF.getUnreachableBlock()); // Whether the finally block is being executed for EH purposes. ForEHVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), "finally.for-eh"); CGF.Builder.CreateStore(CGF.Builder.getFalse(), ForEHVar); // Enter a normal cleanup which will perform the @@finally block. CGF.EHStack.pushCleanup(NormalCleanup, body, ForEHVar, endCatchFn, rethrowFn, SavedExnVar); // Enter a catch-all scope. llvm::BasicBlock *catchBB = CGF.createBasicBlock("finally.catchall"); EHCatchScope *catchScope = CGF.EHStack.pushCatch(1); catchScope->setCatchAllHandler(0, catchBB); } void CodeGenFunction::FinallyInfo::exit(CodeGenFunction &CGF) { // Leave the finally catch-all. EHCatchScope &catchScope = cast(*CGF.EHStack.begin()); llvm::BasicBlock *catchBB = catchScope.getHandler(0).Block; CGF.popCatchScope(); // If there are any references to the catch-all block, emit it. if (catchBB->use_empty()) { delete catchBB; } else { CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveAndClearIP(); CGF.EmitBlock(catchBB); llvm::Value *exn = nullptr; // If there's a begin-catch function, call it. if (BeginCatchFn) { exn = CGF.getExceptionFromSlot(); CGF.EmitNounwindRuntimeCall(BeginCatchFn, exn); } // If we need to remember the exception pointer to rethrow later, do so. if (SavedExnVar) { if (!exn) exn = CGF.getExceptionFromSlot(); CGF.Builder.CreateStore(exn, SavedExnVar); } // Tell the cleanups in the finally block that we're do this for EH. CGF.Builder.CreateStore(CGF.Builder.getTrue(), ForEHVar); // Thread a jump through the finally cleanup. CGF.EmitBranchThroughCleanup(RethrowDest); CGF.Builder.restoreIP(savedIP); } // Finally, leave the @@finally cleanup. CGF.PopCleanupBlock(); } /// In a terminate landing pad, should we use __clang__call_terminate /// or just a naked call to std::terminate? /// /// __clang_call_terminate calls __cxa_begin_catch, which then allows /// std::terminate to usefully report something about the /// violating exception. static bool useClangCallTerminate(CodeGenModule &CGM) { // Only do this for Itanium-family ABIs in C++ mode. return (CGM.getLangOpts().CPlusPlus && CGM.getTarget().getCXXABI().isItaniumFamily()); } /// Get or define the following function: /// void @@__clang_call_terminate(i8* %exn) nounwind noreturn /// This code is used only in C++. static llvm::Constant *getClangCallTerminateFn(CodeGenModule &CGM) { llvm::FunctionType *fnTy = llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); llvm::Constant *fnRef = CGM.CreateRuntimeFunction(fnTy, "__clang_call_terminate"); llvm::Function *fn = dyn_cast(fnRef); if (fn && fn->empty()) { fn->setDoesNotThrow(); fn->setDoesNotReturn(); // What we really want is to massively penalize inlining without // forbidding it completely. The difference between that and // 'noinline' is negligible. fn->addFnAttr(llvm::Attribute::NoInline); // Allow this function to be shared across translation units, but // we don't want it to turn into an exported symbol. fn->setLinkage(llvm::Function::LinkOnceODRLinkage); fn->setVisibility(llvm::Function::HiddenVisibility); // Set up the function. llvm::BasicBlock *entry = llvm::BasicBlock::Create(CGM.getLLVMContext(), "", fn); CGBuilderTy builder(entry); // Pull the exception pointer out of the parameter list. llvm::Value *exn = &*fn->arg_begin(); // Call __cxa_begin_catch(exn). llvm::CallInst *catchCall = builder.CreateCall(getBeginCatchFn(CGM), exn); catchCall->setDoesNotThrow(); catchCall->setCallingConv(CGM.getRuntimeCC()); // Call std::terminate(). llvm::CallInst *termCall = builder.CreateCall(getTerminateFn(CGM)); termCall->setDoesNotThrow(); termCall->setDoesNotReturn(); termCall->setCallingConv(CGM.getRuntimeCC()); // std::terminate cannot return. builder.CreateUnreachable(); } return fnRef; } llvm::BasicBlock *CodeGenFunction::getTerminateLandingPad() { if (TerminateLandingPad) return TerminateLandingPad; CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); // This will get inserted at the end of the function. TerminateLandingPad = createBasicBlock("terminate.lpad"); Builder.SetInsertPoint(TerminateLandingPad); // Tell the backend that this is a landing pad. const EHPersonality &Personality = EHPersonality::get(CGM.getLangOpts()); llvm::LandingPadInst *LPadInst = Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty, NULL), getOpaquePersonalityFn(CGM, Personality), 0); LPadInst->addClause(getCatchAllValue(*this)); llvm::CallInst *terminateCall; if (useClangCallTerminate(CGM)) { // Extract out the exception pointer. llvm::Value *exn = Builder.CreateExtractValue(LPadInst, 0); terminateCall = EmitNounwindRuntimeCall(getClangCallTerminateFn(CGM), exn); } else { terminateCall = EmitNounwindRuntimeCall(getTerminateFn(CGM)); } terminateCall->setDoesNotReturn(); Builder.CreateUnreachable(); // Restore the saved insertion state. Builder.restoreIP(SavedIP); return TerminateLandingPad; } llvm::BasicBlock *CodeGenFunction::getTerminateHandler() { if (TerminateHandler) return TerminateHandler; CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); // Set up the terminate handler. This block is inserted at the very // end of the function by FinishFunction. TerminateHandler = createBasicBlock("terminate.handler"); Builder.SetInsertPoint(TerminateHandler); llvm::CallInst *terminateCall; if (useClangCallTerminate(CGM)) { // Load the exception pointer. llvm::Value *exn = getExceptionFromSlot(); terminateCall = EmitNounwindRuntimeCall(getClangCallTerminateFn(CGM), exn); } else { terminateCall = EmitNounwindRuntimeCall(getTerminateFn(CGM)); } terminateCall->setDoesNotReturn(); Builder.CreateUnreachable(); // Restore the saved insertion state. Builder.restoreIP(SavedIP); return TerminateHandler; } llvm::BasicBlock *CodeGenFunction::getEHResumeBlock(bool isCleanup) { if (EHResumeBlock) return EHResumeBlock; CGBuilderTy::InsertPoint SavedIP = Builder.saveIP(); // We emit a jump to a notional label at the outermost unwind state. EHResumeBlock = createBasicBlock("eh.resume"); Builder.SetInsertPoint(EHResumeBlock); const EHPersonality &Personality = EHPersonality::get(CGM.getLangOpts()); // This can always be a call because we necessarily didn't find // anything on the EH stack which needs our help. const char *RethrowName = Personality.CatchallRethrowFn; if (RethrowName != nullptr && !isCleanup) { EmitRuntimeCall(getCatchallRethrowFn(CGM, RethrowName), getExceptionFromSlot()) ->setDoesNotReturn(); Builder.CreateUnreachable(); Builder.restoreIP(SavedIP); return EHResumeBlock; } // Recreate the landingpad's return value for the 'resume' instruction. llvm::Value *Exn = getExceptionFromSlot(); llvm::Value *Sel = getSelectorFromSlot(); llvm::Type *LPadType = llvm::StructType::get(Exn->getType(), Sel->getType(), NULL); llvm::Value *LPadVal = llvm::UndefValue::get(LPadType); LPadVal = Builder.CreateInsertValue(LPadVal, Exn, 0, "lpad.val"); LPadVal = Builder.CreateInsertValue(LPadVal, Sel, 1, "lpad.val"); Builder.CreateResume(LPadVal); Builder.restoreIP(SavedIP); return EHResumeBlock; } void CodeGenFunction::EmitSEHTryStmt(const SEHTryStmt &S) { CGM.ErrorUnsupported(&S, "SEH __try"); } void CodeGenFunction::EmitSEHLeaveStmt(const SEHLeaveStmt &S) { CGM.ErrorUnsupported(&S, "SEH __leave"); } @ 1.1.1.3.4.1 log @file CGException.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:26 +0000 @ text @d1 1707 @ 1.1.1.3.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 1707 //===--- CGException.cpp - Emit LLVM Code for C++ exceptions --------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This contains code dealing with C++ exception related code generation. // //===----------------------------------------------------------------------===// #include "CodeGenFunction.h" #include "CGCleanup.h" #include "CGObjCRuntime.h" #include "TargetInfo.h" #include "clang/AST/StmtCXX.h" #include "clang/AST/StmtObjC.h" #include "llvm/IR/Intrinsics.h" #include "llvm/Support/CallSite.h" using namespace clang; using namespace CodeGen; static llvm::Constant *getAllocateExceptionFn(CodeGenModule &CGM) { // void *__cxa_allocate_exception(size_t thrown_size); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.Int8PtrTy, CGM.SizeTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_allocate_exception"); } static llvm::Constant *getFreeExceptionFn(CodeGenModule &CGM) { // void __cxa_free_exception(void *thrown_exception); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_free_exception"); } static llvm::Constant *getThrowFn(CodeGenModule &CGM) { // void __cxa_throw(void *thrown_exception, std::type_info *tinfo, // void (*dest) (void *)); llvm::Type *Args[3] = { CGM.Int8PtrTy, CGM.Int8PtrTy, CGM.Int8PtrTy }; llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, Args, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_throw"); } static llvm::Constant *getReThrowFn(CodeGenModule &CGM) { // void __cxa_rethrow(); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_rethrow"); } static llvm::Constant *getGetExceptionPtrFn(CodeGenModule &CGM) { // void *__cxa_get_exception_ptr(void*); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_get_exception_ptr"); } static llvm::Constant *getBeginCatchFn(CodeGenModule &CGM) { // void *__cxa_begin_catch(void*); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.Int8PtrTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_begin_catch"); } static llvm::Constant *getEndCatchFn(CodeGenModule &CGM) { // void __cxa_end_catch(); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_end_catch"); } static llvm::Constant *getUnexpectedFn(CodeGenModule &CGM) { // void __cxa_call_unexpected(void *thrown_exception); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, "__cxa_call_unexpected"); } llvm::Constant *CodeGenFunction::getUnwindResumeFn() { llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, Int8PtrTy, /*IsVarArgs=*/false); if (CGM.getLangOpts().SjLjExceptions) return CGM.CreateRuntimeFunction(FTy, "_Unwind_SjLj_Resume"); return CGM.CreateRuntimeFunction(FTy, "_Unwind_Resume"); } llvm::Constant *CodeGenFunction::getUnwindResumeOrRethrowFn() { llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, Int8PtrTy, /*IsVarArgs=*/false); if (CGM.getLangOpts().SjLjExceptions) return CGM.CreateRuntimeFunction(FTy, "_Unwind_SjLj_Resume_or_Rethrow"); return CGM.CreateRuntimeFunction(FTy, "_Unwind_Resume_or_Rethrow"); } static llvm::Constant *getTerminateFn(CodeGenModule &CGM) { // void __terminate(); llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, /*IsVarArgs=*/false); StringRef name; // In C++, use std::terminate(). if (CGM.getLangOpts().CPlusPlus) name = "_ZSt9terminatev"; // FIXME: mangling! else if (CGM.getLangOpts().ObjC1 && CGM.getLangOpts().ObjCRuntime.hasTerminate()) name = "objc_terminate"; else name = "abort"; return CGM.CreateRuntimeFunction(FTy, name); } static llvm::Constant *getCatchallRethrowFn(CodeGenModule &CGM, StringRef Name) { llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); return CGM.CreateRuntimeFunction(FTy, Name); } namespace { /// The exceptions personality for a function. struct EHPersonality { const char *PersonalityFn; // If this is non-null, this personality requires a non-standard // function for rethrowing an exception after a catchall cleanup. // This function must have prototype void(void*). const char *CatchallRethrowFn; static const EHPersonality &get(const LangOptions &Lang); static const EHPersonality GNU_C; static const EHPersonality GNU_C_SJLJ; static const EHPersonality GNU_ObjC; static const EHPersonality GNUstep_ObjC; static const EHPersonality GNU_ObjCXX; static const EHPersonality NeXT_ObjC; static const EHPersonality GNU_CPlusPlus; static const EHPersonality GNU_CPlusPlus_SJLJ; }; } const EHPersonality EHPersonality::GNU_C = { "__gcc_personality_v0", 0 }; const EHPersonality EHPersonality::GNU_C_SJLJ = { "__gcc_personality_sj0", 0 }; const EHPersonality EHPersonality::NeXT_ObjC = { "__objc_personality_v0", 0 }; const EHPersonality EHPersonality::GNU_CPlusPlus = { "__gxx_personality_v0", 0}; const EHPersonality EHPersonality::GNU_CPlusPlus_SJLJ = { "__gxx_personality_sj0", 0 }; const EHPersonality EHPersonality::GNU_ObjC = {"__gnu_objc_personality_v0", "objc_exception_throw"}; const EHPersonality EHPersonality::GNU_ObjCXX = { "__gnustep_objcxx_personality_v0", 0 }; const EHPersonality EHPersonality::GNUstep_ObjC = { "__gnustep_objc_personality_v0", 0 }; static const EHPersonality &getCPersonality(const LangOptions &L) { if (L.SjLjExceptions) return EHPersonality::GNU_C_SJLJ; return EHPersonality::GNU_C; } static const EHPersonality &getObjCPersonality(const LangOptions &L) { switch (L.ObjCRuntime.getKind()) { case ObjCRuntime::FragileMacOSX: return getCPersonality(L); case ObjCRuntime::MacOSX: case ObjCRuntime::iOS: return EHPersonality::NeXT_ObjC; case ObjCRuntime::GNUstep: if (L.ObjCRuntime.getVersion() >= VersionTuple(1, 7)) return EHPersonality::GNUstep_ObjC; // fallthrough case ObjCRuntime::GCC: case ObjCRuntime::ObjFW: return EHPersonality::GNU_ObjC; } llvm_unreachable("bad runtime kind"); } static const EHPersonality &getCXXPersonality(const LangOptions &L) { if (L.SjLjExceptions) return EHPersonality::GNU_CPlusPlus_SJLJ; else return EHPersonality::GNU_CPlusPlus; } /// Determines the personality function to use when both C++ /// and Objective-C exceptions are being caught. static const EHPersonality &getObjCXXPersonality(const LangOptions &L) { switch (L.ObjCRuntime.getKind()) { // The ObjC personality defers to the C++ personality for non-ObjC // handlers. Unlike the C++ case, we use the same personality // function on targets using (backend-driven) SJLJ EH. case ObjCRuntime::MacOSX: case ObjCRuntime::iOS: return EHPersonality::NeXT_ObjC; // In the fragile ABI, just use C++ exception handling and hope // they're not doing crazy exception mixing. case ObjCRuntime::FragileMacOSX: return getCXXPersonality(L); // The GCC runtime's personality function inherently doesn't support // mixed EH. Use the C++ personality just to avoid returning null. case ObjCRuntime::GCC: case ObjCRuntime::ObjFW: // XXX: this will change soon return EHPersonality::GNU_ObjC; case ObjCRuntime::GNUstep: return EHPersonality::GNU_ObjCXX; } llvm_unreachable("bad runtime kind"); } const EHPersonality &EHPersonality::get(const LangOptions &L) { if (L.CPlusPlus && L.ObjC1) return getObjCXXPersonality(L); else if (L.CPlusPlus) return getCXXPersonality(L); else if (L.ObjC1) return getObjCPersonality(L); else return getCPersonality(L); } static llvm::Constant *getPersonalityFn(CodeGenModule &CGM, const EHPersonality &Personality) { llvm::Constant *Fn = CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty, true), Personality.PersonalityFn); return Fn; } static llvm::Constant *getOpaquePersonalityFn(CodeGenModule &CGM, const EHPersonality &Personality) { llvm::Constant *Fn = getPersonalityFn(CGM, Personality); return llvm::ConstantExpr::getBitCast(Fn, CGM.Int8PtrTy); } /// Check whether a personality function could reasonably be swapped /// for a C++ personality function. static bool PersonalityHasOnlyCXXUses(llvm::Constant *Fn) { for (llvm::Constant::use_iterator I = Fn->use_begin(), E = Fn->use_end(); I != E; ++I) { llvm::User *User = *I; // Conditionally white-list bitcasts. if (llvm::ConstantExpr *CE = dyn_cast(User)) { if (CE->getOpcode() != llvm::Instruction::BitCast) return false; if (!PersonalityHasOnlyCXXUses(CE)) return false; continue; } // Otherwise, it has to be a landingpad instruction. llvm::LandingPadInst *LPI = dyn_cast(User); if (!LPI) return false; for (unsigned I = 0, E = LPI->getNumClauses(); I != E; ++I) { // Look for something that would've been returned by the ObjC // runtime's GetEHType() method. llvm::Value *Val = LPI->getClause(I)->stripPointerCasts(); if (LPI->isCatch(I)) { // Check if the catch value has the ObjC prefix. if (llvm::GlobalVariable *GV = dyn_cast(Val)) // ObjC EH selector entries are always global variables with // names starting like this. if (GV->getName().startswith("OBJC_EHTYPE")) return false; } else { // Check if any of the filter values have the ObjC prefix. llvm::Constant *CVal = cast(Val); for (llvm::User::op_iterator II = CVal->op_begin(), IE = CVal->op_end(); II != IE; ++II) { if (llvm::GlobalVariable *GV = cast((*II)->stripPointerCasts())) // ObjC EH selector entries are always global variables with // names starting like this. if (GV->getName().startswith("OBJC_EHTYPE")) return false; } } } } return true; } /// Try to use the C++ personality function in ObjC++. Not doing this /// can cause some incompatibilities with gcc, which is more /// aggressive about only using the ObjC++ personality in a function /// when it really needs it. void CodeGenModule::SimplifyPersonality() { // If we're not in ObjC++ -fexceptions, there's nothing to do. if (!LangOpts.CPlusPlus || !LangOpts.ObjC1 || !LangOpts.Exceptions) return; // Both the problem this endeavors to fix and the way the logic // above works is specific to the NeXT runtime. if (!LangOpts.ObjCRuntime.isNeXTFamily()) return; const EHPersonality &ObjCXX = EHPersonality::get(LangOpts); const EHPersonality &CXX = getCXXPersonality(LangOpts); if (&ObjCXX == &CXX) return; assert(std::strcmp(ObjCXX.PersonalityFn, CXX.PersonalityFn) != 0 && "Different EHPersonalities using the same personality function."); llvm::Function *Fn = getModule().getFunction(ObjCXX.PersonalityFn); // Nothing to do if it's unused. if (!Fn || Fn->use_empty()) return; // Can't do the optimization if it has non-C++ uses. if (!PersonalityHasOnlyCXXUses(Fn)) return; // Create the C++ personality function and kill off the old // function. llvm::Constant *CXXFn = getPersonalityFn(*this, CXX); // This can happen if the user is screwing with us. if (Fn->getType() != CXXFn->getType()) return; Fn->replaceAllUsesWith(CXXFn); Fn->eraseFromParent(); } /// Returns the value to inject into a selector to indicate the /// presence of a catch-all. static llvm::Constant *getCatchAllValue(CodeGenFunction &CGF) { // Possibly we should use @@llvm.eh.catch.all.value here. return llvm::ConstantPointerNull::get(CGF.Int8PtrTy); } namespace { /// A cleanup to free the exception object if its initialization /// throws. struct FreeException : EHScopeStack::Cleanup { llvm::Value *exn; FreeException(llvm::Value *exn) : exn(exn) {} void Emit(CodeGenFunction &CGF, Flags flags) { CGF.EmitNounwindRuntimeCall(getFreeExceptionFn(CGF.CGM), exn); } }; } // Emits an exception expression into the given location. This // differs from EmitAnyExprToMem only in that, if a final copy-ctor // call is required, an exception within that copy ctor causes // std::terminate to be invoked. static void EmitAnyExprToExn(CodeGenFunction &CGF, const Expr *e, llvm::Value *addr) { // Make sure the exception object is cleaned up if there's an // exception during initialization. CGF.pushFullExprCleanup(EHCleanup, addr); EHScopeStack::stable_iterator cleanup = CGF.EHStack.stable_begin(); // __cxa_allocate_exception returns a void*; we need to cast this // to the appropriate type for the object. llvm::Type *ty = CGF.ConvertTypeForMem(e->getType())->getPointerTo(); llvm::Value *typedAddr = CGF.Builder.CreateBitCast(addr, ty); // FIXME: this isn't quite right! If there's a final unelided call // to a copy constructor, then according to [except.terminate]p1 we // must call std::terminate() if that constructor throws, because // technically that copy occurs after the exception expression is // evaluated but before the exception is caught. But the best way // to handle that is to teach EmitAggExpr to do the final copy // differently if it can't be elided. CGF.EmitAnyExprToMem(e, typedAddr, e->getType().getQualifiers(), /*IsInit*/ true); // Deactivate the cleanup block. CGF.DeactivateCleanupBlock(cleanup, cast(typedAddr)); } llvm::Value *CodeGenFunction::getExceptionSlot() { if (!ExceptionSlot) ExceptionSlot = CreateTempAlloca(Int8PtrTy, "exn.slot"); return ExceptionSlot; } llvm::Value *CodeGenFunction::getEHSelectorSlot() { if (!EHSelectorSlot) EHSelectorSlot = CreateTempAlloca(Int32Ty, "ehselector.slot"); return EHSelectorSlot; } llvm::Value *CodeGenFunction::getExceptionFromSlot() { return Builder.CreateLoad(getExceptionSlot(), "exn"); } llvm::Value *CodeGenFunction::getSelectorFromSlot() { return Builder.CreateLoad(getEHSelectorSlot(), "sel"); } void CodeGenFunction::EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint) { if (!E->getSubExpr()) { EmitNoreturnRuntimeCallOrInvoke(getReThrowFn(CGM), ArrayRef()); // throw is an expression, and the expression emitters expect us // to leave ourselves at a valid insertion point. if (KeepInsertionPoint) EmitBlock(createBasicBlock("throw.cont")); return; } QualType ThrowType = E->getSubExpr()->getType(); if (ThrowType->isObjCObjectPointerType()) { const Stmt *ThrowStmt = E->getSubExpr(); const ObjCAtThrowStmt S(E->getExprLoc(), const_cast(ThrowStmt)); CGM.getObjCRuntime().EmitThrowStmt(*this, S, false); // This will clear insertion point which was not cleared in // call to EmitThrowStmt. if (KeepInsertionPoint) EmitBlock(createBasicBlock("throw.cont")); return; } // Now allocate the exception object. llvm::Type *SizeTy = ConvertType(getContext().getSizeType()); uint64_t TypeSize = getContext().getTypeSizeInChars(ThrowType).getQuantity(); llvm::Constant *AllocExceptionFn = getAllocateExceptionFn(CGM); llvm::CallInst *ExceptionPtr = EmitNounwindRuntimeCall(AllocExceptionFn, llvm::ConstantInt::get(SizeTy, TypeSize), "exception"); EmitAnyExprToExn(*this, E->getSubExpr(), ExceptionPtr); // Now throw the exception. llvm::Constant *TypeInfo = CGM.GetAddrOfRTTIDescriptor(ThrowType, /*ForEH=*/true); // The address of the destructor. If the exception type has a // trivial destructor (or isn't a record), we just pass null. llvm::Constant *Dtor = 0; if (const RecordType *RecordTy = ThrowType->getAs()) { CXXRecordDecl *Record = cast(RecordTy->getDecl()); if (!Record->hasTrivialDestructor()) { CXXDestructorDecl *DtorD = Record->getDestructor(); Dtor = CGM.GetAddrOfCXXDestructor(DtorD, Dtor_Complete); Dtor = llvm::ConstantExpr::getBitCast(Dtor, Int8PtrTy); } } if (!Dtor) Dtor = llvm::Constant::getNullValue(Int8PtrTy); llvm::Value *args[] = { ExceptionPtr, TypeInfo, Dtor }; EmitNoreturnRuntimeCallOrInvoke(getThrowFn(CGM), args); // throw is an expression, and the expression emitters expect us // to leave ourselves at a valid insertion point. if (KeepInsertionPoint) EmitBlock(createBasicBlock("throw.cont")); } void CodeGenFunction::EmitStartEHSpec(const Decl *D) { if (!CGM.getLangOpts().CXXExceptions) return; const FunctionDecl* FD = dyn_cast_or_null(D); if (FD == 0) return; const FunctionProtoType *Proto = FD->getType()->getAs(); if (Proto == 0) return; ExceptionSpecificationType EST = Proto->getExceptionSpecType(); if (isNoexceptExceptionSpec(EST)) { if (Proto->getNoexceptSpec(getContext()) == FunctionProtoType::NR_Nothrow) { // noexcept functions are simple terminate scopes. EHStack.pushTerminate(); } } else if (EST == EST_Dynamic || EST == EST_DynamicNone) { unsigned NumExceptions = Proto->getNumExceptions(); EHFilterScope *Filter = EHStack.pushFilter(NumExceptions); for (unsigned I = 0; I != NumExceptions; ++I) { QualType Ty = Proto->getExceptionType(I); QualType ExceptType = Ty.getNonReferenceType().getUnqualifiedType(); llvm::Value *EHType = CGM.GetAddrOfRTTIDescriptor(ExceptType, /*ForEH=*/true); Filter->setFilter(I, EHType); } } } /// Emit the dispatch block for a filter scope if necessary. static void emitFilterDispatchBlock(CodeGenFunction &CGF, EHFilterScope &filterScope) { llvm::BasicBlock *dispatchBlock = filterScope.getCachedEHDispatchBlock(); if (!dispatchBlock) return; if (dispatchBlock->use_empty()) { delete dispatchBlock; return; } CGF.EmitBlockAfterUses(dispatchBlock); // If this isn't a catch-all filter, we need to check whether we got // here because the filter triggered. if (filterScope.getNumFilters()) { // Load the selector value. llvm::Value *selector = CGF.getSelectorFromSlot(); llvm::BasicBlock *unexpectedBB = CGF.createBasicBlock("ehspec.unexpected"); llvm::Value *zero = CGF.Builder.getInt32(0); llvm::Value *failsFilter = CGF.Builder.CreateICmpSLT(selector, zero, "ehspec.fails"); CGF.Builder.CreateCondBr(failsFilter, unexpectedBB, CGF.getEHResumeBlock(false)); CGF.EmitBlock(unexpectedBB); } // Call __cxa_call_unexpected. This doesn't need to be an invoke // because __cxa_call_unexpected magically filters exceptions // according to the last landing pad the exception was thrown // into. Seriously. llvm::Value *exn = CGF.getExceptionFromSlot(); CGF.EmitRuntimeCall(getUnexpectedFn(CGF.CGM), exn) ->setDoesNotReturn(); CGF.Builder.CreateUnreachable(); } void CodeGenFunction::EmitEndEHSpec(const Decl *D) { if (!CGM.getLangOpts().CXXExceptions) return; const FunctionDecl* FD = dyn_cast_or_null(D); if (FD == 0) return; const FunctionProtoType *Proto = FD->getType()->getAs(); if (Proto == 0) return; ExceptionSpecificationType EST = Proto->getExceptionSpecType(); if (isNoexceptExceptionSpec(EST)) { if (Proto->getNoexceptSpec(getContext()) == FunctionProtoType::NR_Nothrow) { EHStack.popTerminate(); } } else if (EST == EST_Dynamic || EST == EST_DynamicNone) { EHFilterScope &filterScope = cast(*EHStack.begin()); emitFilterDispatchBlock(*this, filterScope); EHStack.popFilter(); } } void CodeGenFunction::EmitCXXTryStmt(const CXXTryStmt &S) { EnterCXXTryStmt(S); EmitStmt(S.getTryBlock()); ExitCXXTryStmt(S); } void CodeGenFunction::EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) { unsigned NumHandlers = S.getNumHandlers(); EHCatchScope *CatchScope = EHStack.pushCatch(NumHandlers); for (unsigned I = 0; I != NumHandlers; ++I) { const CXXCatchStmt *C = S.getHandler(I); llvm::BasicBlock *Handler = createBasicBlock("catch"); if (C->getExceptionDecl()) { // FIXME: Dropping the reference type on the type into makes it // impossible to correctly implement catch-by-reference // semantics for pointers. Unfortunately, this is what all // existing compilers do, and it's not clear that the standard // personality routine is capable of doing this right. See C++ DR 388: // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#388 QualType CaughtType = C->getCaughtType(); CaughtType = CaughtType.getNonReferenceType().getUnqualifiedType(); llvm::Value *TypeInfo = 0; if (CaughtType->isObjCObjectPointerType()) TypeInfo = CGM.getObjCRuntime().GetEHType(CaughtType); else TypeInfo = CGM.GetAddrOfRTTIDescriptor(CaughtType, /*ForEH=*/true); CatchScope->setHandler(I, TypeInfo, Handler); } else { // No exception decl indicates '...', a catch-all. CatchScope->setCatchAllHandler(I, Handler); } } } llvm::BasicBlock * CodeGenFunction::getEHDispatchBlock(EHScopeStack::stable_iterator si) { // The dispatch block for the end of the scope chain is a block that // just resumes unwinding. if (si == EHStack.stable_end()) return getEHResumeBlock(true); // Otherwise, we should look at the actual scope. EHScope &scope = *EHStack.find(si); llvm::BasicBlock *dispatchBlock = scope.getCachedEHDispatchBlock(); if (!dispatchBlock) { switch (scope.getKind()) { case EHScope::Catch: { // Apply a special case to a single catch-all. EHCatchScope &catchScope = cast(scope); if (catchScope.getNumHandlers() == 1 && catchScope.getHandler(0).isCatchAll()) { dispatchBlock = catchScope.getHandler(0).Block; // Otherwise, make a dispatch block. } else { dispatchBlock = createBasicBlock("catch.dispatch"); } break; } case EHScope::Cleanup: dispatchBlock = createBasicBlock("ehcleanup"); break; case EHScope::Filter: dispatchBlock = createBasicBlock("filter.dispatch"); break; case EHScope::Terminate: dispatchBlock = getTerminateHandler(); break; } scope.setCachedEHDispatchBlock(dispatchBlock); } return dispatchBlock; } /// Check whether this is a non-EH scope, i.e. a scope which doesn't /// affect exception handling. Currently, the only non-EH scopes are /// normal-only cleanup scopes. static bool isNonEHScope(const EHScope &S) { switch (S.getKind()) { case EHScope::Cleanup: return !cast(S).isEHCleanup(); case EHScope::Filter: case EHScope::Catch: case EHScope::Terminate: return false; } llvm_unreachable("Invalid EHScope Kind!"); } llvm::BasicBlock *CodeGenFunction::getInvokeDestImpl() { assert(EHStack.requiresLandingPad()); assert(!EHStack.empty()); if (!CGM.getLangOpts().Exceptions) return 0; // Check the innermost scope for a cached landing pad. If this is // a non-EH cleanup, we'll check enclosing scopes in EmitLandingPad. llvm::BasicBlock *LP = EHStack.begin()->getCachedLandingPad(); if (LP) return LP; // Build the landing pad for this scope. LP = EmitLandingPad(); assert(LP); // Cache the landing pad on the innermost scope. If this is a // non-EH scope, cache the landing pad on the enclosing scope, too. for (EHScopeStack::iterator ir = EHStack.begin(); true; ++ir) { ir->setCachedLandingPad(LP); if (!isNonEHScope(*ir)) break; } return LP; } // This code contains a hack to work around a design flaw in // LLVM's EH IR which breaks semantics after inlining. This same // hack is implemented in llvm-gcc. // // The LLVM EH abstraction is basically a thin veneer over the // traditional GCC zero-cost design: for each range of instructions // in the function, there is (at most) one "landing pad" with an // associated chain of EH actions. A language-specific personality // function interprets this chain of actions and (1) decides whether // or not to resume execution at the landing pad and (2) if so, // provides an integer indicating why it's stopping. In LLVM IR, // the association of a landing pad with a range of instructions is // achieved via an invoke instruction, the chain of actions becomes // the arguments to the @@llvm.eh.selector call, and the selector // call returns the integer indicator. Other than the required // presence of two intrinsic function calls in the landing pad, // the IR exactly describes the layout of the output code. // // A principal advantage of this design is that it is completely // language-agnostic; in theory, the LLVM optimizers can treat // landing pads neutrally, and targets need only know how to lower // the intrinsics to have a functioning exceptions system (assuming // that platform exceptions follow something approximately like the // GCC design). Unfortunately, landing pads cannot be combined in a // language-agnostic way: given selectors A and B, there is no way // to make a single landing pad which faithfully represents the // semantics of propagating an exception first through A, then // through B, without knowing how the personality will interpret the // (lowered form of the) selectors. This means that inlining has no // choice but to crudely chain invokes (i.e., to ignore invokes in // the inlined function, but to turn all unwindable calls into // invokes), which is only semantically valid if every unwind stops // at every landing pad. // // Therefore, the invoke-inline hack is to guarantee that every // landing pad has a catch-all. enum CleanupHackLevel_t { /// A level of hack that requires that all landing pads have /// catch-alls. CHL_MandatoryCatchall, /// A level of hack that requires that all landing pads handle /// cleanups. CHL_MandatoryCleanup, /// No hacks at all; ideal IR generation. CHL_Ideal }; const CleanupHackLevel_t CleanupHackLevel = CHL_MandatoryCleanup; llvm::BasicBlock *CodeGenFunction::EmitLandingPad() { assert(EHStack.requiresLandingPad()); EHScope &innermostEHScope = *EHStack.find(EHStack.getInnermostEHScope()); switch (innermostEHScope.getKind()) { case EHScope::Terminate: return getTerminateLandingPad(); case EHScope::Catch: case EHScope::Cleanup: case EHScope::Filter: if (llvm::BasicBlock *lpad = innermostEHScope.getCachedLandingPad()) return lpad; } // Save the current IR generation state. CGBuilderTy::InsertPoint savedIP = Builder.saveAndClearIP(); SaveAndRestoreLocation AutoRestoreLocation(*this, Builder); if (CGDebugInfo *DI = getDebugInfo()) DI->EmitLocation(Builder, CurEHLocation); const EHPersonality &personality = EHPersonality::get(getLangOpts()); // Create and configure the landing pad. llvm::BasicBlock *lpad = createBasicBlock("lpad"); EmitBlock(lpad); llvm::LandingPadInst *LPadInst = Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty, NULL), getOpaquePersonalityFn(CGM, personality), 0); llvm::Value *LPadExn = Builder.CreateExtractValue(LPadInst, 0); Builder.CreateStore(LPadExn, getExceptionSlot()); llvm::Value *LPadSel = Builder.CreateExtractValue(LPadInst, 1); Builder.CreateStore(LPadSel, getEHSelectorSlot()); // Save the exception pointer. It's safe to use a single exception // pointer per function because EH cleanups can never have nested // try/catches. // Build the landingpad instruction. // Accumulate all the handlers in scope. bool hasCatchAll = false; bool hasCleanup = false; bool hasFilter = false; SmallVector filterTypes; llvm::SmallPtrSet catchTypes; for (EHScopeStack::iterator I = EHStack.begin(), E = EHStack.end(); I != E; ++I) { switch (I->getKind()) { case EHScope::Cleanup: // If we have a cleanup, remember that. hasCleanup = (hasCleanup || cast(*I).isEHCleanup()); continue; case EHScope::Filter: { assert(I.next() == EHStack.end() && "EH filter is not end of EH stack"); assert(!hasCatchAll && "EH filter reached after catch-all"); // Filter scopes get added to the landingpad in weird ways. EHFilterScope &filter = cast(*I); hasFilter = true; // Add all the filter values. for (unsigned i = 0, e = filter.getNumFilters(); i != e; ++i) filterTypes.push_back(filter.getFilter(i)); goto done; } case EHScope::Terminate: // Terminate scopes are basically catch-alls. assert(!hasCatchAll); hasCatchAll = true; goto done; case EHScope::Catch: break; } EHCatchScope &catchScope = cast(*I); for (unsigned hi = 0, he = catchScope.getNumHandlers(); hi != he; ++hi) { EHCatchScope::Handler handler = catchScope.getHandler(hi); // If this is a catch-all, register that and abort. if (!handler.Type) { assert(!hasCatchAll); hasCatchAll = true; goto done; } // Check whether we already have a handler for this type. if (catchTypes.insert(handler.Type)) // If not, add it directly to the landingpad. LPadInst->addClause(handler.Type); } } done: // If we have a catch-all, add null to the landingpad. assert(!(hasCatchAll && hasFilter)); if (hasCatchAll) { LPadInst->addClause(getCatchAllValue(*this)); // If we have an EH filter, we need to add those handlers in the // right place in the landingpad, which is to say, at the end. } else if (hasFilter) { // Create a filter expression: a constant array indicating which filter // types there are. The personality routine only lands here if the filter // doesn't match. SmallVector Filters; llvm::ArrayType *AType = llvm::ArrayType::get(!filterTypes.empty() ? filterTypes[0]->getType() : Int8PtrTy, filterTypes.size()); for (unsigned i = 0, e = filterTypes.size(); i != e; ++i) Filters.push_back(cast(filterTypes[i])); llvm::Constant *FilterArray = llvm::ConstantArray::get(AType, Filters); LPadInst->addClause(FilterArray); // Also check whether we need a cleanup. if (hasCleanup) LPadInst->setCleanup(true); // Otherwise, signal that we at least have cleanups. } else if (CleanupHackLevel == CHL_MandatoryCatchall || hasCleanup) { if (CleanupHackLevel == CHL_MandatoryCatchall) LPadInst->addClause(getCatchAllValue(*this)); else LPadInst->setCleanup(true); } assert((LPadInst->getNumClauses() > 0 || LPadInst->isCleanup()) && "landingpad instruction has no clauses!"); // Tell the backend how to generate the landing pad. Builder.CreateBr(getEHDispatchBlock(EHStack.getInnermostEHScope())); // Restore the old IR generation state. Builder.restoreIP(savedIP); return lpad; } namespace { /// A cleanup to call __cxa_end_catch. In many cases, the caught /// exception type lets us state definitively that the thrown exception /// type does not have a destructor. In particular: /// - Catch-alls tell us nothing, so we have to conservatively /// assume that the thrown exception might have a destructor. /// - Catches by reference behave according to their base types. /// - Catches of non-record types will only trigger for exceptions /// of non-record types, which never have destructors. /// - Catches of record types can trigger for arbitrary subclasses /// of the caught type, so we have to assume the actual thrown /// exception type might have a throwing destructor, even if the /// caught type's destructor is trivial or nothrow. struct CallEndCatch : EHScopeStack::Cleanup { CallEndCatch(bool MightThrow) : MightThrow(MightThrow) {} bool MightThrow; void Emit(CodeGenFunction &CGF, Flags flags) { if (!MightThrow) { CGF.EmitNounwindRuntimeCall(getEndCatchFn(CGF.CGM)); return; } CGF.EmitRuntimeCallOrInvoke(getEndCatchFn(CGF.CGM)); } }; } /// Emits a call to __cxa_begin_catch and enters a cleanup to call /// __cxa_end_catch. /// /// \param EndMightThrow - true if __cxa_end_catch might throw static llvm::Value *CallBeginCatch(CodeGenFunction &CGF, llvm::Value *Exn, bool EndMightThrow) { llvm::CallInst *call = CGF.EmitNounwindRuntimeCall(getBeginCatchFn(CGF.CGM), Exn); CGF.EHStack.pushCleanup(NormalAndEHCleanup, EndMightThrow); return call; } /// A "special initializer" callback for initializing a catch /// parameter during catch initialization. static void InitCatchParam(CodeGenFunction &CGF, const VarDecl &CatchParam, llvm::Value *ParamAddr, SourceLocation Loc) { // Load the exception from where the landing pad saved it. llvm::Value *Exn = CGF.getExceptionFromSlot(); CanQualType CatchType = CGF.CGM.getContext().getCanonicalType(CatchParam.getType()); llvm::Type *LLVMCatchTy = CGF.ConvertTypeForMem(CatchType); // If we're catching by reference, we can just cast the object // pointer to the appropriate pointer. if (isa(CatchType)) { QualType CaughtType = cast(CatchType)->getPointeeType(); bool EndCatchMightThrow = CaughtType->isRecordType(); // __cxa_begin_catch returns the adjusted object pointer. llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, EndCatchMightThrow); // We have no way to tell the personality function that we're // catching by reference, so if we're catching a pointer, // __cxa_begin_catch will actually return that pointer by value. if (const PointerType *PT = dyn_cast(CaughtType)) { QualType PointeeType = PT->getPointeeType(); // When catching by reference, generally we should just ignore // this by-value pointer and use the exception object instead. if (!PointeeType->isRecordType()) { // Exn points to the struct _Unwind_Exception header, which // we have to skip past in order to reach the exception data. unsigned HeaderSize = CGF.CGM.getTargetCodeGenInfo().getSizeOfUnwindException(); AdjustedExn = CGF.Builder.CreateConstGEP1_32(Exn, HeaderSize); // However, if we're catching a pointer-to-record type that won't // work, because the personality function might have adjusted // the pointer. There's actually no way for us to fully satisfy // the language/ABI contract here: we can't use Exn because it // might have the wrong adjustment, but we can't use the by-value // pointer because it's off by a level of abstraction. // // The current solution is to dump the adjusted pointer into an // alloca, which breaks language semantics (because changing the // pointer doesn't change the exception) but at least works. // The better solution would be to filter out non-exact matches // and rethrow them, but this is tricky because the rethrow // really needs to be catchable by other sites at this landing // pad. The best solution is to fix the personality function. } else { // Pull the pointer for the reference type off. llvm::Type *PtrTy = cast(LLVMCatchTy)->getElementType(); // Create the temporary and write the adjusted pointer into it. llvm::Value *ExnPtrTmp = CGF.CreateTempAlloca(PtrTy, "exn.byref.tmp"); llvm::Value *Casted = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy); CGF.Builder.CreateStore(Casted, ExnPtrTmp); // Bind the reference to the temporary. AdjustedExn = ExnPtrTmp; } } llvm::Value *ExnCast = CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.byref"); CGF.Builder.CreateStore(ExnCast, ParamAddr); return; } // Scalars and complexes. TypeEvaluationKind TEK = CGF.getEvaluationKind(CatchType); if (TEK != TEK_Aggregate) { llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, false); // If the catch type is a pointer type, __cxa_begin_catch returns // the pointer by value. if (CatchType->hasPointerRepresentation()) { llvm::Value *CastExn = CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.casted"); switch (CatchType.getQualifiers().getObjCLifetime()) { case Qualifiers::OCL_Strong: CastExn = CGF.EmitARCRetainNonBlock(CastExn); // fallthrough case Qualifiers::OCL_None: case Qualifiers::OCL_ExplicitNone: case Qualifiers::OCL_Autoreleasing: CGF.Builder.CreateStore(CastExn, ParamAddr); return; case Qualifiers::OCL_Weak: CGF.EmitARCInitWeak(ParamAddr, CastExn); return; } llvm_unreachable("bad ownership qualifier!"); } // Otherwise, it returns a pointer into the exception object. llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok llvm::Value *Cast = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy); LValue srcLV = CGF.MakeNaturalAlignAddrLValue(Cast, CatchType); LValue destLV = CGF.MakeAddrLValue(ParamAddr, CatchType, CGF.getContext().getDeclAlign(&CatchParam)); switch (TEK) { case TEK_Complex: CGF.EmitStoreOfComplex(CGF.EmitLoadOfComplex(srcLV, Loc), destLV, /*init*/ true); return; case TEK_Scalar: { llvm::Value *ExnLoad = CGF.EmitLoadOfScalar(srcLV, Loc); CGF.EmitStoreOfScalar(ExnLoad, destLV, /*init*/ true); return; } case TEK_Aggregate: llvm_unreachable("evaluation kind filtered out!"); } llvm_unreachable("bad evaluation kind"); } assert(isa(CatchType) && "unexpected catch type!"); llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok // Check for a copy expression. If we don't have a copy expression, // that means a trivial copy is okay. const Expr *copyExpr = CatchParam.getInit(); if (!copyExpr) { llvm::Value *rawAdjustedExn = CallBeginCatch(CGF, Exn, true); llvm::Value *adjustedExn = CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy); CGF.EmitAggregateCopy(ParamAddr, adjustedExn, CatchType); return; } // We have to call __cxa_get_exception_ptr to get the adjusted // pointer before copying. llvm::CallInst *rawAdjustedExn = CGF.EmitNounwindRuntimeCall(getGetExceptionPtrFn(CGF.CGM), Exn); // Cast that to the appropriate type. llvm::Value *adjustedExn = CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy); // The copy expression is defined in terms of an OpaqueValueExpr. // Find it and map it to the adjusted expression. CodeGenFunction::OpaqueValueMapping opaque(CGF, OpaqueValueExpr::findInCopyConstruct(copyExpr), CGF.MakeAddrLValue(adjustedExn, CatchParam.getType())); // Call the copy ctor in a terminate scope. CGF.EHStack.pushTerminate(); // Perform the copy construction. CharUnits Alignment = CGF.getContext().getDeclAlign(&CatchParam); CGF.EmitAggExpr(copyExpr, AggValueSlot::forAddr(ParamAddr, Alignment, Qualifiers(), AggValueSlot::IsNotDestructed, AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased)); // Leave the terminate scope. CGF.EHStack.popTerminate(); // Undo the opaque value mapping. opaque.pop(); // Finally we can call __cxa_begin_catch. CallBeginCatch(CGF, Exn, true); } /// Begins a catch statement by initializing the catch variable and /// calling __cxa_begin_catch. static void BeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *S) { // We have to be very careful with the ordering of cleanups here: // C++ [except.throw]p4: // The destruction [of the exception temporary] occurs // immediately after the destruction of the object declared in // the exception-declaration in the handler. // // So the precise ordering is: // 1. Construct catch variable. // 2. __cxa_begin_catch // 3. Enter __cxa_end_catch cleanup // 4. Enter dtor cleanup // // We do this by using a slightly abnormal initialization process. // Delegation sequence: // - ExitCXXTryStmt opens a RunCleanupsScope // - EmitAutoVarAlloca creates the variable and debug info // - InitCatchParam initializes the variable from the exception // - CallBeginCatch calls __cxa_begin_catch // - CallBeginCatch enters the __cxa_end_catch cleanup // - EmitAutoVarCleanups enters the variable destructor cleanup // - EmitCXXTryStmt emits the code for the catch body // - EmitCXXTryStmt close the RunCleanupsScope VarDecl *CatchParam = S->getExceptionDecl(); if (!CatchParam) { llvm::Value *Exn = CGF.getExceptionFromSlot(); CallBeginCatch(CGF, Exn, true); return; } // Emit the local. CodeGenFunction::AutoVarEmission var = CGF.EmitAutoVarAlloca(*CatchParam); InitCatchParam(CGF, *CatchParam, var.getObjectAddress(CGF), S->getLocStart()); CGF.EmitAutoVarCleanups(var); } /// Emit the structure of the dispatch block for the given catch scope. /// It is an invariant that the dispatch block already exists. static void emitCatchDispatchBlock(CodeGenFunction &CGF, EHCatchScope &catchScope) { llvm::BasicBlock *dispatchBlock = catchScope.getCachedEHDispatchBlock(); assert(dispatchBlock); // If there's only a single catch-all, getEHDispatchBlock returned // that catch-all as the dispatch block. if (catchScope.getNumHandlers() == 1 && catchScope.getHandler(0).isCatchAll()) { assert(dispatchBlock == catchScope.getHandler(0).Block); return; } CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveIP(); CGF.EmitBlockAfterUses(dispatchBlock); // Select the right handler. llvm::Value *llvm_eh_typeid_for = CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for); // Load the selector value. llvm::Value *selector = CGF.getSelectorFromSlot(); // Test against each of the exception types we claim to catch. for (unsigned i = 0, e = catchScope.getNumHandlers(); ; ++i) { assert(i < e && "ran off end of handlers!"); const EHCatchScope::Handler &handler = catchScope.getHandler(i); llvm::Value *typeValue = handler.Type; assert(typeValue && "fell into catch-all case!"); typeValue = CGF.Builder.CreateBitCast(typeValue, CGF.Int8PtrTy); // Figure out the next block. bool nextIsEnd; llvm::BasicBlock *nextBlock; // If this is the last handler, we're at the end, and the next // block is the block for the enclosing EH scope. if (i + 1 == e) { nextBlock = CGF.getEHDispatchBlock(catchScope.getEnclosingEHScope()); nextIsEnd = true; // If the next handler is a catch-all, we're at the end, and the // next block is that handler. } else if (catchScope.getHandler(i+1).isCatchAll()) { nextBlock = catchScope.getHandler(i+1).Block; nextIsEnd = true; // Otherwise, we're not at the end and we need a new block. } else { nextBlock = CGF.createBasicBlock("catch.fallthrough"); nextIsEnd = false; } // Figure out the catch type's index in the LSDA's type table. llvm::CallInst *typeIndex = CGF.Builder.CreateCall(llvm_eh_typeid_for, typeValue); typeIndex->setDoesNotThrow(); llvm::Value *matchesTypeIndex = CGF.Builder.CreateICmpEQ(selector, typeIndex, "matches"); CGF.Builder.CreateCondBr(matchesTypeIndex, handler.Block, nextBlock); // If the next handler is a catch-all, we're completely done. if (nextIsEnd) { CGF.Builder.restoreIP(savedIP); return; } // Otherwise we need to emit and continue at that block. CGF.EmitBlock(nextBlock); } } void CodeGenFunction::popCatchScope() { EHCatchScope &catchScope = cast(*EHStack.begin()); if (catchScope.hasEHBranches()) emitCatchDispatchBlock(*this, catchScope); EHStack.popCatch(); } void CodeGenFunction::ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) { unsigned NumHandlers = S.getNumHandlers(); EHCatchScope &CatchScope = cast(*EHStack.begin()); assert(CatchScope.getNumHandlers() == NumHandlers); // If the catch was not required, bail out now. if (!CatchScope.hasEHBranches()) { CatchScope.clearHandlerBlocks(); EHStack.popCatch(); return; } // Emit the structure of the EH dispatch for this catch. emitCatchDispatchBlock(*this, CatchScope); // Copy the handler blocks off before we pop the EH stack. Emitting // the handlers might scribble on this memory. SmallVector Handlers(NumHandlers); memcpy(Handlers.data(), CatchScope.begin(), NumHandlers * sizeof(EHCatchScope::Handler)); EHStack.popCatch(); // The fall-through block. llvm::BasicBlock *ContBB = createBasicBlock("try.cont"); // We just emitted the body of the try; jump to the continue block. if (HaveInsertPoint()) Builder.CreateBr(ContBB); // Determine if we need an implicit rethrow for all these catch handlers; // see the comment below. bool doImplicitRethrow = false; if (IsFnTryBlock) doImplicitRethrow = isa(CurCodeDecl) || isa(CurCodeDecl); // Perversely, we emit the handlers backwards precisely because we // want them to appear in source order. In all of these cases, the // catch block will have exactly one predecessor, which will be a // particular block in the catch dispatch. However, in the case of // a catch-all, one of the dispatch blocks will branch to two // different handlers, and EmitBlockAfterUses will cause the second // handler to be moved before the first. for (unsigned I = NumHandlers; I != 0; --I) { llvm::BasicBlock *CatchBlock = Handlers[I-1].Block; EmitBlockAfterUses(CatchBlock); // Catch the exception if this isn't a catch-all. const CXXCatchStmt *C = S.getHandler(I-1); // Enter a cleanup scope, including the catch variable and the // end-catch. RunCleanupsScope CatchScope(*this); // Initialize the catch variable and set up the cleanups. BeginCatch(*this, C); // Emit the PGO counter increment. RegionCounter CatchCnt = getPGORegionCounter(C); CatchCnt.beginRegion(Builder); // Perform the body of the catch. EmitStmt(C->getHandlerBlock()); // [except.handle]p11: // The currently handled exception is rethrown if control // reaches the end of a handler of the function-try-block of a // constructor or destructor. // It is important that we only do this on fallthrough and not on // return. Note that it's illegal to put a return in a // constructor function-try-block's catch handler (p14), so this // really only applies to destructors. if (doImplicitRethrow && HaveInsertPoint()) { EmitRuntimeCallOrInvoke(getReThrowFn(CGM)); Builder.CreateUnreachable(); Builder.ClearInsertionPoint(); } // Fall out through the catch cleanups. CatchScope.ForceCleanup(); // Branch out of the try. if (HaveInsertPoint()) Builder.CreateBr(ContBB); } RegionCounter ContCnt = getPGORegionCounter(&S); EmitBlock(ContBB); ContCnt.beginRegion(Builder); } namespace { struct CallEndCatchForFinally : EHScopeStack::Cleanup { llvm::Value *ForEHVar; llvm::Value *EndCatchFn; CallEndCatchForFinally(llvm::Value *ForEHVar, llvm::Value *EndCatchFn) : ForEHVar(ForEHVar), EndCatchFn(EndCatchFn) {} void Emit(CodeGenFunction &CGF, Flags flags) { llvm::BasicBlock *EndCatchBB = CGF.createBasicBlock("finally.endcatch"); llvm::BasicBlock *CleanupContBB = CGF.createBasicBlock("finally.cleanup.cont"); llvm::Value *ShouldEndCatch = CGF.Builder.CreateLoad(ForEHVar, "finally.endcatch"); CGF.Builder.CreateCondBr(ShouldEndCatch, EndCatchBB, CleanupContBB); CGF.EmitBlock(EndCatchBB); CGF.EmitRuntimeCallOrInvoke(EndCatchFn); // catch-all, so might throw CGF.EmitBlock(CleanupContBB); } }; struct PerformFinally : EHScopeStack::Cleanup { const Stmt *Body; llvm::Value *ForEHVar; llvm::Value *EndCatchFn; llvm::Value *RethrowFn; llvm::Value *SavedExnVar; PerformFinally(const Stmt *Body, llvm::Value *ForEHVar, llvm::Value *EndCatchFn, llvm::Value *RethrowFn, llvm::Value *SavedExnVar) : Body(Body), ForEHVar(ForEHVar), EndCatchFn(EndCatchFn), RethrowFn(RethrowFn), SavedExnVar(SavedExnVar) {} void Emit(CodeGenFunction &CGF, Flags flags) { // Enter a cleanup to call the end-catch function if one was provided. if (EndCatchFn) CGF.EHStack.pushCleanup(NormalAndEHCleanup, ForEHVar, EndCatchFn); // Save the current cleanup destination in case there are // cleanups in the finally block. llvm::Value *SavedCleanupDest = CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot(), "cleanup.dest.saved"); // Emit the finally block. CGF.EmitStmt(Body); // If the end of the finally is reachable, check whether this was // for EH. If so, rethrow. if (CGF.HaveInsertPoint()) { llvm::BasicBlock *RethrowBB = CGF.createBasicBlock("finally.rethrow"); llvm::BasicBlock *ContBB = CGF.createBasicBlock("finally.cont"); llvm::Value *ShouldRethrow = CGF.Builder.CreateLoad(ForEHVar, "finally.shouldthrow"); CGF.Builder.CreateCondBr(ShouldRethrow, RethrowBB, ContBB); CGF.EmitBlock(RethrowBB); if (SavedExnVar) { CGF.EmitRuntimeCallOrInvoke(RethrowFn, CGF.Builder.CreateLoad(SavedExnVar)); } else { CGF.EmitRuntimeCallOrInvoke(RethrowFn); } CGF.Builder.CreateUnreachable(); CGF.EmitBlock(ContBB); // Restore the cleanup destination. CGF.Builder.CreateStore(SavedCleanupDest, CGF.getNormalCleanupDestSlot()); } // Leave the end-catch cleanup. As an optimization, pretend that // the fallthrough path was inaccessible; we've dynamically proven // that we're not in the EH case along that path. if (EndCatchFn) { CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP(); CGF.PopCleanupBlock(); CGF.Builder.restoreIP(SavedIP); } // Now make sure we actually have an insertion point or the // cleanup gods will hate us. CGF.EnsureInsertPoint(); } }; } /// Enters a finally block for an implementation using zero-cost /// exceptions. This is mostly general, but hard-codes some /// language/ABI-specific behavior in the catch-all sections. void CodeGenFunction::FinallyInfo::enter(CodeGenFunction &CGF, const Stmt *body, llvm::Constant *beginCatchFn, llvm::Constant *endCatchFn, llvm::Constant *rethrowFn) { assert((beginCatchFn != 0) == (endCatchFn != 0) && "begin/end catch functions not paired"); assert(rethrowFn && "rethrow function is required"); BeginCatchFn = beginCatchFn; // The rethrow function has one of the following two types: // void (*)() // void (*)(void*) // In the latter case we need to pass it the exception object. // But we can't use the exception slot because the @@finally might // have a landing pad (which would overwrite the exception slot). llvm::FunctionType *rethrowFnTy = cast( cast(rethrowFn->getType())->getElementType()); SavedExnVar = 0; if (rethrowFnTy->getNumParams()) SavedExnVar = CGF.CreateTempAlloca(CGF.Int8PtrTy, "finally.exn"); // A finally block is a statement which must be executed on any edge // out of a given scope. Unlike a cleanup, the finally block may // contain arbitrary control flow leading out of itself. In // addition, finally blocks should always be executed, even if there // are no catch handlers higher on the stack. Therefore, we // surround the protected scope with a combination of a normal // cleanup (to catch attempts to break out of the block via normal // control flow) and an EH catch-all (semantically "outside" any try // statement to which the finally block might have been attached). // The finally block itself is generated in the context of a cleanup // which conditionally leaves the catch-all. // Jump destination for performing the finally block on an exception // edge. We'll never actually reach this block, so unreachable is // fine. RethrowDest = CGF.getJumpDestInCurrentScope(CGF.getUnreachableBlock()); // Whether the finally block is being executed for EH purposes. ForEHVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), "finally.for-eh"); CGF.Builder.CreateStore(CGF.Builder.getFalse(), ForEHVar); // Enter a normal cleanup which will perform the @@finally block. CGF.EHStack.pushCleanup(NormalCleanup, body, ForEHVar, endCatchFn, rethrowFn, SavedExnVar); // Enter a catch-all scope. llvm::BasicBlock *catchBB = CGF.createBasicBlock("finally.catchall"); EHCatchScope *catchScope = CGF.EHStack.pushCatch(1); catchScope->setCatchAllHandler(0, catchBB); } void CodeGenFunction::FinallyInfo::exit(CodeGenFunction &CGF) { // Leave the finally catch-all. EHCatchScope &catchScope = cast(*CGF.EHStack.begin()); llvm::BasicBlock *catchBB = catchScope.getHandler(0).Block; CGF.popCatchScope(); // If there are any references to the catch-all block, emit it. if (catchBB->use_empty()) { delete catchBB; } else { CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveAndClearIP(); CGF.EmitBlock(catchBB); llvm::Value *exn = 0; // If there's a begin-catch function, call it. if (BeginCatchFn) { exn = CGF.getExceptionFromSlot(); CGF.EmitNounwindRuntimeCall(BeginCatchFn, exn); } // If we need to remember the exception pointer to rethrow later, do so. if (SavedExnVar) { if (!exn) exn = CGF.getExceptionFromSlot(); CGF.Builder.CreateStore(exn, SavedExnVar); } // Tell the cleanups in the finally block that we're do this for EH. CGF.Builder.CreateStore(CGF.Builder.getTrue(), ForEHVar); // Thread a jump through the finally cleanup. CGF.EmitBranchThroughCleanup(RethrowDest); CGF.Builder.restoreIP(savedIP); } // Finally, leave the @@finally cleanup. CGF.PopCleanupBlock(); } /// In a terminate landing pad, should we use __clang__call_terminate /// or just a naked call to std::terminate? /// /// __clang_call_terminate calls __cxa_begin_catch, which then allows /// std::terminate to usefully report something about the /// violating exception. static bool useClangCallTerminate(CodeGenModule &CGM) { // Only do this for Itanium-family ABIs in C++ mode. return (CGM.getLangOpts().CPlusPlus && CGM.getTarget().getCXXABI().isItaniumFamily()); } /// Get or define the following function: /// void @@__clang_call_terminate(i8* %exn) nounwind noreturn /// This code is used only in C++. static llvm::Constant *getClangCallTerminateFn(CodeGenModule &CGM) { llvm::FunctionType *fnTy = llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*IsVarArgs=*/false); llvm::Constant *fnRef = CGM.CreateRuntimeFunction(fnTy, "__clang_call_terminate"); llvm::Function *fn = dyn_cast(fnRef); if (fn && fn->empty()) { fn->setDoesNotThrow(); fn->setDoesNotReturn(); // What we really want is to massively penalize inlining without // forbidding it completely. The difference between that and // 'noinline' is negligible. fn->addFnAttr(llvm::Attribute::NoInline); // Allow this function to be shared across translation units, but // we don't want it to turn into an exported symbol. fn->setLinkage(llvm::Function::LinkOnceODRLinkage); fn->setVisibility(llvm::Function::HiddenVisibility); // Set up the function. llvm::BasicBlock *entry = llvm::BasicBlock::Create(CGM.getLLVMContext(), "", fn); CGBuilderTy builder(entry); // Pull the exception pointer out of the parameter list. llvm::Value *exn = &*fn->arg_begin(); // Call __cxa_begin_catch(exn). llvm::CallInst *catchCall = builder.CreateCall(getBeginCatchFn(CGM), exn); catchCall->setDoesNotThrow(); catchCall->setCallingConv(CGM.getRuntimeCC()); // Call std::terminate(). llvm::CallInst *termCall = builder.CreateCall(getTerminateFn(CGM)); termCall->setDoesNotThrow(); termCall->setDoesNotReturn(); termCall->setCallingConv(CGM.getRuntimeCC()); // std::terminate cannot return. builder.CreateUnreachable(); } return fnRef; } llvm::BasicBlock *CodeGenFunction::getTerminateLandingPad() { if (TerminateLandingPad) return TerminateLandingPad; CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); // This will get inserted at the end of the function. TerminateLandingPad = createBasicBlock("terminate.lpad"); Builder.SetInsertPoint(TerminateLandingPad); // Tell the backend that this is a landing pad. const EHPersonality &Personality = EHPersonality::get(CGM.getLangOpts()); llvm::LandingPadInst *LPadInst = Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty, NULL), getOpaquePersonalityFn(CGM, Personality), 0); LPadInst->addClause(getCatchAllValue(*this)); llvm::CallInst *terminateCall; if (useClangCallTerminate(CGM)) { // Extract out the exception pointer. llvm::Value *exn = Builder.CreateExtractValue(LPadInst, 0); terminateCall = EmitNounwindRuntimeCall(getClangCallTerminateFn(CGM), exn); } else { terminateCall = EmitNounwindRuntimeCall(getTerminateFn(CGM)); } terminateCall->setDoesNotReturn(); Builder.CreateUnreachable(); // Restore the saved insertion state. Builder.restoreIP(SavedIP); return TerminateLandingPad; } llvm::BasicBlock *CodeGenFunction::getTerminateHandler() { if (TerminateHandler) return TerminateHandler; CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); // Set up the terminate handler. This block is inserted at the very // end of the function by FinishFunction. TerminateHandler = createBasicBlock("terminate.handler"); Builder.SetInsertPoint(TerminateHandler); llvm::CallInst *terminateCall; if (useClangCallTerminate(CGM)) { // Load the exception pointer. llvm::Value *exn = getExceptionFromSlot(); terminateCall = EmitNounwindRuntimeCall(getClangCallTerminateFn(CGM), exn); } else { terminateCall = EmitNounwindRuntimeCall(getTerminateFn(CGM)); } terminateCall->setDoesNotReturn(); Builder.CreateUnreachable(); // Restore the saved insertion state. Builder.restoreIP(SavedIP); return TerminateHandler; } llvm::BasicBlock *CodeGenFunction::getEHResumeBlock(bool isCleanup) { if (EHResumeBlock) return EHResumeBlock; CGBuilderTy::InsertPoint SavedIP = Builder.saveIP(); // We emit a jump to a notional label at the outermost unwind state. EHResumeBlock = createBasicBlock("eh.resume"); Builder.SetInsertPoint(EHResumeBlock); const EHPersonality &Personality = EHPersonality::get(CGM.getLangOpts()); // This can always be a call because we necessarily didn't find // anything on the EH stack which needs our help. const char *RethrowName = Personality.CatchallRethrowFn; if (RethrowName != 0 && !isCleanup) { EmitRuntimeCall(getCatchallRethrowFn(CGM, RethrowName), getExceptionFromSlot()) ->setDoesNotReturn(); } else { switch (CleanupHackLevel) { case CHL_MandatoryCatchall: // In mandatory-catchall mode, we need to use // _Unwind_Resume_or_Rethrow, or whatever the personality's // equivalent is. EmitRuntimeCall(getUnwindResumeOrRethrowFn(), getExceptionFromSlot()) ->setDoesNotReturn(); break; case CHL_MandatoryCleanup: { // In mandatory-cleanup mode, we should use 'resume'. // Recreate the landingpad's return value for the 'resume' instruction. llvm::Value *Exn = getExceptionFromSlot(); llvm::Value *Sel = getSelectorFromSlot(); llvm::Type *LPadType = llvm::StructType::get(Exn->getType(), Sel->getType(), NULL); llvm::Value *LPadVal = llvm::UndefValue::get(LPadType); LPadVal = Builder.CreateInsertValue(LPadVal, Exn, 0, "lpad.val"); LPadVal = Builder.CreateInsertValue(LPadVal, Sel, 1, "lpad.val"); Builder.CreateResume(LPadVal); Builder.restoreIP(SavedIP); return EHResumeBlock; } case CHL_Ideal: // In an idealized mode where we don't have to worry about the // optimizer combining landing pads, we should just use // _Unwind_Resume (or the personality's equivalent). EmitRuntimeCall(getUnwindResumeFn(), getExceptionFromSlot()) ->setDoesNotReturn(); break; } } Builder.CreateUnreachable(); Builder.restoreIP(SavedIP); return EHResumeBlock; } void CodeGenFunction::EmitSEHTryStmt(const SEHTryStmt &S) { CGM.ErrorUnsupported(&S, "SEH __try"); } @