CGException.cpp revision 9d96bce991048fd2337cf058ec6a6a722207cbf2
1//===--- CGException.cpp - Emit LLVM Code for C++ exceptions --------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This contains code dealing with C++ exception related code generation. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/AST/StmtCXX.h" 15 16#include "llvm/Intrinsics.h" 17#include "llvm/IntrinsicInst.h" 18#include "llvm/Support/CallSite.h" 19 20#include "CGObjCRuntime.h" 21#include "CodeGenFunction.h" 22#include "CGException.h" 23#include "CGCleanup.h" 24#include "TargetInfo.h" 25 26using namespace clang; 27using namespace CodeGen; 28 29static llvm::Constant *getAllocateExceptionFn(CodeGenFunction &CGF) { 30 // void *__cxa_allocate_exception(size_t thrown_size); 31 32 const llvm::Type *SizeTy = CGF.ConvertType(CGF.getContext().getSizeType()); 33 const llvm::FunctionType *FTy = 34 llvm::FunctionType::get(llvm::Type::getInt8PtrTy(CGF.getLLVMContext()), 35 SizeTy, /*IsVarArgs=*/false); 36 37 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_allocate_exception"); 38} 39 40static llvm::Constant *getFreeExceptionFn(CodeGenFunction &CGF) { 41 // void __cxa_free_exception(void *thrown_exception); 42 43 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGF.getLLVMContext()); 44 const llvm::FunctionType *FTy = 45 llvm::FunctionType::get(llvm::Type::getVoidTy(CGF.getLLVMContext()), 46 Int8PtrTy, /*IsVarArgs=*/false); 47 48 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_free_exception"); 49} 50 51static llvm::Constant *getThrowFn(CodeGenFunction &CGF) { 52 // void __cxa_throw(void *thrown_exception, std::type_info *tinfo, 53 // void (*dest) (void *)); 54 55 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGF.getLLVMContext()); 56 const llvm::Type *Args[3] = { Int8PtrTy, Int8PtrTy, Int8PtrTy }; 57 const llvm::FunctionType *FTy = 58 llvm::FunctionType::get(llvm::Type::getVoidTy(CGF.getLLVMContext()), 59 Args, /*IsVarArgs=*/false); 60 61 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_throw"); 62} 63 64static llvm::Constant *getReThrowFn(CodeGenFunction &CGF) { 65 // void __cxa_rethrow(); 66 67 const llvm::FunctionType *FTy = 68 llvm::FunctionType::get(llvm::Type::getVoidTy(CGF.getLLVMContext()), 69 /*IsVarArgs=*/false); 70 71 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_rethrow"); 72} 73 74static llvm::Constant *getGetExceptionPtrFn(CodeGenFunction &CGF) { 75 // void *__cxa_get_exception_ptr(void*); 76 77 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGF.getLLVMContext()); 78 const llvm::FunctionType *FTy = 79 llvm::FunctionType::get(Int8PtrTy, Int8PtrTy, /*IsVarArgs=*/false); 80 81 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_get_exception_ptr"); 82} 83 84static llvm::Constant *getBeginCatchFn(CodeGenFunction &CGF) { 85 // void *__cxa_begin_catch(void*); 86 87 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGF.getLLVMContext()); 88 const llvm::FunctionType *FTy = 89 llvm::FunctionType::get(Int8PtrTy, Int8PtrTy, /*IsVarArgs=*/false); 90 91 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_begin_catch"); 92} 93 94static llvm::Constant *getEndCatchFn(CodeGenFunction &CGF) { 95 // void __cxa_end_catch(); 96 97 const llvm::FunctionType *FTy = 98 llvm::FunctionType::get(llvm::Type::getVoidTy(CGF.getLLVMContext()), 99 /*IsVarArgs=*/false); 100 101 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_end_catch"); 102} 103 104static llvm::Constant *getUnexpectedFn(CodeGenFunction &CGF) { 105 // void __cxa_call_unexepcted(void *thrown_exception); 106 107 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGF.getLLVMContext()); 108 const llvm::FunctionType *FTy = 109 llvm::FunctionType::get(llvm::Type::getVoidTy(CGF.getLLVMContext()), 110 Int8PtrTy, /*IsVarArgs=*/false); 111 112 return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_call_unexpected"); 113} 114 115llvm::Constant *CodeGenFunction::getUnwindResumeFn() { 116 const llvm::FunctionType *FTy = 117 llvm::FunctionType::get(VoidTy, Int8PtrTy, /*IsVarArgs=*/false); 118 119 if (CGM.getLangOptions().SjLjExceptions) 120 return CGM.CreateRuntimeFunction(FTy, "_Unwind_SjLj_Resume"); 121 return CGM.CreateRuntimeFunction(FTy, "_Unwind_Resume"); 122} 123 124llvm::Constant *CodeGenFunction::getUnwindResumeOrRethrowFn() { 125 const llvm::FunctionType *FTy = 126 llvm::FunctionType::get(VoidTy, Int8PtrTy, /*IsVarArgs=*/false); 127 128 if (CGM.getLangOptions().SjLjExceptions) 129 return CGM.CreateRuntimeFunction(FTy, "_Unwind_SjLj_Resume_or_Rethrow"); 130 return CGM.CreateRuntimeFunction(FTy, "_Unwind_Resume_or_Rethrow"); 131} 132 133static llvm::Constant *getTerminateFn(CodeGenFunction &CGF) { 134 // void __terminate(); 135 136 const llvm::FunctionType *FTy = 137 llvm::FunctionType::get(llvm::Type::getVoidTy(CGF.getLLVMContext()), 138 /*IsVarArgs=*/false); 139 140 return CGF.CGM.CreateRuntimeFunction(FTy, 141 CGF.CGM.getLangOptions().CPlusPlus ? "_ZSt9terminatev" : "abort"); 142} 143 144static llvm::Constant *getCatchallRethrowFn(CodeGenFunction &CGF, 145 llvm::StringRef Name) { 146 const llvm::Type *Int8PtrTy = 147 llvm::Type::getInt8PtrTy(CGF.getLLVMContext()); 148 const llvm::Type *VoidTy = llvm::Type::getVoidTy(CGF.getLLVMContext()); 149 const llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, Int8PtrTy, 150 /*IsVarArgs=*/false); 151 152 return CGF.CGM.CreateRuntimeFunction(FTy, Name); 153} 154 155const EHPersonality EHPersonality::GNU_C("__gcc_personality_v0"); 156const EHPersonality EHPersonality::GNU_C_SJLJ("__gcc_personality_sj0"); 157const EHPersonality EHPersonality::NeXT_ObjC("__objc_personality_v0"); 158const EHPersonality EHPersonality::GNU_CPlusPlus("__gxx_personality_v0"); 159const EHPersonality EHPersonality::GNU_CPlusPlus_SJLJ("__gxx_personality_sj0"); 160const EHPersonality EHPersonality::GNU_ObjC("__gnu_objc_personality_v0", 161 "objc_exception_throw"); 162const EHPersonality EHPersonality::GNU_ObjCXX("__gnustep_objcxx_personality_v0"); 163 164static const EHPersonality &getCPersonality(const LangOptions &L) { 165 if (L.SjLjExceptions) 166 return EHPersonality::GNU_C_SJLJ; 167 return EHPersonality::GNU_C; 168} 169 170static const EHPersonality &getObjCPersonality(const LangOptions &L) { 171 if (L.NeXTRuntime) { 172 if (L.ObjCNonFragileABI) return EHPersonality::NeXT_ObjC; 173 else return getCPersonality(L); 174 } else { 175 return EHPersonality::GNU_ObjC; 176 } 177} 178 179static const EHPersonality &getCXXPersonality(const LangOptions &L) { 180 if (L.SjLjExceptions) 181 return EHPersonality::GNU_CPlusPlus_SJLJ; 182 else 183 return EHPersonality::GNU_CPlusPlus; 184} 185 186/// Determines the personality function to use when both C++ 187/// and Objective-C exceptions are being caught. 188static const EHPersonality &getObjCXXPersonality(const LangOptions &L) { 189 // The ObjC personality defers to the C++ personality for non-ObjC 190 // handlers. Unlike the C++ case, we use the same personality 191 // function on targets using (backend-driven) SJLJ EH. 192 if (L.NeXTRuntime) { 193 if (L.ObjCNonFragileABI) 194 return EHPersonality::NeXT_ObjC; 195 196 // In the fragile ABI, just use C++ exception handling and hope 197 // they're not doing crazy exception mixing. 198 else 199 return getCXXPersonality(L); 200 } 201 202 // The GNU runtime's personality function inherently doesn't support 203 // mixed EH. Use the C++ personality just to avoid returning null. 204 return EHPersonality::GNU_ObjCXX; 205} 206 207const EHPersonality &EHPersonality::get(const LangOptions &L) { 208 if (L.CPlusPlus && L.ObjC1) 209 return getObjCXXPersonality(L); 210 else if (L.CPlusPlus) 211 return getCXXPersonality(L); 212 else if (L.ObjC1) 213 return getObjCPersonality(L); 214 else 215 return getCPersonality(L); 216} 217 218static llvm::Constant *getPersonalityFn(CodeGenModule &CGM, 219 const EHPersonality &Personality) { 220 llvm::Constant *Fn = 221 CGM.CreateRuntimeFunction(llvm::FunctionType::get( 222 llvm::Type::getInt32Ty(CGM.getLLVMContext()), 223 true), 224 Personality.getPersonalityFnName()); 225 return Fn; 226} 227 228static llvm::Constant *getOpaquePersonalityFn(CodeGenModule &CGM, 229 const EHPersonality &Personality) { 230 llvm::Constant *Fn = getPersonalityFn(CGM, Personality); 231 return llvm::ConstantExpr::getBitCast(Fn, CGM.Int8PtrTy); 232} 233 234/// Check whether a personality function could reasonably be swapped 235/// for a C++ personality function. 236static bool PersonalityHasOnlyCXXUses(llvm::Constant *Fn) { 237 for (llvm::Constant::use_iterator 238 I = Fn->use_begin(), E = Fn->use_end(); I != E; ++I) { 239 llvm::User *User = *I; 240 241 // Conditionally white-list bitcasts. 242 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(User)) { 243 if (CE->getOpcode() != llvm::Instruction::BitCast) return false; 244 if (!PersonalityHasOnlyCXXUses(CE)) 245 return false; 246 continue; 247 } 248 249 // Otherwise, it has to be a selector call. 250 if (!isa<llvm::EHSelectorInst>(User)) return false; 251 252 llvm::EHSelectorInst *Selector = cast<llvm::EHSelectorInst>(User); 253 for (unsigned I = 2, E = Selector->getNumArgOperands(); I != E; ++I) { 254 // Look for something that would've been returned by the ObjC 255 // runtime's GetEHType() method. 256 llvm::GlobalVariable *GV 257 = dyn_cast<llvm::GlobalVariable>(Selector->getArgOperand(I)); 258 if (!GV) continue; 259 260 // ObjC EH selector entries are always global variables with 261 // names starting like this. 262 if (GV->getName().startswith("OBJC_EHTYPE")) 263 return false; 264 } 265 } 266 267 return true; 268} 269 270/// Try to use the C++ personality function in ObjC++. Not doing this 271/// can cause some incompatibilities with gcc, which is more 272/// aggressive about only using the ObjC++ personality in a function 273/// when it really needs it. 274void CodeGenModule::SimplifyPersonality() { 275 // For now, this is really a Darwin-specific operation. 276 if (!Context.Target.getTriple().isOSDarwin()) 277 return; 278 279 // If we're not in ObjC++ -fexceptions, there's nothing to do. 280 if (!Features.CPlusPlus || !Features.ObjC1 || !Features.Exceptions) 281 return; 282 283 const EHPersonality &ObjCXX = EHPersonality::get(Features); 284 const EHPersonality &CXX = getCXXPersonality(Features); 285 if (&ObjCXX == &CXX || 286 ObjCXX.getPersonalityFnName() == CXX.getPersonalityFnName()) 287 return; 288 289 llvm::Function *Fn = 290 getModule().getFunction(ObjCXX.getPersonalityFnName()); 291 292 // Nothing to do if it's unused. 293 if (!Fn || Fn->use_empty()) return; 294 295 // Can't do the optimization if it has non-C++ uses. 296 if (!PersonalityHasOnlyCXXUses(Fn)) return; 297 298 // Create the C++ personality function and kill off the old 299 // function. 300 llvm::Constant *CXXFn = getPersonalityFn(*this, CXX); 301 302 // This can happen if the user is screwing with us. 303 if (Fn->getType() != CXXFn->getType()) return; 304 305 Fn->replaceAllUsesWith(CXXFn); 306 Fn->eraseFromParent(); 307} 308 309/// Returns the value to inject into a selector to indicate the 310/// presence of a catch-all. 311static llvm::Constant *getCatchAllValue(CodeGenFunction &CGF) { 312 // Possibly we should use @llvm.eh.catch.all.value here. 313 return llvm::ConstantPointerNull::get(CGF.Int8PtrTy); 314} 315 316/// Returns the value to inject into a selector to indicate the 317/// presence of a cleanup. 318static llvm::Constant *getCleanupValue(CodeGenFunction &CGF) { 319 return llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0); 320} 321 322namespace { 323 /// A cleanup to free the exception object if its initialization 324 /// throws. 325 struct FreeException { 326 static void Emit(CodeGenFunction &CGF, bool forEH, 327 llvm::Value *exn) { 328 CGF.Builder.CreateCall(getFreeExceptionFn(CGF), exn) 329 ->setDoesNotThrow(); 330 } 331 }; 332} 333 334// Emits an exception expression into the given location. This 335// differs from EmitAnyExprToMem only in that, if a final copy-ctor 336// call is required, an exception within that copy ctor causes 337// std::terminate to be invoked. 338static void EmitAnyExprToExn(CodeGenFunction &CGF, const Expr *e, 339 llvm::Value *addr) { 340 // Make sure the exception object is cleaned up if there's an 341 // exception during initialization. 342 CGF.pushFullExprCleanup<FreeException>(EHCleanup, addr); 343 EHScopeStack::stable_iterator cleanup = CGF.EHStack.stable_begin(); 344 345 // __cxa_allocate_exception returns a void*; we need to cast this 346 // to the appropriate type for the object. 347 const llvm::Type *ty = CGF.ConvertTypeForMem(e->getType())->getPointerTo(); 348 llvm::Value *typedAddr = CGF.Builder.CreateBitCast(addr, ty); 349 350 // FIXME: this isn't quite right! If there's a final unelided call 351 // to a copy constructor, then according to [except.terminate]p1 we 352 // must call std::terminate() if that constructor throws, because 353 // technically that copy occurs after the exception expression is 354 // evaluated but before the exception is caught. But the best way 355 // to handle that is to teach EmitAggExpr to do the final copy 356 // differently if it can't be elided. 357 CGF.EmitAnyExprToMem(e, typedAddr, e->getType().getQualifiers(), 358 /*IsInit*/ true); 359 360 // Deactivate the cleanup block. 361 CGF.DeactivateCleanupBlock(cleanup); 362} 363 364llvm::Value *CodeGenFunction::getExceptionSlot() { 365 if (!ExceptionSlot) 366 ExceptionSlot = CreateTempAlloca(Int8PtrTy, "exn.slot"); 367 return ExceptionSlot; 368} 369 370llvm::Value *CodeGenFunction::getEHSelectorSlot() { 371 if (!EHSelectorSlot) 372 EHSelectorSlot = CreateTempAlloca(Int32Ty, "ehselector.slot"); 373 return EHSelectorSlot; 374} 375 376void CodeGenFunction::EmitCXXThrowExpr(const CXXThrowExpr *E) { 377 if (!E->getSubExpr()) { 378 if (getInvokeDest()) { 379 Builder.CreateInvoke(getReThrowFn(*this), 380 getUnreachableBlock(), 381 getInvokeDest()) 382 ->setDoesNotReturn(); 383 } else { 384 Builder.CreateCall(getReThrowFn(*this))->setDoesNotReturn(); 385 Builder.CreateUnreachable(); 386 } 387 388 // throw is an expression, and the expression emitters expect us 389 // to leave ourselves at a valid insertion point. 390 EmitBlock(createBasicBlock("throw.cont")); 391 392 return; 393 } 394 395 QualType ThrowType = E->getSubExpr()->getType(); 396 397 // Now allocate the exception object. 398 const llvm::Type *SizeTy = ConvertType(getContext().getSizeType()); 399 uint64_t TypeSize = getContext().getTypeSizeInChars(ThrowType).getQuantity(); 400 401 llvm::Constant *AllocExceptionFn = getAllocateExceptionFn(*this); 402 llvm::CallInst *ExceptionPtr = 403 Builder.CreateCall(AllocExceptionFn, 404 llvm::ConstantInt::get(SizeTy, TypeSize), 405 "exception"); 406 ExceptionPtr->setDoesNotThrow(); 407 408 EmitAnyExprToExn(*this, E->getSubExpr(), ExceptionPtr); 409 410 // Now throw the exception. 411 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(getLLVMContext()); 412 llvm::Constant *TypeInfo = CGM.GetAddrOfRTTIDescriptor(ThrowType, 413 /*ForEH=*/true); 414 415 // The address of the destructor. If the exception type has a 416 // trivial destructor (or isn't a record), we just pass null. 417 llvm::Constant *Dtor = 0; 418 if (const RecordType *RecordTy = ThrowType->getAs<RecordType>()) { 419 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordTy->getDecl()); 420 if (!Record->hasTrivialDestructor()) { 421 CXXDestructorDecl *DtorD = Record->getDestructor(); 422 Dtor = CGM.GetAddrOfCXXDestructor(DtorD, Dtor_Complete); 423 Dtor = llvm::ConstantExpr::getBitCast(Dtor, Int8PtrTy); 424 } 425 } 426 if (!Dtor) Dtor = llvm::Constant::getNullValue(Int8PtrTy); 427 428 if (getInvokeDest()) { 429 llvm::InvokeInst *ThrowCall = 430 Builder.CreateInvoke3(getThrowFn(*this), 431 getUnreachableBlock(), getInvokeDest(), 432 ExceptionPtr, TypeInfo, Dtor); 433 ThrowCall->setDoesNotReturn(); 434 } else { 435 llvm::CallInst *ThrowCall = 436 Builder.CreateCall3(getThrowFn(*this), ExceptionPtr, TypeInfo, Dtor); 437 ThrowCall->setDoesNotReturn(); 438 Builder.CreateUnreachable(); 439 } 440 441 // throw is an expression, and the expression emitters expect us 442 // to leave ourselves at a valid insertion point. 443 EmitBlock(createBasicBlock("throw.cont")); 444} 445 446void CodeGenFunction::EmitStartEHSpec(const Decl *D) { 447 if (!CGM.getLangOptions().CXXExceptions) 448 return; 449 450 const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D); 451 if (FD == 0) 452 return; 453 const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>(); 454 if (Proto == 0) 455 return; 456 457 ExceptionSpecificationType EST = Proto->getExceptionSpecType(); 458 if (isNoexceptExceptionSpec(EST)) { 459 if (Proto->getNoexceptSpec(getContext()) == FunctionProtoType::NR_Nothrow) { 460 // noexcept functions are simple terminate scopes. 461 EHStack.pushTerminate(); 462 } 463 } else if (EST == EST_Dynamic || EST == EST_DynamicNone) { 464 unsigned NumExceptions = Proto->getNumExceptions(); 465 EHFilterScope *Filter = EHStack.pushFilter(NumExceptions); 466 467 for (unsigned I = 0; I != NumExceptions; ++I) { 468 QualType Ty = Proto->getExceptionType(I); 469 QualType ExceptType = Ty.getNonReferenceType().getUnqualifiedType(); 470 llvm::Value *EHType = CGM.GetAddrOfRTTIDescriptor(ExceptType, 471 /*ForEH=*/true); 472 Filter->setFilter(I, EHType); 473 } 474 } 475} 476 477void CodeGenFunction::EmitEndEHSpec(const Decl *D) { 478 if (!CGM.getLangOptions().CXXExceptions) 479 return; 480 481 const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D); 482 if (FD == 0) 483 return; 484 const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>(); 485 if (Proto == 0) 486 return; 487 488 ExceptionSpecificationType EST = Proto->getExceptionSpecType(); 489 if (isNoexceptExceptionSpec(EST)) { 490 if (Proto->getNoexceptSpec(getContext()) == FunctionProtoType::NR_Nothrow) { 491 EHStack.popTerminate(); 492 } 493 } else if (EST == EST_Dynamic || EST == EST_DynamicNone) { 494 EHStack.popFilter(); 495 } 496} 497 498void CodeGenFunction::EmitCXXTryStmt(const CXXTryStmt &S) { 499 EnterCXXTryStmt(S); 500 EmitStmt(S.getTryBlock()); 501 ExitCXXTryStmt(S); 502} 503 504void CodeGenFunction::EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) { 505 unsigned NumHandlers = S.getNumHandlers(); 506 EHCatchScope *CatchScope = EHStack.pushCatch(NumHandlers); 507 508 for (unsigned I = 0; I != NumHandlers; ++I) { 509 const CXXCatchStmt *C = S.getHandler(I); 510 511 llvm::BasicBlock *Handler = createBasicBlock("catch"); 512 if (C->getExceptionDecl()) { 513 // FIXME: Dropping the reference type on the type into makes it 514 // impossible to correctly implement catch-by-reference 515 // semantics for pointers. Unfortunately, this is what all 516 // existing compilers do, and it's not clear that the standard 517 // personality routine is capable of doing this right. See C++ DR 388: 518 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#388 519 QualType CaughtType = C->getCaughtType(); 520 CaughtType = CaughtType.getNonReferenceType().getUnqualifiedType(); 521 522 llvm::Value *TypeInfo = 0; 523 if (CaughtType->isObjCObjectPointerType()) 524 TypeInfo = CGM.getObjCRuntime().GetEHType(CaughtType, this); 525 else 526 TypeInfo = CGM.GetAddrOfRTTIDescriptor(CaughtType, /*ForEH=*/true); 527 CatchScope->setHandler(I, TypeInfo, Handler); 528 } else { 529 // No exception decl indicates '...', a catch-all. 530 CatchScope->setCatchAllHandler(I, Handler); 531 } 532 } 533} 534 535/// Check whether this is a non-EH scope, i.e. a scope which doesn't 536/// affect exception handling. Currently, the only non-EH scopes are 537/// normal-only cleanup scopes. 538static bool isNonEHScope(const EHScope &S) { 539 switch (S.getKind()) { 540 case EHScope::Cleanup: 541 return !cast<EHCleanupScope>(S).isEHCleanup(); 542 case EHScope::Filter: 543 case EHScope::Catch: 544 case EHScope::Terminate: 545 return false; 546 } 547 548 // Suppress warning. 549 return false; 550} 551 552llvm::BasicBlock *CodeGenFunction::getInvokeDestImpl() { 553 assert(EHStack.requiresLandingPad()); 554 assert(!EHStack.empty()); 555 556 if (!CGM.getLangOptions().Exceptions) 557 return 0; 558 559 // Check the innermost scope for a cached landing pad. If this is 560 // a non-EH cleanup, we'll check enclosing scopes in EmitLandingPad. 561 llvm::BasicBlock *LP = EHStack.begin()->getCachedLandingPad(); 562 if (LP) return LP; 563 564 // Build the landing pad for this scope. 565 LP = EmitLandingPad(); 566 assert(LP); 567 568 // Cache the landing pad on the innermost scope. If this is a 569 // non-EH scope, cache the landing pad on the enclosing scope, too. 570 for (EHScopeStack::iterator ir = EHStack.begin(); true; ++ir) { 571 ir->setCachedLandingPad(LP); 572 if (!isNonEHScope(*ir)) break; 573 } 574 575 return LP; 576} 577 578// This code contains a hack to work around a design flaw in 579// LLVM's EH IR which breaks semantics after inlining. This same 580// hack is implemented in llvm-gcc. 581// 582// The LLVM EH abstraction is basically a thin veneer over the 583// traditional GCC zero-cost design: for each range of instructions 584// in the function, there is (at most) one "landing pad" with an 585// associated chain of EH actions. A language-specific personality 586// function interprets this chain of actions and (1) decides whether 587// or not to resume execution at the landing pad and (2) if so, 588// provides an integer indicating why it's stopping. In LLVM IR, 589// the association of a landing pad with a range of instructions is 590// achieved via an invoke instruction, the chain of actions becomes 591// the arguments to the @llvm.eh.selector call, and the selector 592// call returns the integer indicator. Other than the required 593// presence of two intrinsic function calls in the landing pad, 594// the IR exactly describes the layout of the output code. 595// 596// A principal advantage of this design is that it is completely 597// language-agnostic; in theory, the LLVM optimizers can treat 598// landing pads neutrally, and targets need only know how to lower 599// the intrinsics to have a functioning exceptions system (assuming 600// that platform exceptions follow something approximately like the 601// GCC design). Unfortunately, landing pads cannot be combined in a 602// language-agnostic way: given selectors A and B, there is no way 603// to make a single landing pad which faithfully represents the 604// semantics of propagating an exception first through A, then 605// through B, without knowing how the personality will interpret the 606// (lowered form of the) selectors. This means that inlining has no 607// choice but to crudely chain invokes (i.e., to ignore invokes in 608// the inlined function, but to turn all unwindable calls into 609// invokes), which is only semantically valid if every unwind stops 610// at every landing pad. 611// 612// Therefore, the invoke-inline hack is to guarantee that every 613// landing pad has a catch-all. 614enum CleanupHackLevel_t { 615 /// A level of hack that requires that all landing pads have 616 /// catch-alls. 617 CHL_MandatoryCatchall, 618 619 /// A level of hack that requires that all landing pads handle 620 /// cleanups. 621 CHL_MandatoryCleanup, 622 623 /// No hacks at all; ideal IR generation. 624 CHL_Ideal 625}; 626const CleanupHackLevel_t CleanupHackLevel = CHL_MandatoryCleanup; 627 628llvm::BasicBlock *CodeGenFunction::EmitLandingPad() { 629 assert(EHStack.requiresLandingPad()); 630 631 for (EHScopeStack::iterator ir = EHStack.begin(); ; ) { 632 assert(ir != EHStack.end() && 633 "stack requiring landing pad is nothing but non-EH scopes?"); 634 635 // If this is a terminate scope, just use the singleton terminate 636 // landing pad. 637 if (isa<EHTerminateScope>(*ir)) 638 return getTerminateLandingPad(); 639 640 // If this isn't an EH scope, iterate; otherwise break out. 641 if (!isNonEHScope(*ir)) break; 642 ++ir; 643 644 // We haven't checked this scope for a cached landing pad yet. 645 if (llvm::BasicBlock *LP = ir->getCachedLandingPad()) 646 return LP; 647 } 648 649 // Save the current IR generation state. 650 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); 651 652 const EHPersonality &Personality = EHPersonality::get(getLangOptions()); 653 654 // Create and configure the landing pad. 655 llvm::BasicBlock *LP = createBasicBlock("lpad"); 656 EmitBlock(LP); 657 658 // Save the exception pointer. It's safe to use a single exception 659 // pointer per function because EH cleanups can never have nested 660 // try/catches. 661 llvm::CallInst *Exn = 662 Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::eh_exception), "exn"); 663 Exn->setDoesNotThrow(); 664 Builder.CreateStore(Exn, getExceptionSlot()); 665 666 // Build the selector arguments. 667 llvm::SmallVector<llvm::Value*, 8> EHSelector; 668 EHSelector.push_back(Exn); 669 EHSelector.push_back(getOpaquePersonalityFn(CGM, Personality)); 670 671 // Accumulate all the handlers in scope. 672 llvm::DenseMap<llvm::Value*, UnwindDest> EHHandlers; 673 UnwindDest CatchAll; 674 bool HasEHCleanup = false; 675 bool HasEHFilter = false; 676 llvm::SmallVector<llvm::Value*, 8> EHFilters; 677 for (EHScopeStack::iterator I = EHStack.begin(), E = EHStack.end(); 678 I != E; ++I) { 679 680 switch (I->getKind()) { 681 case EHScope::Cleanup: 682 if (!HasEHCleanup) 683 HasEHCleanup = cast<EHCleanupScope>(*I).isEHCleanup(); 684 // We otherwise don't care about cleanups. 685 continue; 686 687 case EHScope::Filter: { 688 assert(I.next() == EHStack.end() && "EH filter is not end of EH stack"); 689 assert(!CatchAll.isValid() && "EH filter reached after catch-all"); 690 691 // Filter scopes get added to the selector in weird ways. 692 EHFilterScope &Filter = cast<EHFilterScope>(*I); 693 HasEHFilter = true; 694 695 // Add all the filter values which we aren't already explicitly 696 // catching. 697 for (unsigned I = 0, E = Filter.getNumFilters(); I != E; ++I) { 698 llvm::Value *FV = Filter.getFilter(I); 699 if (!EHHandlers.count(FV)) 700 EHFilters.push_back(FV); 701 } 702 goto done; 703 } 704 705 case EHScope::Terminate: 706 // Terminate scopes are basically catch-alls. 707 assert(!CatchAll.isValid()); 708 CatchAll = UnwindDest(getTerminateHandler(), 709 EHStack.getEnclosingEHCleanup(I), 710 cast<EHTerminateScope>(*I).getDestIndex()); 711 goto done; 712 713 case EHScope::Catch: 714 break; 715 } 716 717 EHCatchScope &Catch = cast<EHCatchScope>(*I); 718 for (unsigned HI = 0, HE = Catch.getNumHandlers(); HI != HE; ++HI) { 719 EHCatchScope::Handler Handler = Catch.getHandler(HI); 720 721 // Catch-all. We should only have one of these per catch. 722 if (!Handler.Type) { 723 assert(!CatchAll.isValid()); 724 CatchAll = UnwindDest(Handler.Block, 725 EHStack.getEnclosingEHCleanup(I), 726 Handler.Index); 727 continue; 728 } 729 730 // Check whether we already have a handler for this type. 731 UnwindDest &Dest = EHHandlers[Handler.Type]; 732 if (Dest.isValid()) continue; 733 734 EHSelector.push_back(Handler.Type); 735 Dest = UnwindDest(Handler.Block, 736 EHStack.getEnclosingEHCleanup(I), 737 Handler.Index); 738 } 739 740 // Stop if we found a catch-all. 741 if (CatchAll.isValid()) break; 742 } 743 744 done: 745 unsigned LastToEmitInLoop = EHSelector.size(); 746 747 // If we have a catch-all, add null to the selector. 748 if (CatchAll.isValid()) { 749 EHSelector.push_back(getCatchAllValue(*this)); 750 751 // If we have an EH filter, we need to add those handlers in the 752 // right place in the selector, which is to say, at the end. 753 } else if (HasEHFilter) { 754 // Create a filter expression: an integer constant saying how many 755 // filters there are (+1 to avoid ambiguity with 0 for cleanup), 756 // followed by the filter types. The personality routine only 757 // lands here if the filter doesn't match. 758 EHSelector.push_back(llvm::ConstantInt::get(Builder.getInt32Ty(), 759 EHFilters.size() + 1)); 760 EHSelector.append(EHFilters.begin(), EHFilters.end()); 761 762 // Also check whether we need a cleanup. 763 if (CleanupHackLevel == CHL_MandatoryCatchall || HasEHCleanup) 764 EHSelector.push_back(CleanupHackLevel == CHL_MandatoryCatchall 765 ? getCatchAllValue(*this) 766 : getCleanupValue(*this)); 767 768 // Otherwise, signal that we at least have cleanups. 769 } else if (CleanupHackLevel == CHL_MandatoryCatchall || HasEHCleanup) { 770 EHSelector.push_back(CleanupHackLevel == CHL_MandatoryCatchall 771 ? getCatchAllValue(*this) 772 : getCleanupValue(*this)); 773 774 // At the MandatoryCleanup hack level, we don't need to actually 775 // spuriously tell the unwinder that we have cleanups, but we do 776 // need to always be prepared to handle cleanups. 777 } else if (CleanupHackLevel == CHL_MandatoryCleanup) { 778 // Just don't decrement LastToEmitInLoop. 779 780 } else { 781 assert(LastToEmitInLoop > 2); 782 LastToEmitInLoop--; 783 } 784 785 assert(EHSelector.size() >= 3 && "selector call has only two arguments!"); 786 787 // Tell the backend how to generate the landing pad. 788 llvm::CallInst *Selection = 789 Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::eh_selector), 790 EHSelector.begin(), EHSelector.end(), "eh.selector"); 791 Selection->setDoesNotThrow(); 792 793 // Save the selector value in mandatory-cleanup mode. 794 if (CleanupHackLevel == CHL_MandatoryCleanup) 795 Builder.CreateStore(Selection, getEHSelectorSlot()); 796 797 // Select the right handler. 798 llvm::Value *llvm_eh_typeid_for = 799 CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for); 800 801 // The results of llvm_eh_typeid_for aren't reliable --- at least 802 // not locally --- so we basically have to do this as an 'if' chain. 803 // We walk through the first N-1 catch clauses, testing and chaining, 804 // and then fall into the final clause (which is either a cleanup, a 805 // filter (possibly with a cleanup), a catch-all, or another catch). 806 for (unsigned I = 2; I != LastToEmitInLoop; ++I) { 807 llvm::Value *Type = EHSelector[I]; 808 UnwindDest Dest = EHHandlers[Type]; 809 assert(Dest.isValid() && "no handler entry for value in selector?"); 810 811 // Figure out where to branch on a match. As a debug code-size 812 // optimization, if the scope depth matches the innermost cleanup, 813 // we branch directly to the catch handler. 814 llvm::BasicBlock *Match = Dest.getBlock(); 815 bool MatchNeedsCleanup = 816 Dest.getScopeDepth() != EHStack.getInnermostEHCleanup(); 817 if (MatchNeedsCleanup) 818 Match = createBasicBlock("eh.match"); 819 820 llvm::BasicBlock *Next = createBasicBlock("eh.next"); 821 822 // Check whether the exception matches. 823 llvm::CallInst *Id 824 = Builder.CreateCall(llvm_eh_typeid_for, 825 Builder.CreateBitCast(Type, Int8PtrTy)); 826 Id->setDoesNotThrow(); 827 Builder.CreateCondBr(Builder.CreateICmpEQ(Selection, Id), 828 Match, Next); 829 830 // Emit match code if necessary. 831 if (MatchNeedsCleanup) { 832 EmitBlock(Match); 833 EmitBranchThroughEHCleanup(Dest); 834 } 835 836 // Continue to the next match. 837 EmitBlock(Next); 838 } 839 840 // Emit the final case in the selector. 841 // This might be a catch-all.... 842 if (CatchAll.isValid()) { 843 assert(isa<llvm::ConstantPointerNull>(EHSelector.back())); 844 EmitBranchThroughEHCleanup(CatchAll); 845 846 // ...or an EH filter... 847 } else if (HasEHFilter) { 848 llvm::Value *SavedSelection = Selection; 849 850 // First, unwind out to the outermost scope if necessary. 851 if (EHStack.hasEHCleanups()) { 852 // The end here might not dominate the beginning, so we might need to 853 // save the selector if we need it. 854 llvm::AllocaInst *SelectorVar = 0; 855 if (HasEHCleanup) { 856 SelectorVar = CreateTempAlloca(Builder.getInt32Ty(), "selector.var"); 857 Builder.CreateStore(Selection, SelectorVar); 858 } 859 860 llvm::BasicBlock *CleanupContBB = createBasicBlock("ehspec.cleanup.cont"); 861 EmitBranchThroughEHCleanup(UnwindDest(CleanupContBB, EHStack.stable_end(), 862 EHStack.getNextEHDestIndex())); 863 EmitBlock(CleanupContBB); 864 865 if (HasEHCleanup) 866 SavedSelection = Builder.CreateLoad(SelectorVar, "ehspec.saved-selector"); 867 } 868 869 // If there was a cleanup, we'll need to actually check whether we 870 // landed here because the filter triggered. 871 if (CleanupHackLevel != CHL_Ideal || HasEHCleanup) { 872 llvm::BasicBlock *UnexpectedBB = createBasicBlock("ehspec.unexpected"); 873 874 llvm::Constant *Zero = llvm::ConstantInt::get(Int32Ty, 0); 875 llvm::Value *FailsFilter = 876 Builder.CreateICmpSLT(SavedSelection, Zero, "ehspec.fails"); 877 Builder.CreateCondBr(FailsFilter, UnexpectedBB, getRethrowDest().getBlock()); 878 879 EmitBlock(UnexpectedBB); 880 } 881 882 // Call __cxa_call_unexpected. This doesn't need to be an invoke 883 // because __cxa_call_unexpected magically filters exceptions 884 // according to the last landing pad the exception was thrown 885 // into. Seriously. 886 Builder.CreateCall(getUnexpectedFn(*this), 887 Builder.CreateLoad(getExceptionSlot())) 888 ->setDoesNotReturn(); 889 Builder.CreateUnreachable(); 890 891 // ...or a normal catch handler... 892 } else if (CleanupHackLevel == CHL_Ideal && !HasEHCleanup) { 893 llvm::Value *Type = EHSelector.back(); 894 EmitBranchThroughEHCleanup(EHHandlers[Type]); 895 896 // ...or a cleanup. 897 } else { 898 EmitBranchThroughEHCleanup(getRethrowDest()); 899 } 900 901 // Restore the old IR generation state. 902 Builder.restoreIP(SavedIP); 903 904 return LP; 905} 906 907namespace { 908 /// A cleanup to call __cxa_end_catch. In many cases, the caught 909 /// exception type lets us state definitively that the thrown exception 910 /// type does not have a destructor. In particular: 911 /// - Catch-alls tell us nothing, so we have to conservatively 912 /// assume that the thrown exception might have a destructor. 913 /// - Catches by reference behave according to their base types. 914 /// - Catches of non-record types will only trigger for exceptions 915 /// of non-record types, which never have destructors. 916 /// - Catches of record types can trigger for arbitrary subclasses 917 /// of the caught type, so we have to assume the actual thrown 918 /// exception type might have a throwing destructor, even if the 919 /// caught type's destructor is trivial or nothrow. 920 struct CallEndCatch : EHScopeStack::Cleanup { 921 CallEndCatch(bool MightThrow) : MightThrow(MightThrow) {} 922 bool MightThrow; 923 924 void Emit(CodeGenFunction &CGF, bool IsForEH) { 925 if (!MightThrow) { 926 CGF.Builder.CreateCall(getEndCatchFn(CGF))->setDoesNotThrow(); 927 return; 928 } 929 930 CGF.EmitCallOrInvoke(getEndCatchFn(CGF), 0, 0); 931 } 932 }; 933} 934 935/// Emits a call to __cxa_begin_catch and enters a cleanup to call 936/// __cxa_end_catch. 937/// 938/// \param EndMightThrow - true if __cxa_end_catch might throw 939static llvm::Value *CallBeginCatch(CodeGenFunction &CGF, 940 llvm::Value *Exn, 941 bool EndMightThrow) { 942 llvm::CallInst *Call = CGF.Builder.CreateCall(getBeginCatchFn(CGF), Exn); 943 Call->setDoesNotThrow(); 944 945 CGF.EHStack.pushCleanup<CallEndCatch>(NormalAndEHCleanup, EndMightThrow); 946 947 return Call; 948} 949 950/// A "special initializer" callback for initializing a catch 951/// parameter during catch initialization. 952static void InitCatchParam(CodeGenFunction &CGF, 953 const VarDecl &CatchParam, 954 llvm::Value *ParamAddr) { 955 // Load the exception from where the landing pad saved it. 956 llvm::Value *Exn = CGF.Builder.CreateLoad(CGF.getExceptionSlot(), "exn"); 957 958 CanQualType CatchType = 959 CGF.CGM.getContext().getCanonicalType(CatchParam.getType()); 960 const llvm::Type *LLVMCatchTy = CGF.ConvertTypeForMem(CatchType); 961 962 // If we're catching by reference, we can just cast the object 963 // pointer to the appropriate pointer. 964 if (isa<ReferenceType>(CatchType)) { 965 QualType CaughtType = cast<ReferenceType>(CatchType)->getPointeeType(); 966 bool EndCatchMightThrow = CaughtType->isRecordType(); 967 968 // __cxa_begin_catch returns the adjusted object pointer. 969 llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, EndCatchMightThrow); 970 971 // We have no way to tell the personality function that we're 972 // catching by reference, so if we're catching a pointer, 973 // __cxa_begin_catch will actually return that pointer by value. 974 if (const PointerType *PT = dyn_cast<PointerType>(CaughtType)) { 975 QualType PointeeType = PT->getPointeeType(); 976 977 // When catching by reference, generally we should just ignore 978 // this by-value pointer and use the exception object instead. 979 if (!PointeeType->isRecordType()) { 980 981 // Exn points to the struct _Unwind_Exception header, which 982 // we have to skip past in order to reach the exception data. 983 unsigned HeaderSize = 984 CGF.CGM.getTargetCodeGenInfo().getSizeOfUnwindException(); 985 AdjustedExn = CGF.Builder.CreateConstGEP1_32(Exn, HeaderSize); 986 987 // However, if we're catching a pointer-to-record type that won't 988 // work, because the personality function might have adjusted 989 // the pointer. There's actually no way for us to fully satisfy 990 // the language/ABI contract here: we can't use Exn because it 991 // might have the wrong adjustment, but we can't use the by-value 992 // pointer because it's off by a level of abstraction. 993 // 994 // The current solution is to dump the adjusted pointer into an 995 // alloca, which breaks language semantics (because changing the 996 // pointer doesn't change the exception) but at least works. 997 // The better solution would be to filter out non-exact matches 998 // and rethrow them, but this is tricky because the rethrow 999 // really needs to be catchable by other sites at this landing 1000 // pad. The best solution is to fix the personality function. 1001 } else { 1002 // Pull the pointer for the reference type off. 1003 const llvm::Type *PtrTy = 1004 cast<llvm::PointerType>(LLVMCatchTy)->getElementType(); 1005 1006 // Create the temporary and write the adjusted pointer into it. 1007 llvm::Value *ExnPtrTmp = CGF.CreateTempAlloca(PtrTy, "exn.byref.tmp"); 1008 llvm::Value *Casted = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy); 1009 CGF.Builder.CreateStore(Casted, ExnPtrTmp); 1010 1011 // Bind the reference to the temporary. 1012 AdjustedExn = ExnPtrTmp; 1013 } 1014 } 1015 1016 llvm::Value *ExnCast = 1017 CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.byref"); 1018 CGF.Builder.CreateStore(ExnCast, ParamAddr); 1019 return; 1020 } 1021 1022 // Non-aggregates (plus complexes). 1023 bool IsComplex = false; 1024 if (!CGF.hasAggregateLLVMType(CatchType) || 1025 (IsComplex = CatchType->isAnyComplexType())) { 1026 llvm::Value *AdjustedExn = CallBeginCatch(CGF, Exn, false); 1027 1028 // If the catch type is a pointer type, __cxa_begin_catch returns 1029 // the pointer by value. 1030 if (CatchType->hasPointerRepresentation()) { 1031 llvm::Value *CastExn = 1032 CGF.Builder.CreateBitCast(AdjustedExn, LLVMCatchTy, "exn.casted"); 1033 CGF.Builder.CreateStore(CastExn, ParamAddr); 1034 return; 1035 } 1036 1037 // Otherwise, it returns a pointer into the exception object. 1038 1039 const llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok 1040 llvm::Value *Cast = CGF.Builder.CreateBitCast(AdjustedExn, PtrTy); 1041 1042 if (IsComplex) { 1043 CGF.StoreComplexToAddr(CGF.LoadComplexFromAddr(Cast, /*volatile*/ false), 1044 ParamAddr, /*volatile*/ false); 1045 } else { 1046 unsigned Alignment = 1047 CGF.getContext().getDeclAlign(&CatchParam).getQuantity(); 1048 llvm::Value *ExnLoad = CGF.Builder.CreateLoad(Cast, "exn.scalar"); 1049 CGF.EmitStoreOfScalar(ExnLoad, ParamAddr, /*volatile*/ false, Alignment, 1050 CatchType); 1051 } 1052 return; 1053 } 1054 1055 assert(isa<RecordType>(CatchType) && "unexpected catch type!"); 1056 1057 const llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok 1058 1059 // Check for a copy expression. If we don't have a copy expression, 1060 // that means a trivial copy is okay. 1061 const Expr *copyExpr = CatchParam.getInit(); 1062 if (!copyExpr) { 1063 llvm::Value *rawAdjustedExn = CallBeginCatch(CGF, Exn, true); 1064 llvm::Value *adjustedExn = CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy); 1065 CGF.EmitAggregateCopy(ParamAddr, adjustedExn, CatchType); 1066 return; 1067 } 1068 1069 // We have to call __cxa_get_exception_ptr to get the adjusted 1070 // pointer before copying. 1071 llvm::CallInst *rawAdjustedExn = 1072 CGF.Builder.CreateCall(getGetExceptionPtrFn(CGF), Exn); 1073 rawAdjustedExn->setDoesNotThrow(); 1074 1075 // Cast that to the appropriate type. 1076 llvm::Value *adjustedExn = CGF.Builder.CreateBitCast(rawAdjustedExn, PtrTy); 1077 1078 // The copy expression is defined in terms of an OpaqueValueExpr. 1079 // Find it and map it to the adjusted expression. 1080 CodeGenFunction::OpaqueValueMapping 1081 opaque(CGF, OpaqueValueExpr::findInCopyConstruct(copyExpr), 1082 CGF.MakeAddrLValue(adjustedExn, CatchParam.getType())); 1083 1084 // Call the copy ctor in a terminate scope. 1085 CGF.EHStack.pushTerminate(); 1086 1087 // Perform the copy construction. 1088 CGF.EmitAggExpr(copyExpr, AggValueSlot::forAddr(ParamAddr, Qualifiers(), 1089 false)); 1090 1091 // Leave the terminate scope. 1092 CGF.EHStack.popTerminate(); 1093 1094 // Undo the opaque value mapping. 1095 opaque.pop(); 1096 1097 // Finally we can call __cxa_begin_catch. 1098 CallBeginCatch(CGF, Exn, true); 1099} 1100 1101/// Begins a catch statement by initializing the catch variable and 1102/// calling __cxa_begin_catch. 1103static void BeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *S) { 1104 // We have to be very careful with the ordering of cleanups here: 1105 // C++ [except.throw]p4: 1106 // The destruction [of the exception temporary] occurs 1107 // immediately after the destruction of the object declared in 1108 // the exception-declaration in the handler. 1109 // 1110 // So the precise ordering is: 1111 // 1. Construct catch variable. 1112 // 2. __cxa_begin_catch 1113 // 3. Enter __cxa_end_catch cleanup 1114 // 4. Enter dtor cleanup 1115 // 1116 // We do this by using a slightly abnormal initialization process. 1117 // Delegation sequence: 1118 // - ExitCXXTryStmt opens a RunCleanupsScope 1119 // - EmitAutoVarAlloca creates the variable and debug info 1120 // - InitCatchParam initializes the variable from the exception 1121 // - CallBeginCatch calls __cxa_begin_catch 1122 // - CallBeginCatch enters the __cxa_end_catch cleanup 1123 // - EmitAutoVarCleanups enters the variable destructor cleanup 1124 // - EmitCXXTryStmt emits the code for the catch body 1125 // - EmitCXXTryStmt close the RunCleanupsScope 1126 1127 VarDecl *CatchParam = S->getExceptionDecl(); 1128 if (!CatchParam) { 1129 llvm::Value *Exn = CGF.Builder.CreateLoad(CGF.getExceptionSlot(), "exn"); 1130 CallBeginCatch(CGF, Exn, true); 1131 return; 1132 } 1133 1134 // Emit the local. 1135 CodeGenFunction::AutoVarEmission var = CGF.EmitAutoVarAlloca(*CatchParam); 1136 InitCatchParam(CGF, *CatchParam, var.getObjectAddress(CGF)); 1137 CGF.EmitAutoVarCleanups(var); 1138} 1139 1140namespace { 1141 struct CallRethrow : EHScopeStack::Cleanup { 1142 void Emit(CodeGenFunction &CGF, bool IsForEH) { 1143 CGF.EmitCallOrInvoke(getReThrowFn(CGF), 0, 0); 1144 } 1145 }; 1146} 1147 1148void CodeGenFunction::ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) { 1149 unsigned NumHandlers = S.getNumHandlers(); 1150 EHCatchScope &CatchScope = cast<EHCatchScope>(*EHStack.begin()); 1151 assert(CatchScope.getNumHandlers() == NumHandlers); 1152 1153 // Copy the handler blocks off before we pop the EH stack. Emitting 1154 // the handlers might scribble on this memory. 1155 llvm::SmallVector<EHCatchScope::Handler, 8> Handlers(NumHandlers); 1156 memcpy(Handlers.data(), CatchScope.begin(), 1157 NumHandlers * sizeof(EHCatchScope::Handler)); 1158 EHStack.popCatch(); 1159 1160 // The fall-through block. 1161 llvm::BasicBlock *ContBB = createBasicBlock("try.cont"); 1162 1163 // We just emitted the body of the try; jump to the continue block. 1164 if (HaveInsertPoint()) 1165 Builder.CreateBr(ContBB); 1166 1167 // Determine if we need an implicit rethrow for all these catch handlers. 1168 bool ImplicitRethrow = false; 1169 if (IsFnTryBlock) 1170 ImplicitRethrow = isa<CXXDestructorDecl>(CurCodeDecl) || 1171 isa<CXXConstructorDecl>(CurCodeDecl); 1172 1173 for (unsigned I = 0; I != NumHandlers; ++I) { 1174 llvm::BasicBlock *CatchBlock = Handlers[I].Block; 1175 EmitBlock(CatchBlock); 1176 1177 // Catch the exception if this isn't a catch-all. 1178 const CXXCatchStmt *C = S.getHandler(I); 1179 1180 // Enter a cleanup scope, including the catch variable and the 1181 // end-catch. 1182 RunCleanupsScope CatchScope(*this); 1183 1184 // Initialize the catch variable and set up the cleanups. 1185 BeginCatch(*this, C); 1186 1187 // If there's an implicit rethrow, push a normal "cleanup" to call 1188 // _cxa_rethrow. This needs to happen before __cxa_end_catch is 1189 // called, and so it is pushed after BeginCatch. 1190 if (ImplicitRethrow) 1191 EHStack.pushCleanup<CallRethrow>(NormalCleanup); 1192 1193 // Perform the body of the catch. 1194 EmitStmt(C->getHandlerBlock()); 1195 1196 // Fall out through the catch cleanups. 1197 CatchScope.ForceCleanup(); 1198 1199 // Branch out of the try. 1200 if (HaveInsertPoint()) 1201 Builder.CreateBr(ContBB); 1202 } 1203 1204 EmitBlock(ContBB); 1205} 1206 1207namespace { 1208 struct CallEndCatchForFinally : EHScopeStack::Cleanup { 1209 llvm::Value *ForEHVar; 1210 llvm::Value *EndCatchFn; 1211 CallEndCatchForFinally(llvm::Value *ForEHVar, llvm::Value *EndCatchFn) 1212 : ForEHVar(ForEHVar), EndCatchFn(EndCatchFn) {} 1213 1214 void Emit(CodeGenFunction &CGF, bool IsForEH) { 1215 llvm::BasicBlock *EndCatchBB = CGF.createBasicBlock("finally.endcatch"); 1216 llvm::BasicBlock *CleanupContBB = 1217 CGF.createBasicBlock("finally.cleanup.cont"); 1218 1219 llvm::Value *ShouldEndCatch = 1220 CGF.Builder.CreateLoad(ForEHVar, "finally.endcatch"); 1221 CGF.Builder.CreateCondBr(ShouldEndCatch, EndCatchBB, CleanupContBB); 1222 CGF.EmitBlock(EndCatchBB); 1223 CGF.EmitCallOrInvoke(EndCatchFn, 0, 0); // catch-all, so might throw 1224 CGF.EmitBlock(CleanupContBB); 1225 } 1226 }; 1227 1228 struct PerformFinally : EHScopeStack::Cleanup { 1229 const Stmt *Body; 1230 llvm::Value *ForEHVar; 1231 llvm::Value *EndCatchFn; 1232 llvm::Value *RethrowFn; 1233 llvm::Value *SavedExnVar; 1234 1235 PerformFinally(const Stmt *Body, llvm::Value *ForEHVar, 1236 llvm::Value *EndCatchFn, 1237 llvm::Value *RethrowFn, llvm::Value *SavedExnVar) 1238 : Body(Body), ForEHVar(ForEHVar), EndCatchFn(EndCatchFn), 1239 RethrowFn(RethrowFn), SavedExnVar(SavedExnVar) {} 1240 1241 void Emit(CodeGenFunction &CGF, bool IsForEH) { 1242 // Enter a cleanup to call the end-catch function if one was provided. 1243 if (EndCatchFn) 1244 CGF.EHStack.pushCleanup<CallEndCatchForFinally>(NormalAndEHCleanup, 1245 ForEHVar, EndCatchFn); 1246 1247 // Save the current cleanup destination in case there are 1248 // cleanups in the finally block. 1249 llvm::Value *SavedCleanupDest = 1250 CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot(), 1251 "cleanup.dest.saved"); 1252 1253 // Emit the finally block. 1254 CGF.EmitStmt(Body); 1255 1256 // If the end of the finally is reachable, check whether this was 1257 // for EH. If so, rethrow. 1258 if (CGF.HaveInsertPoint()) { 1259 llvm::BasicBlock *RethrowBB = CGF.createBasicBlock("finally.rethrow"); 1260 llvm::BasicBlock *ContBB = CGF.createBasicBlock("finally.cont"); 1261 1262 llvm::Value *ShouldRethrow = 1263 CGF.Builder.CreateLoad(ForEHVar, "finally.shouldthrow"); 1264 CGF.Builder.CreateCondBr(ShouldRethrow, RethrowBB, ContBB); 1265 1266 CGF.EmitBlock(RethrowBB); 1267 if (SavedExnVar) { 1268 llvm::Value *Args[] = { CGF.Builder.CreateLoad(SavedExnVar) }; 1269 CGF.EmitCallOrInvoke(RethrowFn, Args, Args+1); 1270 } else { 1271 CGF.EmitCallOrInvoke(RethrowFn, 0, 0); 1272 } 1273 CGF.Builder.CreateUnreachable(); 1274 1275 CGF.EmitBlock(ContBB); 1276 1277 // Restore the cleanup destination. 1278 CGF.Builder.CreateStore(SavedCleanupDest, 1279 CGF.getNormalCleanupDestSlot()); 1280 } 1281 1282 // Leave the end-catch cleanup. As an optimization, pretend that 1283 // the fallthrough path was inaccessible; we've dynamically proven 1284 // that we're not in the EH case along that path. 1285 if (EndCatchFn) { 1286 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP(); 1287 CGF.PopCleanupBlock(); 1288 CGF.Builder.restoreIP(SavedIP); 1289 } 1290 1291 // Now make sure we actually have an insertion point or the 1292 // cleanup gods will hate us. 1293 CGF.EnsureInsertPoint(); 1294 } 1295 }; 1296} 1297 1298/// Enters a finally block for an implementation using zero-cost 1299/// exceptions. This is mostly general, but hard-codes some 1300/// language/ABI-specific behavior in the catch-all sections. 1301void CodeGenFunction::FinallyInfo::enter(CodeGenFunction &CGF, 1302 const Stmt *body, 1303 llvm::Constant *beginCatchFn, 1304 llvm::Constant *endCatchFn, 1305 llvm::Constant *rethrowFn) { 1306 assert((beginCatchFn != 0) == (endCatchFn != 0) && 1307 "begin/end catch functions not paired"); 1308 assert(rethrowFn && "rethrow function is required"); 1309 1310 BeginCatchFn = beginCatchFn; 1311 1312 // The rethrow function has one of the following two types: 1313 // void (*)() 1314 // void (*)(void*) 1315 // In the latter case we need to pass it the exception object. 1316 // But we can't use the exception slot because the @finally might 1317 // have a landing pad (which would overwrite the exception slot). 1318 const llvm::FunctionType *rethrowFnTy = 1319 cast<llvm::FunctionType>( 1320 cast<llvm::PointerType>(rethrowFn->getType())->getElementType()); 1321 SavedExnVar = 0; 1322 if (rethrowFnTy->getNumParams()) 1323 SavedExnVar = CGF.CreateTempAlloca(CGF.Int8PtrTy, "finally.exn"); 1324 1325 // A finally block is a statement which must be executed on any edge 1326 // out of a given scope. Unlike a cleanup, the finally block may 1327 // contain arbitrary control flow leading out of itself. In 1328 // addition, finally blocks should always be executed, even if there 1329 // are no catch handlers higher on the stack. Therefore, we 1330 // surround the protected scope with a combination of a normal 1331 // cleanup (to catch attempts to break out of the block via normal 1332 // control flow) and an EH catch-all (semantically "outside" any try 1333 // statement to which the finally block might have been attached). 1334 // The finally block itself is generated in the context of a cleanup 1335 // which conditionally leaves the catch-all. 1336 1337 // Jump destination for performing the finally block on an exception 1338 // edge. We'll never actually reach this block, so unreachable is 1339 // fine. 1340 RethrowDest = CGF.getJumpDestInCurrentScope(CGF.getUnreachableBlock()); 1341 1342 // Whether the finally block is being executed for EH purposes. 1343 ForEHVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), "finally.for-eh"); 1344 CGF.Builder.CreateStore(CGF.Builder.getFalse(), ForEHVar); 1345 1346 // Enter a normal cleanup which will perform the @finally block. 1347 CGF.EHStack.pushCleanup<PerformFinally>(NormalCleanup, body, 1348 ForEHVar, endCatchFn, 1349 rethrowFn, SavedExnVar); 1350 1351 // Enter a catch-all scope. 1352 llvm::BasicBlock *catchBB = CGF.createBasicBlock("finally.catchall"); 1353 EHCatchScope *catchScope = CGF.EHStack.pushCatch(1); 1354 catchScope->setCatchAllHandler(0, catchBB); 1355} 1356 1357void CodeGenFunction::FinallyInfo::exit(CodeGenFunction &CGF) { 1358 // Leave the finally catch-all. 1359 EHCatchScope &catchScope = cast<EHCatchScope>(*CGF.EHStack.begin()); 1360 llvm::BasicBlock *catchBB = catchScope.getHandler(0).Block; 1361 CGF.EHStack.popCatch(); 1362 1363 // If there are any references to the catch-all block, emit it. 1364 if (catchBB->use_empty()) { 1365 delete catchBB; 1366 } else { 1367 CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveAndClearIP(); 1368 CGF.EmitBlock(catchBB); 1369 1370 llvm::Value *exn = 0; 1371 1372 // If there's a begin-catch function, call it. 1373 if (BeginCatchFn) { 1374 exn = CGF.Builder.CreateLoad(CGF.getExceptionSlot()); 1375 CGF.Builder.CreateCall(BeginCatchFn, exn)->setDoesNotThrow(); 1376 } 1377 1378 // If we need to remember the exception pointer to rethrow later, do so. 1379 if (SavedExnVar) { 1380 if (!exn) exn = CGF.Builder.CreateLoad(CGF.getExceptionSlot()); 1381 CGF.Builder.CreateStore(exn, SavedExnVar); 1382 } 1383 1384 // Tell the cleanups in the finally block that we're do this for EH. 1385 CGF.Builder.CreateStore(CGF.Builder.getTrue(), ForEHVar); 1386 1387 // Thread a jump through the finally cleanup. 1388 CGF.EmitBranchThroughCleanup(RethrowDest); 1389 1390 CGF.Builder.restoreIP(savedIP); 1391 } 1392 1393 // Finally, leave the @finally cleanup. 1394 CGF.PopCleanupBlock(); 1395} 1396 1397llvm::BasicBlock *CodeGenFunction::getTerminateLandingPad() { 1398 if (TerminateLandingPad) 1399 return TerminateLandingPad; 1400 1401 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); 1402 1403 // This will get inserted at the end of the function. 1404 TerminateLandingPad = createBasicBlock("terminate.lpad"); 1405 Builder.SetInsertPoint(TerminateLandingPad); 1406 1407 // Tell the backend that this is a landing pad. 1408 llvm::CallInst *Exn = 1409 Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::eh_exception), "exn"); 1410 Exn->setDoesNotThrow(); 1411 1412 const EHPersonality &Personality = EHPersonality::get(CGM.getLangOptions()); 1413 1414 // Tell the backend what the exception table should be: 1415 // nothing but a catch-all. 1416 llvm::Value *Args[3] = { Exn, getOpaquePersonalityFn(CGM, Personality), 1417 getCatchAllValue(*this) }; 1418 Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::eh_selector), 1419 Args, Args+3, "eh.selector") 1420 ->setDoesNotThrow(); 1421 1422 llvm::CallInst *TerminateCall = Builder.CreateCall(getTerminateFn(*this)); 1423 TerminateCall->setDoesNotReturn(); 1424 TerminateCall->setDoesNotThrow(); 1425 Builder.CreateUnreachable(); 1426 1427 // Restore the saved insertion state. 1428 Builder.restoreIP(SavedIP); 1429 1430 return TerminateLandingPad; 1431} 1432 1433llvm::BasicBlock *CodeGenFunction::getTerminateHandler() { 1434 if (TerminateHandler) 1435 return TerminateHandler; 1436 1437 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); 1438 1439 // Set up the terminate handler. This block is inserted at the very 1440 // end of the function by FinishFunction. 1441 TerminateHandler = createBasicBlock("terminate.handler"); 1442 Builder.SetInsertPoint(TerminateHandler); 1443 llvm::CallInst *TerminateCall = Builder.CreateCall(getTerminateFn(*this)); 1444 TerminateCall->setDoesNotReturn(); 1445 TerminateCall->setDoesNotThrow(); 1446 Builder.CreateUnreachable(); 1447 1448 // Restore the saved insertion state. 1449 Builder.restoreIP(SavedIP); 1450 1451 return TerminateHandler; 1452} 1453 1454CodeGenFunction::UnwindDest CodeGenFunction::getRethrowDest() { 1455 if (RethrowBlock.isValid()) return RethrowBlock; 1456 1457 CGBuilderTy::InsertPoint SavedIP = Builder.saveIP(); 1458 1459 // We emit a jump to a notional label at the outermost unwind state. 1460 llvm::BasicBlock *Unwind = createBasicBlock("eh.resume"); 1461 Builder.SetInsertPoint(Unwind); 1462 1463 const EHPersonality &Personality = EHPersonality::get(CGM.getLangOptions()); 1464 1465 // This can always be a call because we necessarily didn't find 1466 // anything on the EH stack which needs our help. 1467 llvm::StringRef RethrowName = Personality.getCatchallRethrowFnName(); 1468 if (!RethrowName.empty()) { 1469 Builder.CreateCall(getCatchallRethrowFn(*this, RethrowName), 1470 Builder.CreateLoad(getExceptionSlot())) 1471 ->setDoesNotReturn(); 1472 } else { 1473 llvm::Value *Exn = Builder.CreateLoad(getExceptionSlot()); 1474 1475 switch (CleanupHackLevel) { 1476 case CHL_MandatoryCatchall: 1477 // In mandatory-catchall mode, we need to use 1478 // _Unwind_Resume_or_Rethrow, or whatever the personality's 1479 // equivalent is. 1480 Builder.CreateCall(getUnwindResumeOrRethrowFn(), Exn) 1481 ->setDoesNotReturn(); 1482 break; 1483 case CHL_MandatoryCleanup: { 1484 // In mandatory-cleanup mode, we should use llvm.eh.resume. 1485 llvm::Value *Selector = Builder.CreateLoad(getEHSelectorSlot()); 1486 Builder.CreateCall2(CGM.getIntrinsic(llvm::Intrinsic::eh_resume), 1487 Exn, Selector) 1488 ->setDoesNotReturn(); 1489 break; 1490 } 1491 case CHL_Ideal: 1492 // In an idealized mode where we don't have to worry about the 1493 // optimizer combining landing pads, we should just use 1494 // _Unwind_Resume (or the personality's equivalent). 1495 Builder.CreateCall(getUnwindResumeFn(), Exn) 1496 ->setDoesNotReturn(); 1497 break; 1498 } 1499 } 1500 1501 Builder.CreateUnreachable(); 1502 1503 Builder.restoreIP(SavedIP); 1504 1505 RethrowBlock = UnwindDest(Unwind, EHStack.stable_end(), 0); 1506 return RethrowBlock; 1507} 1508 1509