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