1 //===--- CGException.cpp - Emit LLVM Code for C++ exceptions ----*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This contains code dealing with C++ exception related code generation. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "CGCXXABI.h" 14 #include "CGCleanup.h" 15 #include "CGObjCRuntime.h" 16 #include "CodeGenFunction.h" 17 #include "ConstantEmitter.h" 18 #include "TargetInfo.h" 19 #include "clang/AST/Mangle.h" 20 #include "clang/AST/StmtCXX.h" 21 #include "clang/AST/StmtObjC.h" 22 #include "clang/AST/StmtVisitor.h" 23 #include "clang/Basic/DiagnosticSema.h" 24 #include "clang/Basic/TargetBuiltins.h" 25 #include "llvm/IR/IntrinsicInst.h" 26 #include "llvm/IR/Intrinsics.h" 27 #include "llvm/IR/IntrinsicsWebAssembly.h" 28 #include "llvm/Support/SaveAndRestore.h" 29 30 using namespace clang; 31 using namespace CodeGen; 32 33 static llvm::FunctionCallee getFreeExceptionFn(CodeGenModule &CGM) { 34 // void __cxa_free_exception(void *thrown_exception); 35 36 llvm::FunctionType *FTy = 37 llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*isVarArg=*/false); 38 39 return CGM.CreateRuntimeFunction(FTy, "__cxa_free_exception"); 40 } 41 42 static llvm::FunctionCallee getUnexpectedFn(CodeGenModule &CGM) { 43 // void __cxa_call_unexpected(void *thrown_exception); 44 45 llvm::FunctionType *FTy = 46 llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*isVarArg=*/false); 47 48 return CGM.CreateRuntimeFunction(FTy, "__cxa_call_unexpected"); 49 } 50 51 llvm::FunctionCallee CodeGenModule::getTerminateFn() { 52 // void __terminate(); 53 54 llvm::FunctionType *FTy = 55 llvm::FunctionType::get(VoidTy, /*isVarArg=*/false); 56 57 StringRef name; 58 59 // In C++, use std::terminate(). 60 if (getLangOpts().CPlusPlus && 61 getTarget().getCXXABI().isItaniumFamily()) { 62 name = "_ZSt9terminatev"; 63 } else if (getLangOpts().CPlusPlus && 64 getTarget().getCXXABI().isMicrosoft()) { 65 if (getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2015)) 66 name = "__std_terminate"; 67 else 68 name = "?terminate@@YAXXZ"; 69 } else if (getLangOpts().ObjC && 70 getLangOpts().ObjCRuntime.hasTerminate()) 71 name = "objc_terminate"; 72 else 73 name = "abort"; 74 return CreateRuntimeFunction(FTy, name); 75 } 76 77 static llvm::FunctionCallee getCatchallRethrowFn(CodeGenModule &CGM, 78 StringRef Name) { 79 llvm::FunctionType *FTy = 80 llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*isVarArg=*/false); 81 82 return CGM.CreateRuntimeFunction(FTy, Name); 83 } 84 85 const EHPersonality EHPersonality::GNU_C = { "__gcc_personality_v0", nullptr }; 86 const EHPersonality 87 EHPersonality::GNU_C_SJLJ = { "__gcc_personality_sj0", nullptr }; 88 const EHPersonality 89 EHPersonality::GNU_C_SEH = { "__gcc_personality_seh0", nullptr }; 90 const EHPersonality 91 EHPersonality::NeXT_ObjC = { "__objc_personality_v0", nullptr }; 92 const EHPersonality 93 EHPersonality::GNU_CPlusPlus = { "__gxx_personality_v0", nullptr }; 94 const EHPersonality 95 EHPersonality::GNU_CPlusPlus_SJLJ = { "__gxx_personality_sj0", nullptr }; 96 const EHPersonality 97 EHPersonality::GNU_CPlusPlus_SEH = { "__gxx_personality_seh0", nullptr }; 98 const EHPersonality 99 EHPersonality::GNU_ObjC = {"__gnu_objc_personality_v0", "objc_exception_throw"}; 100 const EHPersonality 101 EHPersonality::GNU_ObjC_SJLJ = {"__gnu_objc_personality_sj0", "objc_exception_throw"}; 102 const EHPersonality 103 EHPersonality::GNU_ObjC_SEH = {"__gnu_objc_personality_seh0", "objc_exception_throw"}; 104 const EHPersonality 105 EHPersonality::GNU_ObjCXX = { "__gnustep_objcxx_personality_v0", nullptr }; 106 const EHPersonality 107 EHPersonality::GNUstep_ObjC = { "__gnustep_objc_personality_v0", nullptr }; 108 const EHPersonality 109 EHPersonality::MSVC_except_handler = { "_except_handler3", nullptr }; 110 const EHPersonality 111 EHPersonality::MSVC_C_specific_handler = { "__C_specific_handler", nullptr }; 112 const EHPersonality 113 EHPersonality::MSVC_CxxFrameHandler3 = { "__CxxFrameHandler3", nullptr }; 114 const EHPersonality 115 EHPersonality::GNU_Wasm_CPlusPlus = { "__gxx_wasm_personality_v0", nullptr }; 116 117 static const EHPersonality &getCPersonality(const TargetInfo &Target, 118 const LangOptions &L) { 119 const llvm::Triple &T = Target.getTriple(); 120 if (T.isWindowsMSVCEnvironment()) 121 return EHPersonality::MSVC_CxxFrameHandler3; 122 if (L.SjLjExceptions) 123 return EHPersonality::GNU_C_SJLJ; 124 if (L.DWARFExceptions) 125 return EHPersonality::GNU_C; 126 if (L.SEHExceptions) 127 return EHPersonality::GNU_C_SEH; 128 return EHPersonality::GNU_C; 129 } 130 131 static const EHPersonality &getObjCPersonality(const TargetInfo &Target, 132 const LangOptions &L) { 133 const llvm::Triple &T = Target.getTriple(); 134 if (T.isWindowsMSVCEnvironment()) 135 return EHPersonality::MSVC_CxxFrameHandler3; 136 137 switch (L.ObjCRuntime.getKind()) { 138 case ObjCRuntime::FragileMacOSX: 139 return getCPersonality(Target, L); 140 case ObjCRuntime::MacOSX: 141 case ObjCRuntime::iOS: 142 case ObjCRuntime::WatchOS: 143 return EHPersonality::NeXT_ObjC; 144 case ObjCRuntime::GNUstep: 145 if (L.ObjCRuntime.getVersion() >= VersionTuple(1, 7)) 146 return EHPersonality::GNUstep_ObjC; 147 LLVM_FALLTHROUGH; 148 case ObjCRuntime::GCC: 149 case ObjCRuntime::ObjFW: 150 if (L.SjLjExceptions) 151 return EHPersonality::GNU_ObjC_SJLJ; 152 if (L.SEHExceptions) 153 return EHPersonality::GNU_ObjC_SEH; 154 return EHPersonality::GNU_ObjC; 155 } 156 llvm_unreachable("bad runtime kind"); 157 } 158 159 static const EHPersonality &getCXXPersonality(const TargetInfo &Target, 160 const LangOptions &L) { 161 const llvm::Triple &T = Target.getTriple(); 162 if (T.isWindowsMSVCEnvironment()) 163 return EHPersonality::MSVC_CxxFrameHandler3; 164 if (L.SjLjExceptions) 165 return EHPersonality::GNU_CPlusPlus_SJLJ; 166 if (L.DWARFExceptions) 167 return EHPersonality::GNU_CPlusPlus; 168 if (L.SEHExceptions) 169 return EHPersonality::GNU_CPlusPlus_SEH; 170 if (L.WasmExceptions) 171 return EHPersonality::GNU_Wasm_CPlusPlus; 172 return EHPersonality::GNU_CPlusPlus; 173 } 174 175 /// Determines the personality function to use when both C++ 176 /// and Objective-C exceptions are being caught. 177 static const EHPersonality &getObjCXXPersonality(const TargetInfo &Target, 178 const LangOptions &L) { 179 if (Target.getTriple().isWindowsMSVCEnvironment()) 180 return EHPersonality::MSVC_CxxFrameHandler3; 181 182 switch (L.ObjCRuntime.getKind()) { 183 // In the fragile ABI, just use C++ exception handling and hope 184 // they're not doing crazy exception mixing. 185 case ObjCRuntime::FragileMacOSX: 186 return getCXXPersonality(Target, L); 187 188 // The ObjC personality defers to the C++ personality for non-ObjC 189 // handlers. Unlike the C++ case, we use the same personality 190 // function on targets using (backend-driven) SJLJ EH. 191 case ObjCRuntime::MacOSX: 192 case ObjCRuntime::iOS: 193 case ObjCRuntime::WatchOS: 194 return getObjCPersonality(Target, L); 195 196 case ObjCRuntime::GNUstep: 197 return EHPersonality::GNU_ObjCXX; 198 199 // The GCC runtime's personality function inherently doesn't support 200 // mixed EH. Use the ObjC personality just to avoid returning null. 201 case ObjCRuntime::GCC: 202 case ObjCRuntime::ObjFW: 203 return getObjCPersonality(Target, L); 204 } 205 llvm_unreachable("bad runtime kind"); 206 } 207 208 static const EHPersonality &getSEHPersonalityMSVC(const llvm::Triple &T) { 209 if (T.getArch() == llvm::Triple::x86) 210 return EHPersonality::MSVC_except_handler; 211 return EHPersonality::MSVC_C_specific_handler; 212 } 213 214 const EHPersonality &EHPersonality::get(CodeGenModule &CGM, 215 const FunctionDecl *FD) { 216 const llvm::Triple &T = CGM.getTarget().getTriple(); 217 const LangOptions &L = CGM.getLangOpts(); 218 const TargetInfo &Target = CGM.getTarget(); 219 220 // Functions using SEH get an SEH personality. 221 if (FD && FD->usesSEHTry()) 222 return getSEHPersonalityMSVC(T); 223 224 if (L.ObjC) 225 return L.CPlusPlus ? getObjCXXPersonality(Target, L) 226 : getObjCPersonality(Target, L); 227 return L.CPlusPlus ? getCXXPersonality(Target, L) 228 : getCPersonality(Target, L); 229 } 230 231 const EHPersonality &EHPersonality::get(CodeGenFunction &CGF) { 232 const auto *FD = CGF.CurCodeDecl; 233 // For outlined finallys and filters, use the SEH personality in case they 234 // contain more SEH. This mostly only affects finallys. Filters could 235 // hypothetically use gnu statement expressions to sneak in nested SEH. 236 FD = FD ? FD : CGF.CurSEHParent; 237 return get(CGF.CGM, dyn_cast_or_null<FunctionDecl>(FD)); 238 } 239 240 static llvm::FunctionCallee getPersonalityFn(CodeGenModule &CGM, 241 const EHPersonality &Personality) { 242 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty, true), 243 Personality.PersonalityFn, 244 llvm::AttributeList(), /*Local=*/true); 245 } 246 247 static llvm::Constant *getOpaquePersonalityFn(CodeGenModule &CGM, 248 const EHPersonality &Personality) { 249 llvm::FunctionCallee Fn = getPersonalityFn(CGM, Personality); 250 llvm::PointerType* Int8PtrTy = llvm::PointerType::get( 251 llvm::Type::getInt8Ty(CGM.getLLVMContext()), 252 CGM.getDataLayout().getProgramAddressSpace()); 253 254 return llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(Fn.getCallee()), 255 Int8PtrTy); 256 } 257 258 /// Check whether a landingpad instruction only uses C++ features. 259 static bool LandingPadHasOnlyCXXUses(llvm::LandingPadInst *LPI) { 260 for (unsigned I = 0, E = LPI->getNumClauses(); I != E; ++I) { 261 // Look for something that would've been returned by the ObjC 262 // runtime's GetEHType() method. 263 llvm::Value *Val = LPI->getClause(I)->stripPointerCasts(); 264 if (LPI->isCatch(I)) { 265 // Check if the catch value has the ObjC prefix. 266 if (llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Val)) 267 // ObjC EH selector entries are always global variables with 268 // names starting like this. 269 if (GV->getName().startswith("OBJC_EHTYPE")) 270 return false; 271 } else { 272 // Check if any of the filter values have the ObjC prefix. 273 llvm::Constant *CVal = cast<llvm::Constant>(Val); 274 for (llvm::User::op_iterator 275 II = CVal->op_begin(), IE = CVal->op_end(); II != IE; ++II) { 276 if (llvm::GlobalVariable *GV = 277 cast<llvm::GlobalVariable>((*II)->stripPointerCasts())) 278 // ObjC EH selector entries are always global variables with 279 // names starting like this. 280 if (GV->getName().startswith("OBJC_EHTYPE")) 281 return false; 282 } 283 } 284 } 285 return true; 286 } 287 288 /// Check whether a personality function could reasonably be swapped 289 /// for a C++ personality function. 290 static bool PersonalityHasOnlyCXXUses(llvm::Constant *Fn) { 291 for (llvm::User *U : Fn->users()) { 292 // Conditionally white-list bitcasts. 293 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(U)) { 294 if (CE->getOpcode() != llvm::Instruction::BitCast) return false; 295 if (!PersonalityHasOnlyCXXUses(CE)) 296 return false; 297 continue; 298 } 299 300 // Otherwise it must be a function. 301 llvm::Function *F = dyn_cast<llvm::Function>(U); 302 if (!F) return false; 303 304 for (auto BB = F->begin(), E = F->end(); BB != E; ++BB) { 305 if (BB->isLandingPad()) 306 if (!LandingPadHasOnlyCXXUses(BB->getLandingPadInst())) 307 return false; 308 } 309 } 310 311 return true; 312 } 313 314 /// Try to use the C++ personality function in ObjC++. Not doing this 315 /// can cause some incompatibilities with gcc, which is more 316 /// aggressive about only using the ObjC++ personality in a function 317 /// when it really needs it. 318 void CodeGenModule::SimplifyPersonality() { 319 // If we're not in ObjC++ -fexceptions, there's nothing to do. 320 if (!LangOpts.CPlusPlus || !LangOpts.ObjC || !LangOpts.Exceptions) 321 return; 322 323 // Both the problem this endeavors to fix and the way the logic 324 // above works is specific to the NeXT runtime. 325 if (!LangOpts.ObjCRuntime.isNeXTFamily()) 326 return; 327 328 const EHPersonality &ObjCXX = EHPersonality::get(*this, /*FD=*/nullptr); 329 const EHPersonality &CXX = getCXXPersonality(getTarget(), LangOpts); 330 if (&ObjCXX == &CXX) 331 return; 332 333 assert(std::strcmp(ObjCXX.PersonalityFn, CXX.PersonalityFn) != 0 && 334 "Different EHPersonalities using the same personality function."); 335 336 llvm::Function *Fn = getModule().getFunction(ObjCXX.PersonalityFn); 337 338 // Nothing to do if it's unused. 339 if (!Fn || Fn->use_empty()) return; 340 341 // Can't do the optimization if it has non-C++ uses. 342 if (!PersonalityHasOnlyCXXUses(Fn)) return; 343 344 // Create the C++ personality function and kill off the old 345 // function. 346 llvm::FunctionCallee CXXFn = getPersonalityFn(*this, CXX); 347 348 // This can happen if the user is screwing with us. 349 if (Fn->getType() != CXXFn.getCallee()->getType()) 350 return; 351 352 Fn->replaceAllUsesWith(CXXFn.getCallee()); 353 Fn->eraseFromParent(); 354 } 355 356 /// Returns the value to inject into a selector to indicate the 357 /// presence of a catch-all. 358 static llvm::Constant *getCatchAllValue(CodeGenFunction &CGF) { 359 // Possibly we should use @llvm.eh.catch.all.value here. 360 return llvm::ConstantPointerNull::get(CGF.Int8PtrTy); 361 } 362 363 namespace { 364 /// A cleanup to free the exception object if its initialization 365 /// throws. 366 struct FreeException final : EHScopeStack::Cleanup { 367 llvm::Value *exn; 368 FreeException(llvm::Value *exn) : exn(exn) {} 369 void Emit(CodeGenFunction &CGF, Flags flags) override { 370 CGF.EmitNounwindRuntimeCall(getFreeExceptionFn(CGF.CGM), exn); 371 } 372 }; 373 } // end anonymous namespace 374 375 // Emits an exception expression into the given location. This 376 // differs from EmitAnyExprToMem only in that, if a final copy-ctor 377 // call is required, an exception within that copy ctor causes 378 // std::terminate to be invoked. 379 void CodeGenFunction::EmitAnyExprToExn(const Expr *e, Address addr) { 380 // Make sure the exception object is cleaned up if there's an 381 // exception during initialization. 382 pushFullExprCleanup<FreeException>(EHCleanup, addr.getPointer()); 383 EHScopeStack::stable_iterator cleanup = EHStack.stable_begin(); 384 385 // __cxa_allocate_exception returns a void*; we need to cast this 386 // to the appropriate type for the object. 387 llvm::Type *ty = ConvertTypeForMem(e->getType())->getPointerTo(); 388 Address typedAddr = Builder.CreateBitCast(addr, ty); 389 390 // FIXME: this isn't quite right! If there's a final unelided call 391 // to a copy constructor, then according to [except.terminate]p1 we 392 // must call std::terminate() if that constructor throws, because 393 // technically that copy occurs after the exception expression is 394 // evaluated but before the exception is caught. But the best way 395 // to handle that is to teach EmitAggExpr to do the final copy 396 // differently if it can't be elided. 397 EmitAnyExprToMem(e, typedAddr, e->getType().getQualifiers(), 398 /*IsInit*/ true); 399 400 // Deactivate the cleanup block. 401 DeactivateCleanupBlock(cleanup, 402 cast<llvm::Instruction>(typedAddr.getPointer())); 403 } 404 405 Address CodeGenFunction::getExceptionSlot() { 406 if (!ExceptionSlot) 407 ExceptionSlot = CreateTempAlloca(Int8PtrTy, "exn.slot"); 408 return Address(ExceptionSlot, getPointerAlign()); 409 } 410 411 Address CodeGenFunction::getEHSelectorSlot() { 412 if (!EHSelectorSlot) 413 EHSelectorSlot = CreateTempAlloca(Int32Ty, "ehselector.slot"); 414 return Address(EHSelectorSlot, CharUnits::fromQuantity(4)); 415 } 416 417 llvm::Value *CodeGenFunction::getExceptionFromSlot() { 418 return Builder.CreateLoad(getExceptionSlot(), "exn"); 419 } 420 421 llvm::Value *CodeGenFunction::getSelectorFromSlot() { 422 return Builder.CreateLoad(getEHSelectorSlot(), "sel"); 423 } 424 425 void CodeGenFunction::EmitCXXThrowExpr(const CXXThrowExpr *E, 426 bool KeepInsertionPoint) { 427 if (const Expr *SubExpr = E->getSubExpr()) { 428 QualType ThrowType = SubExpr->getType(); 429 if (ThrowType->isObjCObjectPointerType()) { 430 const Stmt *ThrowStmt = E->getSubExpr(); 431 const ObjCAtThrowStmt S(E->getExprLoc(), const_cast<Stmt *>(ThrowStmt)); 432 CGM.getObjCRuntime().EmitThrowStmt(*this, S, false); 433 } else { 434 CGM.getCXXABI().emitThrow(*this, E); 435 } 436 } else { 437 CGM.getCXXABI().emitRethrow(*this, /*isNoReturn=*/true); 438 } 439 440 // throw is an expression, and the expression emitters expect us 441 // to leave ourselves at a valid insertion point. 442 if (KeepInsertionPoint) 443 EmitBlock(createBasicBlock("throw.cont")); 444 } 445 446 void CodeGenFunction::EmitStartEHSpec(const Decl *D) { 447 if (!CGM.getLangOpts().CXXExceptions) 448 return; 449 450 const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D); 451 if (!FD) { 452 // Check if CapturedDecl is nothrow and create terminate scope for it. 453 if (const CapturedDecl* CD = dyn_cast_or_null<CapturedDecl>(D)) { 454 if (CD->isNothrow()) 455 EHStack.pushTerminate(); 456 } 457 return; 458 } 459 const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>(); 460 if (!Proto) 461 return; 462 463 ExceptionSpecificationType EST = Proto->getExceptionSpecType(); 464 if (isNoexceptExceptionSpec(EST) && Proto->canThrow() == CT_Cannot) { 465 // noexcept functions are simple terminate scopes. 466 EHStack.pushTerminate(); 467 } else if (EST == EST_Dynamic || EST == EST_DynamicNone) { 468 // TODO: Revisit exception specifications for the MS ABI. There is a way to 469 // encode these in an object file but MSVC doesn't do anything with it. 470 if (getTarget().getCXXABI().isMicrosoft()) 471 return; 472 // In wasm we currently treat 'throw()' in the same way as 'noexcept'. In 473 // case of throw with types, we ignore it and print a warning for now. 474 // TODO Correctly handle exception specification in wasm 475 if (CGM.getLangOpts().WasmExceptions) { 476 if (EST == EST_DynamicNone) 477 EHStack.pushTerminate(); 478 else 479 CGM.getDiags().Report(D->getLocation(), 480 diag::warn_wasm_dynamic_exception_spec_ignored) 481 << FD->getExceptionSpecSourceRange(); 482 return; 483 } 484 unsigned NumExceptions = Proto->getNumExceptions(); 485 EHFilterScope *Filter = EHStack.pushFilter(NumExceptions); 486 487 for (unsigned I = 0; I != NumExceptions; ++I) { 488 QualType Ty = Proto->getExceptionType(I); 489 QualType ExceptType = Ty.getNonReferenceType().getUnqualifiedType(); 490 llvm::Value *EHType = CGM.GetAddrOfRTTIDescriptor(ExceptType, 491 /*ForEH=*/true); 492 Filter->setFilter(I, EHType); 493 } 494 } 495 } 496 497 /// Emit the dispatch block for a filter scope if necessary. 498 static void emitFilterDispatchBlock(CodeGenFunction &CGF, 499 EHFilterScope &filterScope) { 500 llvm::BasicBlock *dispatchBlock = filterScope.getCachedEHDispatchBlock(); 501 if (!dispatchBlock) return; 502 if (dispatchBlock->use_empty()) { 503 delete dispatchBlock; 504 return; 505 } 506 507 CGF.EmitBlockAfterUses(dispatchBlock); 508 509 // If this isn't a catch-all filter, we need to check whether we got 510 // here because the filter triggered. 511 if (filterScope.getNumFilters()) { 512 // Load the selector value. 513 llvm::Value *selector = CGF.getSelectorFromSlot(); 514 llvm::BasicBlock *unexpectedBB = CGF.createBasicBlock("ehspec.unexpected"); 515 516 llvm::Value *zero = CGF.Builder.getInt32(0); 517 llvm::Value *failsFilter = 518 CGF.Builder.CreateICmpSLT(selector, zero, "ehspec.fails"); 519 CGF.Builder.CreateCondBr(failsFilter, unexpectedBB, 520 CGF.getEHResumeBlock(false)); 521 522 CGF.EmitBlock(unexpectedBB); 523 } 524 525 // Call __cxa_call_unexpected. This doesn't need to be an invoke 526 // because __cxa_call_unexpected magically filters exceptions 527 // according to the last landing pad the exception was thrown 528 // into. Seriously. 529 llvm::Value *exn = CGF.getExceptionFromSlot(); 530 CGF.EmitRuntimeCall(getUnexpectedFn(CGF.CGM), exn) 531 ->setDoesNotReturn(); 532 CGF.Builder.CreateUnreachable(); 533 } 534 535 void CodeGenFunction::EmitEndEHSpec(const Decl *D) { 536 if (!CGM.getLangOpts().CXXExceptions) 537 return; 538 539 const FunctionDecl* FD = dyn_cast_or_null<FunctionDecl>(D); 540 if (!FD) { 541 // Check if CapturedDecl is nothrow and pop terminate scope for it. 542 if (const CapturedDecl* CD = dyn_cast_or_null<CapturedDecl>(D)) { 543 if (CD->isNothrow()) 544 EHStack.popTerminate(); 545 } 546 return; 547 } 548 const FunctionProtoType *Proto = FD->getType()->getAs<FunctionProtoType>(); 549 if (!Proto) 550 return; 551 552 ExceptionSpecificationType EST = Proto->getExceptionSpecType(); 553 if (isNoexceptExceptionSpec(EST) && Proto->canThrow() == CT_Cannot) { 554 EHStack.popTerminate(); 555 } else if (EST == EST_Dynamic || EST == EST_DynamicNone) { 556 // TODO: Revisit exception specifications for the MS ABI. There is a way to 557 // encode these in an object file but MSVC doesn't do anything with it. 558 if (getTarget().getCXXABI().isMicrosoft()) 559 return; 560 // In wasm we currently treat 'throw()' in the same way as 'noexcept'. In 561 // case of throw with types, we ignore it and print a warning for now. 562 // TODO Correctly handle exception specification in wasm 563 if (CGM.getLangOpts().WasmExceptions) { 564 if (EST == EST_DynamicNone) 565 EHStack.popTerminate(); 566 return; 567 } 568 EHFilterScope &filterScope = cast<EHFilterScope>(*EHStack.begin()); 569 emitFilterDispatchBlock(*this, filterScope); 570 EHStack.popFilter(); 571 } 572 } 573 574 void CodeGenFunction::EmitCXXTryStmt(const CXXTryStmt &S) { 575 EnterCXXTryStmt(S); 576 EmitStmt(S.getTryBlock()); 577 ExitCXXTryStmt(S); 578 } 579 580 void CodeGenFunction::EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) { 581 unsigned NumHandlers = S.getNumHandlers(); 582 EHCatchScope *CatchScope = EHStack.pushCatch(NumHandlers); 583 584 for (unsigned I = 0; I != NumHandlers; ++I) { 585 const CXXCatchStmt *C = S.getHandler(I); 586 587 llvm::BasicBlock *Handler = createBasicBlock("catch"); 588 if (C->getExceptionDecl()) { 589 // FIXME: Dropping the reference type on the type into makes it 590 // impossible to correctly implement catch-by-reference 591 // semantics for pointers. Unfortunately, this is what all 592 // existing compilers do, and it's not clear that the standard 593 // personality routine is capable of doing this right. See C++ DR 388: 594 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#388 595 Qualifiers CaughtTypeQuals; 596 QualType CaughtType = CGM.getContext().getUnqualifiedArrayType( 597 C->getCaughtType().getNonReferenceType(), CaughtTypeQuals); 598 599 CatchTypeInfo TypeInfo{nullptr, 0}; 600 if (CaughtType->isObjCObjectPointerType()) 601 TypeInfo.RTTI = CGM.getObjCRuntime().GetEHType(CaughtType); 602 else 603 TypeInfo = CGM.getCXXABI().getAddrOfCXXCatchHandlerType( 604 CaughtType, C->getCaughtType()); 605 CatchScope->setHandler(I, TypeInfo, Handler); 606 } else { 607 // No exception decl indicates '...', a catch-all. 608 CatchScope->setHandler(I, CGM.getCXXABI().getCatchAllTypeInfo(), Handler); 609 } 610 } 611 } 612 613 llvm::BasicBlock * 614 CodeGenFunction::getEHDispatchBlock(EHScopeStack::stable_iterator si) { 615 if (EHPersonality::get(*this).usesFuncletPads()) 616 return getFuncletEHDispatchBlock(si); 617 618 // The dispatch block for the end of the scope chain is a block that 619 // just resumes unwinding. 620 if (si == EHStack.stable_end()) 621 return getEHResumeBlock(true); 622 623 // Otherwise, we should look at the actual scope. 624 EHScope &scope = *EHStack.find(si); 625 626 llvm::BasicBlock *dispatchBlock = scope.getCachedEHDispatchBlock(); 627 if (!dispatchBlock) { 628 switch (scope.getKind()) { 629 case EHScope::Catch: { 630 // Apply a special case to a single catch-all. 631 EHCatchScope &catchScope = cast<EHCatchScope>(scope); 632 if (catchScope.getNumHandlers() == 1 && 633 catchScope.getHandler(0).isCatchAll()) { 634 dispatchBlock = catchScope.getHandler(0).Block; 635 636 // Otherwise, make a dispatch block. 637 } else { 638 dispatchBlock = createBasicBlock("catch.dispatch"); 639 } 640 break; 641 } 642 643 case EHScope::Cleanup: 644 dispatchBlock = createBasicBlock("ehcleanup"); 645 break; 646 647 case EHScope::Filter: 648 dispatchBlock = createBasicBlock("filter.dispatch"); 649 break; 650 651 case EHScope::Terminate: 652 dispatchBlock = getTerminateHandler(); 653 break; 654 } 655 scope.setCachedEHDispatchBlock(dispatchBlock); 656 } 657 return dispatchBlock; 658 } 659 660 llvm::BasicBlock * 661 CodeGenFunction::getFuncletEHDispatchBlock(EHScopeStack::stable_iterator SI) { 662 // Returning nullptr indicates that the previous dispatch block should unwind 663 // to caller. 664 if (SI == EHStack.stable_end()) 665 return nullptr; 666 667 // Otherwise, we should look at the actual scope. 668 EHScope &EHS = *EHStack.find(SI); 669 670 llvm::BasicBlock *DispatchBlock = EHS.getCachedEHDispatchBlock(); 671 if (DispatchBlock) 672 return DispatchBlock; 673 674 if (EHS.getKind() == EHScope::Terminate) 675 DispatchBlock = getTerminateFunclet(); 676 else 677 DispatchBlock = createBasicBlock(); 678 CGBuilderTy Builder(*this, DispatchBlock); 679 680 switch (EHS.getKind()) { 681 case EHScope::Catch: 682 DispatchBlock->setName("catch.dispatch"); 683 break; 684 685 case EHScope::Cleanup: 686 DispatchBlock->setName("ehcleanup"); 687 break; 688 689 case EHScope::Filter: 690 llvm_unreachable("exception specifications not handled yet!"); 691 692 case EHScope::Terminate: 693 DispatchBlock->setName("terminate"); 694 break; 695 } 696 EHS.setCachedEHDispatchBlock(DispatchBlock); 697 return DispatchBlock; 698 } 699 700 /// Check whether this is a non-EH scope, i.e. a scope which doesn't 701 /// affect exception handling. Currently, the only non-EH scopes are 702 /// normal-only cleanup scopes. 703 static bool isNonEHScope(const EHScope &S) { 704 switch (S.getKind()) { 705 case EHScope::Cleanup: 706 return !cast<EHCleanupScope>(S).isEHCleanup(); 707 case EHScope::Filter: 708 case EHScope::Catch: 709 case EHScope::Terminate: 710 return false; 711 } 712 713 llvm_unreachable("Invalid EHScope Kind!"); 714 } 715 716 llvm::BasicBlock *CodeGenFunction::getInvokeDestImpl() { 717 assert(EHStack.requiresLandingPad()); 718 assert(!EHStack.empty()); 719 720 // If exceptions are disabled/ignored and SEH is not in use, then there is no 721 // invoke destination. SEH "works" even if exceptions are off. In practice, 722 // this means that C++ destructors and other EH cleanups don't run, which is 723 // consistent with MSVC's behavior. 724 const LangOptions &LO = CGM.getLangOpts(); 725 if (!LO.Exceptions || LO.IgnoreExceptions) { 726 if (!LO.Borland && !LO.MicrosoftExt) 727 return nullptr; 728 if (!currentFunctionUsesSEHTry()) 729 return nullptr; 730 } 731 732 // CUDA device code doesn't have exceptions. 733 if (LO.CUDA && LO.CUDAIsDevice) 734 return nullptr; 735 736 // Check the innermost scope for a cached landing pad. If this is 737 // a non-EH cleanup, we'll check enclosing scopes in EmitLandingPad. 738 llvm::BasicBlock *LP = EHStack.begin()->getCachedLandingPad(); 739 if (LP) return LP; 740 741 const EHPersonality &Personality = EHPersonality::get(*this); 742 743 if (!CurFn->hasPersonalityFn()) 744 CurFn->setPersonalityFn(getOpaquePersonalityFn(CGM, Personality)); 745 746 if (Personality.usesFuncletPads()) { 747 // We don't need separate landing pads in the funclet model. 748 LP = getEHDispatchBlock(EHStack.getInnermostEHScope()); 749 } else { 750 // Build the landing pad for this scope. 751 LP = EmitLandingPad(); 752 } 753 754 assert(LP); 755 756 // Cache the landing pad on the innermost scope. If this is a 757 // non-EH scope, cache the landing pad on the enclosing scope, too. 758 for (EHScopeStack::iterator ir = EHStack.begin(); true; ++ir) { 759 ir->setCachedLandingPad(LP); 760 if (!isNonEHScope(*ir)) break; 761 } 762 763 return LP; 764 } 765 766 llvm::BasicBlock *CodeGenFunction::EmitLandingPad() { 767 assert(EHStack.requiresLandingPad()); 768 assert(!CGM.getLangOpts().IgnoreExceptions && 769 "LandingPad should not be emitted when -fignore-exceptions are in " 770 "effect."); 771 EHScope &innermostEHScope = *EHStack.find(EHStack.getInnermostEHScope()); 772 switch (innermostEHScope.getKind()) { 773 case EHScope::Terminate: 774 return getTerminateLandingPad(); 775 776 case EHScope::Catch: 777 case EHScope::Cleanup: 778 case EHScope::Filter: 779 if (llvm::BasicBlock *lpad = innermostEHScope.getCachedLandingPad()) 780 return lpad; 781 } 782 783 // Save the current IR generation state. 784 CGBuilderTy::InsertPoint savedIP = Builder.saveAndClearIP(); 785 auto DL = ApplyDebugLocation::CreateDefaultArtificial(*this, CurEHLocation); 786 787 // Create and configure the landing pad. 788 llvm::BasicBlock *lpad = createBasicBlock("lpad"); 789 EmitBlock(lpad); 790 791 llvm::LandingPadInst *LPadInst = 792 Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty), 0); 793 794 llvm::Value *LPadExn = Builder.CreateExtractValue(LPadInst, 0); 795 Builder.CreateStore(LPadExn, getExceptionSlot()); 796 llvm::Value *LPadSel = Builder.CreateExtractValue(LPadInst, 1); 797 Builder.CreateStore(LPadSel, getEHSelectorSlot()); 798 799 // Save the exception pointer. It's safe to use a single exception 800 // pointer per function because EH cleanups can never have nested 801 // try/catches. 802 // Build the landingpad instruction. 803 804 // Accumulate all the handlers in scope. 805 bool hasCatchAll = false; 806 bool hasCleanup = false; 807 bool hasFilter = false; 808 SmallVector<llvm::Value*, 4> filterTypes; 809 llvm::SmallPtrSet<llvm::Value*, 4> catchTypes; 810 for (EHScopeStack::iterator I = EHStack.begin(), E = EHStack.end(); I != E; 811 ++I) { 812 813 switch (I->getKind()) { 814 case EHScope::Cleanup: 815 // If we have a cleanup, remember that. 816 hasCleanup = (hasCleanup || cast<EHCleanupScope>(*I).isEHCleanup()); 817 continue; 818 819 case EHScope::Filter: { 820 assert(I.next() == EHStack.end() && "EH filter is not end of EH stack"); 821 assert(!hasCatchAll && "EH filter reached after catch-all"); 822 823 // Filter scopes get added to the landingpad in weird ways. 824 EHFilterScope &filter = cast<EHFilterScope>(*I); 825 hasFilter = true; 826 827 // Add all the filter values. 828 for (unsigned i = 0, e = filter.getNumFilters(); i != e; ++i) 829 filterTypes.push_back(filter.getFilter(i)); 830 goto done; 831 } 832 833 case EHScope::Terminate: 834 // Terminate scopes are basically catch-alls. 835 assert(!hasCatchAll); 836 hasCatchAll = true; 837 goto done; 838 839 case EHScope::Catch: 840 break; 841 } 842 843 EHCatchScope &catchScope = cast<EHCatchScope>(*I); 844 for (unsigned hi = 0, he = catchScope.getNumHandlers(); hi != he; ++hi) { 845 EHCatchScope::Handler handler = catchScope.getHandler(hi); 846 assert(handler.Type.Flags == 0 && 847 "landingpads do not support catch handler flags"); 848 849 // If this is a catch-all, register that and abort. 850 if (!handler.Type.RTTI) { 851 assert(!hasCatchAll); 852 hasCatchAll = true; 853 goto done; 854 } 855 856 // Check whether we already have a handler for this type. 857 if (catchTypes.insert(handler.Type.RTTI).second) 858 // If not, add it directly to the landingpad. 859 LPadInst->addClause(handler.Type.RTTI); 860 } 861 } 862 863 done: 864 // If we have a catch-all, add null to the landingpad. 865 assert(!(hasCatchAll && hasFilter)); 866 if (hasCatchAll) { 867 LPadInst->addClause(getCatchAllValue(*this)); 868 869 // If we have an EH filter, we need to add those handlers in the 870 // right place in the landingpad, which is to say, at the end. 871 } else if (hasFilter) { 872 // Create a filter expression: a constant array indicating which filter 873 // types there are. The personality routine only lands here if the filter 874 // doesn't match. 875 SmallVector<llvm::Constant*, 8> Filters; 876 llvm::ArrayType *AType = 877 llvm::ArrayType::get(!filterTypes.empty() ? 878 filterTypes[0]->getType() : Int8PtrTy, 879 filterTypes.size()); 880 881 for (unsigned i = 0, e = filterTypes.size(); i != e; ++i) 882 Filters.push_back(cast<llvm::Constant>(filterTypes[i])); 883 llvm::Constant *FilterArray = llvm::ConstantArray::get(AType, Filters); 884 LPadInst->addClause(FilterArray); 885 886 // Also check whether we need a cleanup. 887 if (hasCleanup) 888 LPadInst->setCleanup(true); 889 890 // Otherwise, signal that we at least have cleanups. 891 } else if (hasCleanup) { 892 LPadInst->setCleanup(true); 893 } 894 895 assert((LPadInst->getNumClauses() > 0 || LPadInst->isCleanup()) && 896 "landingpad instruction has no clauses!"); 897 898 // Tell the backend how to generate the landing pad. 899 Builder.CreateBr(getEHDispatchBlock(EHStack.getInnermostEHScope())); 900 901 // Restore the old IR generation state. 902 Builder.restoreIP(savedIP); 903 904 return lpad; 905 } 906 907 static void emitCatchPadBlock(CodeGenFunction &CGF, EHCatchScope &CatchScope) { 908 llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock(); 909 assert(DispatchBlock); 910 911 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveIP(); 912 CGF.EmitBlockAfterUses(DispatchBlock); 913 914 llvm::Value *ParentPad = CGF.CurrentFuncletPad; 915 if (!ParentPad) 916 ParentPad = llvm::ConstantTokenNone::get(CGF.getLLVMContext()); 917 llvm::BasicBlock *UnwindBB = 918 CGF.getEHDispatchBlock(CatchScope.getEnclosingEHScope()); 919 920 unsigned NumHandlers = CatchScope.getNumHandlers(); 921 llvm::CatchSwitchInst *CatchSwitch = 922 CGF.Builder.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers); 923 924 // Test against each of the exception types we claim to catch. 925 for (unsigned I = 0; I < NumHandlers; ++I) { 926 const EHCatchScope::Handler &Handler = CatchScope.getHandler(I); 927 928 CatchTypeInfo TypeInfo = Handler.Type; 929 if (!TypeInfo.RTTI) 930 TypeInfo.RTTI = llvm::Constant::getNullValue(CGF.VoidPtrTy); 931 932 CGF.Builder.SetInsertPoint(Handler.Block); 933 934 if (EHPersonality::get(CGF).isMSVCXXPersonality()) { 935 CGF.Builder.CreateCatchPad( 936 CatchSwitch, {TypeInfo.RTTI, CGF.Builder.getInt32(TypeInfo.Flags), 937 llvm::Constant::getNullValue(CGF.VoidPtrTy)}); 938 } else { 939 CGF.Builder.CreateCatchPad(CatchSwitch, {TypeInfo.RTTI}); 940 } 941 942 CatchSwitch->addHandler(Handler.Block); 943 } 944 CGF.Builder.restoreIP(SavedIP); 945 } 946 947 // Wasm uses Windows-style EH instructions, but it merges all catch clauses into 948 // one big catchpad, within which we use Itanium's landingpad-style selector 949 // comparison instructions. 950 static void emitWasmCatchPadBlock(CodeGenFunction &CGF, 951 EHCatchScope &CatchScope) { 952 llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock(); 953 assert(DispatchBlock); 954 955 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveIP(); 956 CGF.EmitBlockAfterUses(DispatchBlock); 957 958 llvm::Value *ParentPad = CGF.CurrentFuncletPad; 959 if (!ParentPad) 960 ParentPad = llvm::ConstantTokenNone::get(CGF.getLLVMContext()); 961 llvm::BasicBlock *UnwindBB = 962 CGF.getEHDispatchBlock(CatchScope.getEnclosingEHScope()); 963 964 unsigned NumHandlers = CatchScope.getNumHandlers(); 965 llvm::CatchSwitchInst *CatchSwitch = 966 CGF.Builder.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers); 967 968 // We don't use a landingpad instruction, so generate intrinsic calls to 969 // provide exception and selector values. 970 llvm::BasicBlock *WasmCatchStartBlock = CGF.createBasicBlock("catch.start"); 971 CatchSwitch->addHandler(WasmCatchStartBlock); 972 CGF.EmitBlockAfterUses(WasmCatchStartBlock); 973 974 // Create a catchpad instruction. 975 SmallVector<llvm::Value *, 4> CatchTypes; 976 for (unsigned I = 0, E = NumHandlers; I < E; ++I) { 977 const EHCatchScope::Handler &Handler = CatchScope.getHandler(I); 978 CatchTypeInfo TypeInfo = Handler.Type; 979 if (!TypeInfo.RTTI) 980 TypeInfo.RTTI = llvm::Constant::getNullValue(CGF.VoidPtrTy); 981 CatchTypes.push_back(TypeInfo.RTTI); 982 } 983 auto *CPI = CGF.Builder.CreateCatchPad(CatchSwitch, CatchTypes); 984 985 // Create calls to wasm.get.exception and wasm.get.ehselector intrinsics. 986 // Before they are lowered appropriately later, they provide values for the 987 // exception and selector. 988 llvm::Function *GetExnFn = 989 CGF.CGM.getIntrinsic(llvm::Intrinsic::wasm_get_exception); 990 llvm::Function *GetSelectorFn = 991 CGF.CGM.getIntrinsic(llvm::Intrinsic::wasm_get_ehselector); 992 llvm::CallInst *Exn = CGF.Builder.CreateCall(GetExnFn, CPI); 993 CGF.Builder.CreateStore(Exn, CGF.getExceptionSlot()); 994 llvm::CallInst *Selector = CGF.Builder.CreateCall(GetSelectorFn, CPI); 995 996 llvm::Function *TypeIDFn = CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for); 997 998 // If there's only a single catch-all, branch directly to its handler. 999 if (CatchScope.getNumHandlers() == 1 && 1000 CatchScope.getHandler(0).isCatchAll()) { 1001 CGF.Builder.CreateBr(CatchScope.getHandler(0).Block); 1002 CGF.Builder.restoreIP(SavedIP); 1003 return; 1004 } 1005 1006 // Test against each of the exception types we claim to catch. 1007 for (unsigned I = 0, E = NumHandlers;; ++I) { 1008 assert(I < E && "ran off end of handlers!"); 1009 const EHCatchScope::Handler &Handler = CatchScope.getHandler(I); 1010 CatchTypeInfo TypeInfo = Handler.Type; 1011 if (!TypeInfo.RTTI) 1012 TypeInfo.RTTI = llvm::Constant::getNullValue(CGF.VoidPtrTy); 1013 1014 // Figure out the next block. 1015 llvm::BasicBlock *NextBlock; 1016 1017 bool EmitNextBlock = false, NextIsEnd = false; 1018 1019 // If this is the last handler, we're at the end, and the next block is a 1020 // block that contains a call to the rethrow function, so we can unwind to 1021 // the enclosing EH scope. The call itself will be generated later. 1022 if (I + 1 == E) { 1023 NextBlock = CGF.createBasicBlock("rethrow"); 1024 EmitNextBlock = true; 1025 NextIsEnd = true; 1026 1027 // If the next handler is a catch-all, we're at the end, and the 1028 // next block is that handler. 1029 } else if (CatchScope.getHandler(I + 1).isCatchAll()) { 1030 NextBlock = CatchScope.getHandler(I + 1).Block; 1031 NextIsEnd = true; 1032 1033 // Otherwise, we're not at the end and we need a new block. 1034 } else { 1035 NextBlock = CGF.createBasicBlock("catch.fallthrough"); 1036 EmitNextBlock = true; 1037 } 1038 1039 // Figure out the catch type's index in the LSDA's type table. 1040 llvm::CallInst *TypeIndex = CGF.Builder.CreateCall(TypeIDFn, TypeInfo.RTTI); 1041 TypeIndex->setDoesNotThrow(); 1042 1043 llvm::Value *MatchesTypeIndex = 1044 CGF.Builder.CreateICmpEQ(Selector, TypeIndex, "matches"); 1045 CGF.Builder.CreateCondBr(MatchesTypeIndex, Handler.Block, NextBlock); 1046 1047 if (EmitNextBlock) 1048 CGF.EmitBlock(NextBlock); 1049 if (NextIsEnd) 1050 break; 1051 } 1052 1053 CGF.Builder.restoreIP(SavedIP); 1054 } 1055 1056 /// Emit the structure of the dispatch block for the given catch scope. 1057 /// It is an invariant that the dispatch block already exists. 1058 static void emitCatchDispatchBlock(CodeGenFunction &CGF, 1059 EHCatchScope &catchScope) { 1060 if (EHPersonality::get(CGF).isWasmPersonality()) 1061 return emitWasmCatchPadBlock(CGF, catchScope); 1062 if (EHPersonality::get(CGF).usesFuncletPads()) 1063 return emitCatchPadBlock(CGF, catchScope); 1064 1065 llvm::BasicBlock *dispatchBlock = catchScope.getCachedEHDispatchBlock(); 1066 assert(dispatchBlock); 1067 1068 // If there's only a single catch-all, getEHDispatchBlock returned 1069 // that catch-all as the dispatch block. 1070 if (catchScope.getNumHandlers() == 1 && 1071 catchScope.getHandler(0).isCatchAll()) { 1072 assert(dispatchBlock == catchScope.getHandler(0).Block); 1073 return; 1074 } 1075 1076 CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveIP(); 1077 CGF.EmitBlockAfterUses(dispatchBlock); 1078 1079 // Select the right handler. 1080 llvm::Function *llvm_eh_typeid_for = 1081 CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for); 1082 1083 // Load the selector value. 1084 llvm::Value *selector = CGF.getSelectorFromSlot(); 1085 1086 // Test against each of the exception types we claim to catch. 1087 for (unsigned i = 0, e = catchScope.getNumHandlers(); ; ++i) { 1088 assert(i < e && "ran off end of handlers!"); 1089 const EHCatchScope::Handler &handler = catchScope.getHandler(i); 1090 1091 llvm::Value *typeValue = handler.Type.RTTI; 1092 assert(handler.Type.Flags == 0 && 1093 "landingpads do not support catch handler flags"); 1094 assert(typeValue && "fell into catch-all case!"); 1095 typeValue = CGF.Builder.CreateBitCast(typeValue, CGF.Int8PtrTy); 1096 1097 // Figure out the next block. 1098 bool nextIsEnd; 1099 llvm::BasicBlock *nextBlock; 1100 1101 // If this is the last handler, we're at the end, and the next 1102 // block is the block for the enclosing EH scope. 1103 if (i + 1 == e) { 1104 nextBlock = CGF.getEHDispatchBlock(catchScope.getEnclosingEHScope()); 1105 nextIsEnd = true; 1106 1107 // If the next handler is a catch-all, we're at the end, and the 1108 // next block is that handler. 1109 } else if (catchScope.getHandler(i+1).isCatchAll()) { 1110 nextBlock = catchScope.getHandler(i+1).Block; 1111 nextIsEnd = true; 1112 1113 // Otherwise, we're not at the end and we need a new block. 1114 } else { 1115 nextBlock = CGF.createBasicBlock("catch.fallthrough"); 1116 nextIsEnd = false; 1117 } 1118 1119 // Figure out the catch type's index in the LSDA's type table. 1120 llvm::CallInst *typeIndex = 1121 CGF.Builder.CreateCall(llvm_eh_typeid_for, typeValue); 1122 typeIndex->setDoesNotThrow(); 1123 1124 llvm::Value *matchesTypeIndex = 1125 CGF.Builder.CreateICmpEQ(selector, typeIndex, "matches"); 1126 CGF.Builder.CreateCondBr(matchesTypeIndex, handler.Block, nextBlock); 1127 1128 // If the next handler is a catch-all, we're completely done. 1129 if (nextIsEnd) { 1130 CGF.Builder.restoreIP(savedIP); 1131 return; 1132 } 1133 // Otherwise we need to emit and continue at that block. 1134 CGF.EmitBlock(nextBlock); 1135 } 1136 } 1137 1138 void CodeGenFunction::popCatchScope() { 1139 EHCatchScope &catchScope = cast<EHCatchScope>(*EHStack.begin()); 1140 if (catchScope.hasEHBranches()) 1141 emitCatchDispatchBlock(*this, catchScope); 1142 EHStack.popCatch(); 1143 } 1144 1145 void CodeGenFunction::ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock) { 1146 unsigned NumHandlers = S.getNumHandlers(); 1147 EHCatchScope &CatchScope = cast<EHCatchScope>(*EHStack.begin()); 1148 assert(CatchScope.getNumHandlers() == NumHandlers); 1149 llvm::BasicBlock *DispatchBlock = CatchScope.getCachedEHDispatchBlock(); 1150 1151 // If the catch was not required, bail out now. 1152 if (!CatchScope.hasEHBranches()) { 1153 CatchScope.clearHandlerBlocks(); 1154 EHStack.popCatch(); 1155 return; 1156 } 1157 1158 // Emit the structure of the EH dispatch for this catch. 1159 emitCatchDispatchBlock(*this, CatchScope); 1160 1161 // Copy the handler blocks off before we pop the EH stack. Emitting 1162 // the handlers might scribble on this memory. 1163 SmallVector<EHCatchScope::Handler, 8> Handlers( 1164 CatchScope.begin(), CatchScope.begin() + NumHandlers); 1165 1166 EHStack.popCatch(); 1167 1168 // The fall-through block. 1169 llvm::BasicBlock *ContBB = createBasicBlock("try.cont"); 1170 1171 // We just emitted the body of the try; jump to the continue block. 1172 if (HaveInsertPoint()) 1173 Builder.CreateBr(ContBB); 1174 1175 // Determine if we need an implicit rethrow for all these catch handlers; 1176 // see the comment below. 1177 bool doImplicitRethrow = false; 1178 if (IsFnTryBlock) 1179 doImplicitRethrow = isa<CXXDestructorDecl>(CurCodeDecl) || 1180 isa<CXXConstructorDecl>(CurCodeDecl); 1181 1182 // Wasm uses Windows-style EH instructions, but merges all catch clauses into 1183 // one big catchpad. So we save the old funclet pad here before we traverse 1184 // each catch handler. 1185 SaveAndRestore<llvm::Instruction *> RestoreCurrentFuncletPad( 1186 CurrentFuncletPad); 1187 llvm::BasicBlock *WasmCatchStartBlock = nullptr; 1188 if (EHPersonality::get(*this).isWasmPersonality()) { 1189 auto *CatchSwitch = 1190 cast<llvm::CatchSwitchInst>(DispatchBlock->getFirstNonPHI()); 1191 WasmCatchStartBlock = CatchSwitch->hasUnwindDest() 1192 ? CatchSwitch->getSuccessor(1) 1193 : CatchSwitch->getSuccessor(0); 1194 auto *CPI = cast<llvm::CatchPadInst>(WasmCatchStartBlock->getFirstNonPHI()); 1195 CurrentFuncletPad = CPI; 1196 } 1197 1198 // Perversely, we emit the handlers backwards precisely because we 1199 // want them to appear in source order. In all of these cases, the 1200 // catch block will have exactly one predecessor, which will be a 1201 // particular block in the catch dispatch. However, in the case of 1202 // a catch-all, one of the dispatch blocks will branch to two 1203 // different handlers, and EmitBlockAfterUses will cause the second 1204 // handler to be moved before the first. 1205 bool HasCatchAll = false; 1206 for (unsigned I = NumHandlers; I != 0; --I) { 1207 HasCatchAll |= Handlers[I - 1].isCatchAll(); 1208 llvm::BasicBlock *CatchBlock = Handlers[I-1].Block; 1209 EmitBlockAfterUses(CatchBlock); 1210 1211 // Catch the exception if this isn't a catch-all. 1212 const CXXCatchStmt *C = S.getHandler(I-1); 1213 1214 // Enter a cleanup scope, including the catch variable and the 1215 // end-catch. 1216 RunCleanupsScope CatchScope(*this); 1217 1218 // Initialize the catch variable and set up the cleanups. 1219 SaveAndRestore<llvm::Instruction *> RestoreCurrentFuncletPad( 1220 CurrentFuncletPad); 1221 CGM.getCXXABI().emitBeginCatch(*this, C); 1222 1223 // Emit the PGO counter increment. 1224 incrementProfileCounter(C); 1225 1226 // Perform the body of the catch. 1227 EmitStmt(C->getHandlerBlock()); 1228 1229 // [except.handle]p11: 1230 // The currently handled exception is rethrown if control 1231 // reaches the end of a handler of the function-try-block of a 1232 // constructor or destructor. 1233 1234 // It is important that we only do this on fallthrough and not on 1235 // return. Note that it's illegal to put a return in a 1236 // constructor function-try-block's catch handler (p14), so this 1237 // really only applies to destructors. 1238 if (doImplicitRethrow && HaveInsertPoint()) { 1239 CGM.getCXXABI().emitRethrow(*this, /*isNoReturn*/false); 1240 Builder.CreateUnreachable(); 1241 Builder.ClearInsertionPoint(); 1242 } 1243 1244 // Fall out through the catch cleanups. 1245 CatchScope.ForceCleanup(); 1246 1247 // Branch out of the try. 1248 if (HaveInsertPoint()) 1249 Builder.CreateBr(ContBB); 1250 } 1251 1252 // Because in wasm we merge all catch clauses into one big catchpad, in case 1253 // none of the types in catch handlers matches after we test against each of 1254 // them, we should unwind to the next EH enclosing scope. We generate a call 1255 // to rethrow function here to do that. 1256 if (EHPersonality::get(*this).isWasmPersonality() && !HasCatchAll) { 1257 assert(WasmCatchStartBlock); 1258 // Navigate for the "rethrow" block we created in emitWasmCatchPadBlock(). 1259 // Wasm uses landingpad-style conditional branches to compare selectors, so 1260 // we follow the false destination for each of the cond branches to reach 1261 // the rethrow block. 1262 llvm::BasicBlock *RethrowBlock = WasmCatchStartBlock; 1263 while (llvm::Instruction *TI = RethrowBlock->getTerminator()) { 1264 auto *BI = cast<llvm::BranchInst>(TI); 1265 assert(BI->isConditional()); 1266 RethrowBlock = BI->getSuccessor(1); 1267 } 1268 assert(RethrowBlock != WasmCatchStartBlock && RethrowBlock->empty()); 1269 Builder.SetInsertPoint(RethrowBlock); 1270 llvm::Function *RethrowInCatchFn = 1271 CGM.getIntrinsic(llvm::Intrinsic::wasm_rethrow_in_catch); 1272 EmitNoreturnRuntimeCallOrInvoke(RethrowInCatchFn, {}); 1273 } 1274 1275 EmitBlock(ContBB); 1276 incrementProfileCounter(&S); 1277 } 1278 1279 namespace { 1280 struct CallEndCatchForFinally final : EHScopeStack::Cleanup { 1281 llvm::Value *ForEHVar; 1282 llvm::FunctionCallee EndCatchFn; 1283 CallEndCatchForFinally(llvm::Value *ForEHVar, 1284 llvm::FunctionCallee EndCatchFn) 1285 : ForEHVar(ForEHVar), EndCatchFn(EndCatchFn) {} 1286 1287 void Emit(CodeGenFunction &CGF, Flags flags) override { 1288 llvm::BasicBlock *EndCatchBB = CGF.createBasicBlock("finally.endcatch"); 1289 llvm::BasicBlock *CleanupContBB = 1290 CGF.createBasicBlock("finally.cleanup.cont"); 1291 1292 llvm::Value *ShouldEndCatch = 1293 CGF.Builder.CreateFlagLoad(ForEHVar, "finally.endcatch"); 1294 CGF.Builder.CreateCondBr(ShouldEndCatch, EndCatchBB, CleanupContBB); 1295 CGF.EmitBlock(EndCatchBB); 1296 CGF.EmitRuntimeCallOrInvoke(EndCatchFn); // catch-all, so might throw 1297 CGF.EmitBlock(CleanupContBB); 1298 } 1299 }; 1300 1301 struct PerformFinally final : EHScopeStack::Cleanup { 1302 const Stmt *Body; 1303 llvm::Value *ForEHVar; 1304 llvm::FunctionCallee EndCatchFn; 1305 llvm::FunctionCallee RethrowFn; 1306 llvm::Value *SavedExnVar; 1307 1308 PerformFinally(const Stmt *Body, llvm::Value *ForEHVar, 1309 llvm::FunctionCallee EndCatchFn, 1310 llvm::FunctionCallee RethrowFn, llvm::Value *SavedExnVar) 1311 : Body(Body), ForEHVar(ForEHVar), EndCatchFn(EndCatchFn), 1312 RethrowFn(RethrowFn), SavedExnVar(SavedExnVar) {} 1313 1314 void Emit(CodeGenFunction &CGF, Flags flags) override { 1315 // Enter a cleanup to call the end-catch function if one was provided. 1316 if (EndCatchFn) 1317 CGF.EHStack.pushCleanup<CallEndCatchForFinally>(NormalAndEHCleanup, 1318 ForEHVar, EndCatchFn); 1319 1320 // Save the current cleanup destination in case there are 1321 // cleanups in the finally block. 1322 llvm::Value *SavedCleanupDest = 1323 CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot(), 1324 "cleanup.dest.saved"); 1325 1326 // Emit the finally block. 1327 CGF.EmitStmt(Body); 1328 1329 // If the end of the finally is reachable, check whether this was 1330 // for EH. If so, rethrow. 1331 if (CGF.HaveInsertPoint()) { 1332 llvm::BasicBlock *RethrowBB = CGF.createBasicBlock("finally.rethrow"); 1333 llvm::BasicBlock *ContBB = CGF.createBasicBlock("finally.cont"); 1334 1335 llvm::Value *ShouldRethrow = 1336 CGF.Builder.CreateFlagLoad(ForEHVar, "finally.shouldthrow"); 1337 CGF.Builder.CreateCondBr(ShouldRethrow, RethrowBB, ContBB); 1338 1339 CGF.EmitBlock(RethrowBB); 1340 if (SavedExnVar) { 1341 CGF.EmitRuntimeCallOrInvoke(RethrowFn, 1342 CGF.Builder.CreateAlignedLoad(SavedExnVar, CGF.getPointerAlign())); 1343 } else { 1344 CGF.EmitRuntimeCallOrInvoke(RethrowFn); 1345 } 1346 CGF.Builder.CreateUnreachable(); 1347 1348 CGF.EmitBlock(ContBB); 1349 1350 // Restore the cleanup destination. 1351 CGF.Builder.CreateStore(SavedCleanupDest, 1352 CGF.getNormalCleanupDestSlot()); 1353 } 1354 1355 // Leave the end-catch cleanup. As an optimization, pretend that 1356 // the fallthrough path was inaccessible; we've dynamically proven 1357 // that we're not in the EH case along that path. 1358 if (EndCatchFn) { 1359 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP(); 1360 CGF.PopCleanupBlock(); 1361 CGF.Builder.restoreIP(SavedIP); 1362 } 1363 1364 // Now make sure we actually have an insertion point or the 1365 // cleanup gods will hate us. 1366 CGF.EnsureInsertPoint(); 1367 } 1368 }; 1369 } // end anonymous namespace 1370 1371 /// Enters a finally block for an implementation using zero-cost 1372 /// exceptions. This is mostly general, but hard-codes some 1373 /// language/ABI-specific behavior in the catch-all sections. 1374 void CodeGenFunction::FinallyInfo::enter(CodeGenFunction &CGF, const Stmt *body, 1375 llvm::FunctionCallee beginCatchFn, 1376 llvm::FunctionCallee endCatchFn, 1377 llvm::FunctionCallee rethrowFn) { 1378 assert((!!beginCatchFn) == (!!endCatchFn) && 1379 "begin/end catch functions not paired"); 1380 assert(rethrowFn && "rethrow function is required"); 1381 1382 BeginCatchFn = beginCatchFn; 1383 1384 // The rethrow function has one of the following two types: 1385 // void (*)() 1386 // void (*)(void*) 1387 // In the latter case we need to pass it the exception object. 1388 // But we can't use the exception slot because the @finally might 1389 // have a landing pad (which would overwrite the exception slot). 1390 llvm::FunctionType *rethrowFnTy = rethrowFn.getFunctionType(); 1391 SavedExnVar = nullptr; 1392 if (rethrowFnTy->getNumParams()) 1393 SavedExnVar = CGF.CreateTempAlloca(CGF.Int8PtrTy, "finally.exn"); 1394 1395 // A finally block is a statement which must be executed on any edge 1396 // out of a given scope. Unlike a cleanup, the finally block may 1397 // contain arbitrary control flow leading out of itself. In 1398 // addition, finally blocks should always be executed, even if there 1399 // are no catch handlers higher on the stack. Therefore, we 1400 // surround the protected scope with a combination of a normal 1401 // cleanup (to catch attempts to break out of the block via normal 1402 // control flow) and an EH catch-all (semantically "outside" any try 1403 // statement to which the finally block might have been attached). 1404 // The finally block itself is generated in the context of a cleanup 1405 // which conditionally leaves the catch-all. 1406 1407 // Jump destination for performing the finally block on an exception 1408 // edge. We'll never actually reach this block, so unreachable is 1409 // fine. 1410 RethrowDest = CGF.getJumpDestInCurrentScope(CGF.getUnreachableBlock()); 1411 1412 // Whether the finally block is being executed for EH purposes. 1413 ForEHVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), "finally.for-eh"); 1414 CGF.Builder.CreateFlagStore(false, ForEHVar); 1415 1416 // Enter a normal cleanup which will perform the @finally block. 1417 CGF.EHStack.pushCleanup<PerformFinally>(NormalCleanup, body, 1418 ForEHVar, endCatchFn, 1419 rethrowFn, SavedExnVar); 1420 1421 // Enter a catch-all scope. 1422 llvm::BasicBlock *catchBB = CGF.createBasicBlock("finally.catchall"); 1423 EHCatchScope *catchScope = CGF.EHStack.pushCatch(1); 1424 catchScope->setCatchAllHandler(0, catchBB); 1425 } 1426 1427 void CodeGenFunction::FinallyInfo::exit(CodeGenFunction &CGF) { 1428 // Leave the finally catch-all. 1429 EHCatchScope &catchScope = cast<EHCatchScope>(*CGF.EHStack.begin()); 1430 llvm::BasicBlock *catchBB = catchScope.getHandler(0).Block; 1431 1432 CGF.popCatchScope(); 1433 1434 // If there are any references to the catch-all block, emit it. 1435 if (catchBB->use_empty()) { 1436 delete catchBB; 1437 } else { 1438 CGBuilderTy::InsertPoint savedIP = CGF.Builder.saveAndClearIP(); 1439 CGF.EmitBlock(catchBB); 1440 1441 llvm::Value *exn = nullptr; 1442 1443 // If there's a begin-catch function, call it. 1444 if (BeginCatchFn) { 1445 exn = CGF.getExceptionFromSlot(); 1446 CGF.EmitNounwindRuntimeCall(BeginCatchFn, exn); 1447 } 1448 1449 // If we need to remember the exception pointer to rethrow later, do so. 1450 if (SavedExnVar) { 1451 if (!exn) exn = CGF.getExceptionFromSlot(); 1452 CGF.Builder.CreateAlignedStore(exn, SavedExnVar, CGF.getPointerAlign()); 1453 } 1454 1455 // Tell the cleanups in the finally block that we're do this for EH. 1456 CGF.Builder.CreateFlagStore(true, ForEHVar); 1457 1458 // Thread a jump through the finally cleanup. 1459 CGF.EmitBranchThroughCleanup(RethrowDest); 1460 1461 CGF.Builder.restoreIP(savedIP); 1462 } 1463 1464 // Finally, leave the @finally cleanup. 1465 CGF.PopCleanupBlock(); 1466 } 1467 1468 llvm::BasicBlock *CodeGenFunction::getTerminateLandingPad() { 1469 if (TerminateLandingPad) 1470 return TerminateLandingPad; 1471 1472 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); 1473 1474 // This will get inserted at the end of the function. 1475 TerminateLandingPad = createBasicBlock("terminate.lpad"); 1476 Builder.SetInsertPoint(TerminateLandingPad); 1477 1478 // Tell the backend that this is a landing pad. 1479 const EHPersonality &Personality = EHPersonality::get(*this); 1480 1481 if (!CurFn->hasPersonalityFn()) 1482 CurFn->setPersonalityFn(getOpaquePersonalityFn(CGM, Personality)); 1483 1484 llvm::LandingPadInst *LPadInst = 1485 Builder.CreateLandingPad(llvm::StructType::get(Int8PtrTy, Int32Ty), 0); 1486 LPadInst->addClause(getCatchAllValue(*this)); 1487 1488 llvm::Value *Exn = nullptr; 1489 if (getLangOpts().CPlusPlus) 1490 Exn = Builder.CreateExtractValue(LPadInst, 0); 1491 llvm::CallInst *terminateCall = 1492 CGM.getCXXABI().emitTerminateForUnexpectedException(*this, Exn); 1493 terminateCall->setDoesNotReturn(); 1494 Builder.CreateUnreachable(); 1495 1496 // Restore the saved insertion state. 1497 Builder.restoreIP(SavedIP); 1498 1499 return TerminateLandingPad; 1500 } 1501 1502 llvm::BasicBlock *CodeGenFunction::getTerminateHandler() { 1503 if (TerminateHandler) 1504 return TerminateHandler; 1505 1506 // Set up the terminate handler. This block is inserted at the very 1507 // end of the function by FinishFunction. 1508 TerminateHandler = createBasicBlock("terminate.handler"); 1509 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); 1510 Builder.SetInsertPoint(TerminateHandler); 1511 1512 llvm::Value *Exn = nullptr; 1513 if (getLangOpts().CPlusPlus) 1514 Exn = getExceptionFromSlot(); 1515 llvm::CallInst *terminateCall = 1516 CGM.getCXXABI().emitTerminateForUnexpectedException(*this, Exn); 1517 terminateCall->setDoesNotReturn(); 1518 Builder.CreateUnreachable(); 1519 1520 // Restore the saved insertion state. 1521 Builder.restoreIP(SavedIP); 1522 1523 return TerminateHandler; 1524 } 1525 1526 llvm::BasicBlock *CodeGenFunction::getTerminateFunclet() { 1527 assert(EHPersonality::get(*this).usesFuncletPads() && 1528 "use getTerminateLandingPad for non-funclet EH"); 1529 1530 llvm::BasicBlock *&TerminateFunclet = TerminateFunclets[CurrentFuncletPad]; 1531 if (TerminateFunclet) 1532 return TerminateFunclet; 1533 1534 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); 1535 1536 // Set up the terminate handler. This block is inserted at the very 1537 // end of the function by FinishFunction. 1538 TerminateFunclet = createBasicBlock("terminate.handler"); 1539 Builder.SetInsertPoint(TerminateFunclet); 1540 1541 // Create the cleanuppad using the current parent pad as its token. Use 'none' 1542 // if this is a top-level terminate scope, which is the common case. 1543 SaveAndRestore<llvm::Instruction *> RestoreCurrentFuncletPad( 1544 CurrentFuncletPad); 1545 llvm::Value *ParentPad = CurrentFuncletPad; 1546 if (!ParentPad) 1547 ParentPad = llvm::ConstantTokenNone::get(CGM.getLLVMContext()); 1548 CurrentFuncletPad = Builder.CreateCleanupPad(ParentPad); 1549 1550 // Emit the __std_terminate call. 1551 llvm::Value *Exn = nullptr; 1552 // In case of wasm personality, we need to pass the exception value to 1553 // __clang_call_terminate function. 1554 if (getLangOpts().CPlusPlus && 1555 EHPersonality::get(*this).isWasmPersonality()) { 1556 llvm::Function *GetExnFn = 1557 CGM.getIntrinsic(llvm::Intrinsic::wasm_get_exception); 1558 Exn = Builder.CreateCall(GetExnFn, CurrentFuncletPad); 1559 } 1560 llvm::CallInst *terminateCall = 1561 CGM.getCXXABI().emitTerminateForUnexpectedException(*this, Exn); 1562 terminateCall->setDoesNotReturn(); 1563 Builder.CreateUnreachable(); 1564 1565 // Restore the saved insertion state. 1566 Builder.restoreIP(SavedIP); 1567 1568 return TerminateFunclet; 1569 } 1570 1571 llvm::BasicBlock *CodeGenFunction::getEHResumeBlock(bool isCleanup) { 1572 if (EHResumeBlock) return EHResumeBlock; 1573 1574 CGBuilderTy::InsertPoint SavedIP = Builder.saveIP(); 1575 1576 // We emit a jump to a notional label at the outermost unwind state. 1577 EHResumeBlock = createBasicBlock("eh.resume"); 1578 Builder.SetInsertPoint(EHResumeBlock); 1579 1580 const EHPersonality &Personality = EHPersonality::get(*this); 1581 1582 // This can always be a call because we necessarily didn't find 1583 // anything on the EH stack which needs our help. 1584 const char *RethrowName = Personality.CatchallRethrowFn; 1585 if (RethrowName != nullptr && !isCleanup) { 1586 EmitRuntimeCall(getCatchallRethrowFn(CGM, RethrowName), 1587 getExceptionFromSlot())->setDoesNotReturn(); 1588 Builder.CreateUnreachable(); 1589 Builder.restoreIP(SavedIP); 1590 return EHResumeBlock; 1591 } 1592 1593 // Recreate the landingpad's return value for the 'resume' instruction. 1594 llvm::Value *Exn = getExceptionFromSlot(); 1595 llvm::Value *Sel = getSelectorFromSlot(); 1596 1597 llvm::Type *LPadType = llvm::StructType::get(Exn->getType(), Sel->getType()); 1598 llvm::Value *LPadVal = llvm::UndefValue::get(LPadType); 1599 LPadVal = Builder.CreateInsertValue(LPadVal, Exn, 0, "lpad.val"); 1600 LPadVal = Builder.CreateInsertValue(LPadVal, Sel, 1, "lpad.val"); 1601 1602 Builder.CreateResume(LPadVal); 1603 Builder.restoreIP(SavedIP); 1604 return EHResumeBlock; 1605 } 1606 1607 void CodeGenFunction::EmitSEHTryStmt(const SEHTryStmt &S) { 1608 EnterSEHTryStmt(S); 1609 { 1610 JumpDest TryExit = getJumpDestInCurrentScope("__try.__leave"); 1611 1612 SEHTryEpilogueStack.push_back(&TryExit); 1613 EmitStmt(S.getTryBlock()); 1614 SEHTryEpilogueStack.pop_back(); 1615 1616 if (!TryExit.getBlock()->use_empty()) 1617 EmitBlock(TryExit.getBlock(), /*IsFinished=*/true); 1618 else 1619 delete TryExit.getBlock(); 1620 } 1621 ExitSEHTryStmt(S); 1622 } 1623 1624 namespace { 1625 struct PerformSEHFinally final : EHScopeStack::Cleanup { 1626 llvm::Function *OutlinedFinally; 1627 PerformSEHFinally(llvm::Function *OutlinedFinally) 1628 : OutlinedFinally(OutlinedFinally) {} 1629 1630 void Emit(CodeGenFunction &CGF, Flags F) override { 1631 ASTContext &Context = CGF.getContext(); 1632 CodeGenModule &CGM = CGF.CGM; 1633 1634 CallArgList Args; 1635 1636 // Compute the two argument values. 1637 QualType ArgTys[2] = {Context.UnsignedCharTy, Context.VoidPtrTy}; 1638 llvm::Value *FP = nullptr; 1639 // If CFG.IsOutlinedSEHHelper is true, then we are within a finally block. 1640 if (CGF.IsOutlinedSEHHelper) { 1641 FP = &CGF.CurFn->arg_begin()[1]; 1642 } else { 1643 llvm::Function *LocalAddrFn = 1644 CGM.getIntrinsic(llvm::Intrinsic::localaddress); 1645 FP = CGF.Builder.CreateCall(LocalAddrFn); 1646 } 1647 1648 llvm::Value *IsForEH = 1649 llvm::ConstantInt::get(CGF.ConvertType(ArgTys[0]), F.isForEHCleanup()); 1650 1651 // Except _leave and fall-through at the end, all other exits in a _try 1652 // (return/goto/continue/break) are considered as abnormal terminations 1653 // since _leave/fall-through is always Indexed 0, 1654 // just use NormalCleanupDestSlot (>= 1 for goto/return/..), 1655 // as 1st Arg to indicate abnormal termination 1656 if (!F.isForEHCleanup() && F.hasExitSwitch()) { 1657 Address Addr = CGF.getNormalCleanupDestSlot(); 1658 llvm::Value *Load = CGF.Builder.CreateLoad(Addr, "cleanup.dest"); 1659 llvm::Value *Zero = llvm::Constant::getNullValue(CGM.Int32Ty); 1660 IsForEH = CGF.Builder.CreateICmpNE(Load, Zero); 1661 } 1662 1663 Args.add(RValue::get(IsForEH), ArgTys[0]); 1664 Args.add(RValue::get(FP), ArgTys[1]); 1665 1666 // Arrange a two-arg function info and type. 1667 const CGFunctionInfo &FnInfo = 1668 CGM.getTypes().arrangeBuiltinFunctionCall(Context.VoidTy, Args); 1669 1670 auto Callee = CGCallee::forDirect(OutlinedFinally); 1671 CGF.EmitCall(FnInfo, Callee, ReturnValueSlot(), Args); 1672 } 1673 }; 1674 } // end anonymous namespace 1675 1676 namespace { 1677 /// Find all local variable captures in the statement. 1678 struct CaptureFinder : ConstStmtVisitor<CaptureFinder> { 1679 CodeGenFunction &ParentCGF; 1680 const VarDecl *ParentThis; 1681 llvm::SmallSetVector<const VarDecl *, 4> Captures; 1682 Address SEHCodeSlot = Address::invalid(); 1683 CaptureFinder(CodeGenFunction &ParentCGF, const VarDecl *ParentThis) 1684 : ParentCGF(ParentCGF), ParentThis(ParentThis) {} 1685 1686 // Return true if we need to do any capturing work. 1687 bool foundCaptures() { 1688 return !Captures.empty() || SEHCodeSlot.isValid(); 1689 } 1690 1691 void Visit(const Stmt *S) { 1692 // See if this is a capture, then recurse. 1693 ConstStmtVisitor<CaptureFinder>::Visit(S); 1694 for (const Stmt *Child : S->children()) 1695 if (Child) 1696 Visit(Child); 1697 } 1698 1699 void VisitDeclRefExpr(const DeclRefExpr *E) { 1700 // If this is already a capture, just make sure we capture 'this'. 1701 if (E->refersToEnclosingVariableOrCapture()) { 1702 Captures.insert(ParentThis); 1703 return; 1704 } 1705 1706 const auto *D = dyn_cast<VarDecl>(E->getDecl()); 1707 if (D && D->isLocalVarDeclOrParm() && D->hasLocalStorage()) 1708 Captures.insert(D); 1709 } 1710 1711 void VisitCXXThisExpr(const CXXThisExpr *E) { 1712 Captures.insert(ParentThis); 1713 } 1714 1715 void VisitCallExpr(const CallExpr *E) { 1716 // We only need to add parent frame allocations for these builtins in x86. 1717 if (ParentCGF.getTarget().getTriple().getArch() != llvm::Triple::x86) 1718 return; 1719 1720 unsigned ID = E->getBuiltinCallee(); 1721 switch (ID) { 1722 case Builtin::BI__exception_code: 1723 case Builtin::BI_exception_code: 1724 // This is the simple case where we are the outermost finally. All we 1725 // have to do here is make sure we escape this and recover it in the 1726 // outlined handler. 1727 if (!SEHCodeSlot.isValid()) 1728 SEHCodeSlot = ParentCGF.SEHCodeSlotStack.back(); 1729 break; 1730 } 1731 } 1732 }; 1733 } // end anonymous namespace 1734 1735 Address CodeGenFunction::recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF, 1736 Address ParentVar, 1737 llvm::Value *ParentFP) { 1738 llvm::CallInst *RecoverCall = nullptr; 1739 CGBuilderTy Builder(*this, AllocaInsertPt); 1740 if (auto *ParentAlloca = dyn_cast<llvm::AllocaInst>(ParentVar.getPointer())) { 1741 // Mark the variable escaped if nobody else referenced it and compute the 1742 // localescape index. 1743 auto InsertPair = ParentCGF.EscapedLocals.insert( 1744 std::make_pair(ParentAlloca, ParentCGF.EscapedLocals.size())); 1745 int FrameEscapeIdx = InsertPair.first->second; 1746 // call i8* @llvm.localrecover(i8* bitcast(@parentFn), i8* %fp, i32 N) 1747 llvm::Function *FrameRecoverFn = llvm::Intrinsic::getDeclaration( 1748 &CGM.getModule(), llvm::Intrinsic::localrecover); 1749 llvm::Constant *ParentI8Fn = 1750 llvm::ConstantExpr::getBitCast(ParentCGF.CurFn, Int8PtrTy); 1751 RecoverCall = Builder.CreateCall( 1752 FrameRecoverFn, {ParentI8Fn, ParentFP, 1753 llvm::ConstantInt::get(Int32Ty, FrameEscapeIdx)}); 1754 1755 } else { 1756 // If the parent didn't have an alloca, we're doing some nested outlining. 1757 // Just clone the existing localrecover call, but tweak the FP argument to 1758 // use our FP value. All other arguments are constants. 1759 auto *ParentRecover = 1760 cast<llvm::IntrinsicInst>(ParentVar.getPointer()->stripPointerCasts()); 1761 assert(ParentRecover->getIntrinsicID() == llvm::Intrinsic::localrecover && 1762 "expected alloca or localrecover in parent LocalDeclMap"); 1763 RecoverCall = cast<llvm::CallInst>(ParentRecover->clone()); 1764 RecoverCall->setArgOperand(1, ParentFP); 1765 RecoverCall->insertBefore(AllocaInsertPt); 1766 } 1767 1768 // Bitcast the variable, rename it, and insert it in the local decl map. 1769 llvm::Value *ChildVar = 1770 Builder.CreateBitCast(RecoverCall, ParentVar.getType()); 1771 ChildVar->setName(ParentVar.getName()); 1772 return Address(ChildVar, ParentVar.getAlignment()); 1773 } 1774 1775 void CodeGenFunction::EmitCapturedLocals(CodeGenFunction &ParentCGF, 1776 const Stmt *OutlinedStmt, 1777 bool IsFilter) { 1778 // Find all captures in the Stmt. 1779 CaptureFinder Finder(ParentCGF, ParentCGF.CXXABIThisDecl); 1780 Finder.Visit(OutlinedStmt); 1781 1782 // We can exit early on x86_64 when there are no captures. We just have to 1783 // save the exception code in filters so that __exception_code() works. 1784 if (!Finder.foundCaptures() && 1785 CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) { 1786 if (IsFilter) 1787 EmitSEHExceptionCodeSave(ParentCGF, nullptr, nullptr); 1788 return; 1789 } 1790 1791 llvm::Value *EntryFP = nullptr; 1792 CGBuilderTy Builder(CGM, AllocaInsertPt); 1793 if (IsFilter && CGM.getTarget().getTriple().getArch() == llvm::Triple::x86) { 1794 // 32-bit SEH filters need to be careful about FP recovery. The end of the 1795 // EH registration is passed in as the EBP physical register. We can 1796 // recover that with llvm.frameaddress(1). 1797 EntryFP = Builder.CreateCall( 1798 CGM.getIntrinsic(llvm::Intrinsic::frameaddress, AllocaInt8PtrTy), 1799 {Builder.getInt32(1)}); 1800 } else { 1801 // Otherwise, for x64 and 32-bit finally functions, the parent FP is the 1802 // second parameter. 1803 auto AI = CurFn->arg_begin(); 1804 ++AI; 1805 EntryFP = &*AI; 1806 } 1807 1808 llvm::Value *ParentFP = EntryFP; 1809 if (IsFilter) { 1810 // Given whatever FP the runtime provided us in EntryFP, recover the true 1811 // frame pointer of the parent function. We only need to do this in filters, 1812 // since finally funclets recover the parent FP for us. 1813 llvm::Function *RecoverFPIntrin = 1814 CGM.getIntrinsic(llvm::Intrinsic::eh_recoverfp); 1815 llvm::Constant *ParentI8Fn = 1816 llvm::ConstantExpr::getBitCast(ParentCGF.CurFn, Int8PtrTy); 1817 ParentFP = Builder.CreateCall(RecoverFPIntrin, {ParentI8Fn, EntryFP}); 1818 1819 // if the parent is a _finally, the passed-in ParentFP is the FP 1820 // of parent _finally, not Establisher's FP (FP of outermost function). 1821 // Establkisher FP is 2nd paramenter passed into parent _finally. 1822 // Fortunately, it's always saved in parent's frame. The following 1823 // code retrieves it, and escapes it so that spill instruction won't be 1824 // optimized away. 1825 if (ParentCGF.ParentCGF != nullptr) { 1826 // Locate and escape Parent's frame_pointer.addr alloca 1827 // Depending on target, should be 1st/2nd one in LocalDeclMap. 1828 // Let's just scan for ImplicitParamDecl with VoidPtrTy. 1829 llvm::AllocaInst *FramePtrAddrAlloca = nullptr; 1830 for (auto &I : ParentCGF.LocalDeclMap) { 1831 const VarDecl *D = cast<VarDecl>(I.first); 1832 if (isa<ImplicitParamDecl>(D) && 1833 D->getType() == getContext().VoidPtrTy) { 1834 assert(D->getName().startswith("frame_pointer")); 1835 FramePtrAddrAlloca = cast<llvm::AllocaInst>(I.second.getPointer()); 1836 break; 1837 } 1838 } 1839 assert(FramePtrAddrAlloca); 1840 auto InsertPair = ParentCGF.EscapedLocals.insert( 1841 std::make_pair(FramePtrAddrAlloca, ParentCGF.EscapedLocals.size())); 1842 int FrameEscapeIdx = InsertPair.first->second; 1843 1844 // an example of a filter's prolog:: 1845 // %0 = call i8* @llvm.eh.recoverfp(bitcast(@"?fin$0@0@main@@"),..) 1846 // %1 = call i8* @llvm.localrecover(bitcast(@"?fin$0@0@main@@"),..) 1847 // %2 = bitcast i8* %1 to i8** 1848 // %3 = load i8*, i8* *%2, align 8 1849 // ==> %3 is the frame-pointer of outermost host function 1850 llvm::Function *FrameRecoverFn = llvm::Intrinsic::getDeclaration( 1851 &CGM.getModule(), llvm::Intrinsic::localrecover); 1852 llvm::Constant *ParentI8Fn = 1853 llvm::ConstantExpr::getBitCast(ParentCGF.CurFn, Int8PtrTy); 1854 ParentFP = Builder.CreateCall( 1855 FrameRecoverFn, {ParentI8Fn, ParentFP, 1856 llvm::ConstantInt::get(Int32Ty, FrameEscapeIdx)}); 1857 ParentFP = Builder.CreateBitCast(ParentFP, CGM.VoidPtrPtrTy); 1858 ParentFP = Builder.CreateLoad(Address(ParentFP, getPointerAlign())); 1859 } 1860 } 1861 1862 // Create llvm.localrecover calls for all captures. 1863 for (const VarDecl *VD : Finder.Captures) { 1864 if (isa<ImplicitParamDecl>(VD)) { 1865 CGM.ErrorUnsupported(VD, "'this' captured by SEH"); 1866 CXXThisValue = llvm::UndefValue::get(ConvertTypeForMem(VD->getType())); 1867 continue; 1868 } 1869 if (VD->getType()->isVariablyModifiedType()) { 1870 CGM.ErrorUnsupported(VD, "VLA captured by SEH"); 1871 continue; 1872 } 1873 assert((isa<ImplicitParamDecl>(VD) || VD->isLocalVarDeclOrParm()) && 1874 "captured non-local variable"); 1875 1876 // If this decl hasn't been declared yet, it will be declared in the 1877 // OutlinedStmt. 1878 auto I = ParentCGF.LocalDeclMap.find(VD); 1879 if (I == ParentCGF.LocalDeclMap.end()) 1880 continue; 1881 1882 Address ParentVar = I->second; 1883 setAddrOfLocalVar( 1884 VD, recoverAddrOfEscapedLocal(ParentCGF, ParentVar, ParentFP)); 1885 } 1886 1887 if (Finder.SEHCodeSlot.isValid()) { 1888 SEHCodeSlotStack.push_back( 1889 recoverAddrOfEscapedLocal(ParentCGF, Finder.SEHCodeSlot, ParentFP)); 1890 } 1891 1892 if (IsFilter) 1893 EmitSEHExceptionCodeSave(ParentCGF, ParentFP, EntryFP); 1894 } 1895 1896 /// Arrange a function prototype that can be called by Windows exception 1897 /// handling personalities. On Win64, the prototype looks like: 1898 /// RetTy func(void *EHPtrs, void *ParentFP); 1899 void CodeGenFunction::startOutlinedSEHHelper(CodeGenFunction &ParentCGF, 1900 bool IsFilter, 1901 const Stmt *OutlinedStmt) { 1902 SourceLocation StartLoc = OutlinedStmt->getBeginLoc(); 1903 1904 // Get the mangled function name. 1905 SmallString<128> Name; 1906 { 1907 llvm::raw_svector_ostream OS(Name); 1908 const NamedDecl *ParentSEHFn = ParentCGF.CurSEHParent; 1909 assert(ParentSEHFn && "No CurSEHParent!"); 1910 MangleContext &Mangler = CGM.getCXXABI().getMangleContext(); 1911 if (IsFilter) 1912 Mangler.mangleSEHFilterExpression(ParentSEHFn, OS); 1913 else 1914 Mangler.mangleSEHFinallyBlock(ParentSEHFn, OS); 1915 } 1916 1917 FunctionArgList Args; 1918 if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86 || !IsFilter) { 1919 // All SEH finally functions take two parameters. Win64 filters take two 1920 // parameters. Win32 filters take no parameters. 1921 if (IsFilter) { 1922 Args.push_back(ImplicitParamDecl::Create( 1923 getContext(), /*DC=*/nullptr, StartLoc, 1924 &getContext().Idents.get("exception_pointers"), 1925 getContext().VoidPtrTy, ImplicitParamDecl::Other)); 1926 } else { 1927 Args.push_back(ImplicitParamDecl::Create( 1928 getContext(), /*DC=*/nullptr, StartLoc, 1929 &getContext().Idents.get("abnormal_termination"), 1930 getContext().UnsignedCharTy, ImplicitParamDecl::Other)); 1931 } 1932 Args.push_back(ImplicitParamDecl::Create( 1933 getContext(), /*DC=*/nullptr, StartLoc, 1934 &getContext().Idents.get("frame_pointer"), getContext().VoidPtrTy, 1935 ImplicitParamDecl::Other)); 1936 } 1937 1938 QualType RetTy = IsFilter ? getContext().LongTy : getContext().VoidTy; 1939 1940 const CGFunctionInfo &FnInfo = 1941 CGM.getTypes().arrangeBuiltinFunctionDeclaration(RetTy, Args); 1942 1943 llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FnInfo); 1944 llvm::Function *Fn = llvm::Function::Create( 1945 FnTy, llvm::GlobalValue::InternalLinkage, Name.str(), &CGM.getModule()); 1946 1947 IsOutlinedSEHHelper = true; 1948 1949 StartFunction(GlobalDecl(), RetTy, Fn, FnInfo, Args, 1950 OutlinedStmt->getBeginLoc(), OutlinedStmt->getBeginLoc()); 1951 CurSEHParent = ParentCGF.CurSEHParent; 1952 1953 CGM.SetInternalFunctionAttributes(GlobalDecl(), CurFn, FnInfo); 1954 EmitCapturedLocals(ParentCGF, OutlinedStmt, IsFilter); 1955 } 1956 1957 /// Create a stub filter function that will ultimately hold the code of the 1958 /// filter expression. The EH preparation passes in LLVM will outline the code 1959 /// from the main function body into this stub. 1960 llvm::Function * 1961 CodeGenFunction::GenerateSEHFilterFunction(CodeGenFunction &ParentCGF, 1962 const SEHExceptStmt &Except) { 1963 const Expr *FilterExpr = Except.getFilterExpr(); 1964 startOutlinedSEHHelper(ParentCGF, true, FilterExpr); 1965 1966 // Emit the original filter expression, convert to i32, and return. 1967 llvm::Value *R = EmitScalarExpr(FilterExpr); 1968 R = Builder.CreateIntCast(R, ConvertType(getContext().LongTy), 1969 FilterExpr->getType()->isSignedIntegerType()); 1970 Builder.CreateStore(R, ReturnValue); 1971 1972 FinishFunction(FilterExpr->getEndLoc()); 1973 1974 return CurFn; 1975 } 1976 1977 llvm::Function * 1978 CodeGenFunction::GenerateSEHFinallyFunction(CodeGenFunction &ParentCGF, 1979 const SEHFinallyStmt &Finally) { 1980 const Stmt *FinallyBlock = Finally.getBlock(); 1981 startOutlinedSEHHelper(ParentCGF, false, FinallyBlock); 1982 1983 // Emit the original filter expression, convert to i32, and return. 1984 EmitStmt(FinallyBlock); 1985 1986 FinishFunction(FinallyBlock->getEndLoc()); 1987 1988 return CurFn; 1989 } 1990 1991 void CodeGenFunction::EmitSEHExceptionCodeSave(CodeGenFunction &ParentCGF, 1992 llvm::Value *ParentFP, 1993 llvm::Value *EntryFP) { 1994 // Get the pointer to the EXCEPTION_POINTERS struct. This is returned by the 1995 // __exception_info intrinsic. 1996 if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) { 1997 // On Win64, the info is passed as the first parameter to the filter. 1998 SEHInfo = &*CurFn->arg_begin(); 1999 SEHCodeSlotStack.push_back( 2000 CreateMemTemp(getContext().IntTy, "__exception_code")); 2001 } else { 2002 // On Win32, the EBP on entry to the filter points to the end of an 2003 // exception registration object. It contains 6 32-bit fields, and the info 2004 // pointer is stored in the second field. So, GEP 20 bytes backwards and 2005 // load the pointer. 2006 SEHInfo = Builder.CreateConstInBoundsGEP1_32(Int8Ty, EntryFP, -20); 2007 SEHInfo = Builder.CreateBitCast(SEHInfo, Int8PtrTy->getPointerTo()); 2008 SEHInfo = Builder.CreateAlignedLoad(Int8PtrTy, SEHInfo, getPointerAlign()); 2009 SEHCodeSlotStack.push_back(recoverAddrOfEscapedLocal( 2010 ParentCGF, ParentCGF.SEHCodeSlotStack.back(), ParentFP)); 2011 } 2012 2013 // Save the exception code in the exception slot to unify exception access in 2014 // the filter function and the landing pad. 2015 // struct EXCEPTION_POINTERS { 2016 // EXCEPTION_RECORD *ExceptionRecord; 2017 // CONTEXT *ContextRecord; 2018 // }; 2019 // int exceptioncode = exception_pointers->ExceptionRecord->ExceptionCode; 2020 llvm::Type *RecordTy = CGM.Int32Ty->getPointerTo(); 2021 llvm::Type *PtrsTy = llvm::StructType::get(RecordTy, CGM.VoidPtrTy); 2022 llvm::Value *Ptrs = Builder.CreateBitCast(SEHInfo, PtrsTy->getPointerTo()); 2023 llvm::Value *Rec = Builder.CreateStructGEP(PtrsTy, Ptrs, 0); 2024 Rec = Builder.CreateAlignedLoad(Rec, getPointerAlign()); 2025 llvm::Value *Code = Builder.CreateAlignedLoad(Rec, getIntAlign()); 2026 assert(!SEHCodeSlotStack.empty() && "emitting EH code outside of __except"); 2027 Builder.CreateStore(Code, SEHCodeSlotStack.back()); 2028 } 2029 2030 llvm::Value *CodeGenFunction::EmitSEHExceptionInfo() { 2031 // Sema should diagnose calling this builtin outside of a filter context, but 2032 // don't crash if we screw up. 2033 if (!SEHInfo) 2034 return llvm::UndefValue::get(Int8PtrTy); 2035 assert(SEHInfo->getType() == Int8PtrTy); 2036 return SEHInfo; 2037 } 2038 2039 llvm::Value *CodeGenFunction::EmitSEHExceptionCode() { 2040 assert(!SEHCodeSlotStack.empty() && "emitting EH code outside of __except"); 2041 return Builder.CreateLoad(SEHCodeSlotStack.back()); 2042 } 2043 2044 llvm::Value *CodeGenFunction::EmitSEHAbnormalTermination() { 2045 // Abnormal termination is just the first parameter to the outlined finally 2046 // helper. 2047 auto AI = CurFn->arg_begin(); 2048 return Builder.CreateZExt(&*AI, Int32Ty); 2049 } 2050 2051 void CodeGenFunction::pushSEHCleanup(CleanupKind Kind, 2052 llvm::Function *FinallyFunc) { 2053 EHStack.pushCleanup<PerformSEHFinally>(Kind, FinallyFunc); 2054 } 2055 2056 void CodeGenFunction::EnterSEHTryStmt(const SEHTryStmt &S) { 2057 CodeGenFunction HelperCGF(CGM, /*suppressNewContext=*/true); 2058 HelperCGF.ParentCGF = this; 2059 if (const SEHFinallyStmt *Finally = S.getFinallyHandler()) { 2060 // Outline the finally block. 2061 llvm::Function *FinallyFunc = 2062 HelperCGF.GenerateSEHFinallyFunction(*this, *Finally); 2063 2064 // Push a cleanup for __finally blocks. 2065 EHStack.pushCleanup<PerformSEHFinally>(NormalAndEHCleanup, FinallyFunc); 2066 return; 2067 } 2068 2069 // Otherwise, we must have an __except block. 2070 const SEHExceptStmt *Except = S.getExceptHandler(); 2071 assert(Except); 2072 EHCatchScope *CatchScope = EHStack.pushCatch(1); 2073 SEHCodeSlotStack.push_back( 2074 CreateMemTemp(getContext().IntTy, "__exception_code")); 2075 2076 // If the filter is known to evaluate to 1, then we can use the clause 2077 // "catch i8* null". We can't do this on x86 because the filter has to save 2078 // the exception code. 2079 llvm::Constant *C = 2080 ConstantEmitter(*this).tryEmitAbstract(Except->getFilterExpr(), 2081 getContext().IntTy); 2082 if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86 && C && 2083 C->isOneValue()) { 2084 CatchScope->setCatchAllHandler(0, createBasicBlock("__except")); 2085 return; 2086 } 2087 2088 // In general, we have to emit an outlined filter function. Use the function 2089 // in place of the RTTI typeinfo global that C++ EH uses. 2090 llvm::Function *FilterFunc = 2091 HelperCGF.GenerateSEHFilterFunction(*this, *Except); 2092 llvm::Constant *OpaqueFunc = 2093 llvm::ConstantExpr::getBitCast(FilterFunc, Int8PtrTy); 2094 CatchScope->setHandler(0, OpaqueFunc, createBasicBlock("__except.ret")); 2095 } 2096 2097 void CodeGenFunction::ExitSEHTryStmt(const SEHTryStmt &S) { 2098 // Just pop the cleanup if it's a __finally block. 2099 if (S.getFinallyHandler()) { 2100 PopCleanupBlock(); 2101 return; 2102 } 2103 2104 // Otherwise, we must have an __except block. 2105 const SEHExceptStmt *Except = S.getExceptHandler(); 2106 assert(Except && "__try must have __finally xor __except"); 2107 EHCatchScope &CatchScope = cast<EHCatchScope>(*EHStack.begin()); 2108 2109 // Don't emit the __except block if the __try block lacked invokes. 2110 // TODO: Model unwind edges from instructions, either with iload / istore or 2111 // a try body function. 2112 if (!CatchScope.hasEHBranches()) { 2113 CatchScope.clearHandlerBlocks(); 2114 EHStack.popCatch(); 2115 SEHCodeSlotStack.pop_back(); 2116 return; 2117 } 2118 2119 // The fall-through block. 2120 llvm::BasicBlock *ContBB = createBasicBlock("__try.cont"); 2121 2122 // We just emitted the body of the __try; jump to the continue block. 2123 if (HaveInsertPoint()) 2124 Builder.CreateBr(ContBB); 2125 2126 // Check if our filter function returned true. 2127 emitCatchDispatchBlock(*this, CatchScope); 2128 2129 // Grab the block before we pop the handler. 2130 llvm::BasicBlock *CatchPadBB = CatchScope.getHandler(0).Block; 2131 EHStack.popCatch(); 2132 2133 EmitBlockAfterUses(CatchPadBB); 2134 2135 // __except blocks don't get outlined into funclets, so immediately do a 2136 // catchret. 2137 llvm::CatchPadInst *CPI = 2138 cast<llvm::CatchPadInst>(CatchPadBB->getFirstNonPHI()); 2139 llvm::BasicBlock *ExceptBB = createBasicBlock("__except"); 2140 Builder.CreateCatchRet(CPI, ExceptBB); 2141 EmitBlock(ExceptBB); 2142 2143 // On Win64, the exception code is returned in EAX. Copy it into the slot. 2144 if (CGM.getTarget().getTriple().getArch() != llvm::Triple::x86) { 2145 llvm::Function *SEHCodeIntrin = 2146 CGM.getIntrinsic(llvm::Intrinsic::eh_exceptioncode); 2147 llvm::Value *Code = Builder.CreateCall(SEHCodeIntrin, {CPI}); 2148 Builder.CreateStore(Code, SEHCodeSlotStack.back()); 2149 } 2150 2151 // Emit the __except body. 2152 EmitStmt(Except->getBlock()); 2153 2154 // End the lifetime of the exception code. 2155 SEHCodeSlotStack.pop_back(); 2156 2157 if (HaveInsertPoint()) 2158 Builder.CreateBr(ContBB); 2159 2160 EmitBlock(ContBB); 2161 } 2162 2163 void CodeGenFunction::EmitSEHLeaveStmt(const SEHLeaveStmt &S) { 2164 // If this code is reachable then emit a stop point (if generating 2165 // debug info). We have to do this ourselves because we are on the 2166 // "simple" statement path. 2167 if (HaveInsertPoint()) 2168 EmitStopPoint(&S); 2169 2170 // This must be a __leave from a __finally block, which we warn on and is UB. 2171 // Just emit unreachable. 2172 if (!isSEHTryScope()) { 2173 Builder.CreateUnreachable(); 2174 Builder.ClearInsertionPoint(); 2175 return; 2176 } 2177 2178 EmitBranchThroughCleanup(*SEHTryEpilogueStack.back()); 2179 } 2180