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