1 //===--- CGCleanup.cpp - Bookkeeping and code emission for cleanups -------===// 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 file contains code dealing with the IR generation for cleanups 10 // and related information. 11 // 12 // A "cleanup" is a piece of code which needs to be executed whenever 13 // control transfers out of a particular scope. This can be 14 // conditionalized to occur only on exceptional control flow, only on 15 // normal control flow, or both. 16 // 17 //===----------------------------------------------------------------------===// 18 19 #include "CGCleanup.h" 20 #include "CodeGenFunction.h" 21 #include "llvm/Support/SaveAndRestore.h" 22 23 using namespace clang; 24 using namespace CodeGen; 25 26 bool DominatingValue<RValue>::saved_type::needsSaving(RValue rv) { 27 if (rv.isScalar()) 28 return DominatingLLVMValue::needsSaving(rv.getScalarVal()); 29 if (rv.isAggregate()) 30 return DominatingLLVMValue::needsSaving(rv.getAggregatePointer()); 31 return true; 32 } 33 34 DominatingValue<RValue>::saved_type 35 DominatingValue<RValue>::saved_type::save(CodeGenFunction &CGF, RValue rv) { 36 if (rv.isScalar()) { 37 llvm::Value *V = rv.getScalarVal(); 38 39 // These automatically dominate and don't need to be saved. 40 if (!DominatingLLVMValue::needsSaving(V)) 41 return saved_type(V, nullptr, ScalarLiteral); 42 43 // Everything else needs an alloca. 44 Address addr = 45 CGF.CreateDefaultAlignTempAlloca(V->getType(), "saved-rvalue"); 46 CGF.Builder.CreateStore(V, addr); 47 return saved_type(addr.getPointer(), nullptr, ScalarAddress); 48 } 49 50 if (rv.isComplex()) { 51 CodeGenFunction::ComplexPairTy V = rv.getComplexVal(); 52 llvm::Type *ComplexTy = 53 llvm::StructType::get(V.first->getType(), V.second->getType()); 54 Address addr = CGF.CreateDefaultAlignTempAlloca(ComplexTy, "saved-complex"); 55 CGF.Builder.CreateStore(V.first, CGF.Builder.CreateStructGEP(addr, 0)); 56 CGF.Builder.CreateStore(V.second, CGF.Builder.CreateStructGEP(addr, 1)); 57 return saved_type(addr.getPointer(), nullptr, ComplexAddress); 58 } 59 60 assert(rv.isAggregate()); 61 Address V = rv.getAggregateAddress(); // TODO: volatile? 62 if (!DominatingLLVMValue::needsSaving(V.getPointer())) 63 return saved_type(V.getPointer(), V.getElementType(), AggregateLiteral, 64 V.getAlignment().getQuantity()); 65 66 Address addr = 67 CGF.CreateTempAlloca(V.getType(), CGF.getPointerAlign(), "saved-rvalue"); 68 CGF.Builder.CreateStore(V.getPointer(), addr); 69 return saved_type(addr.getPointer(), V.getElementType(), AggregateAddress, 70 V.getAlignment().getQuantity()); 71 } 72 73 /// Given a saved r-value produced by SaveRValue, perform the code 74 /// necessary to restore it to usability at the current insertion 75 /// point. 76 RValue DominatingValue<RValue>::saved_type::restore(CodeGenFunction &CGF) { 77 auto getSavingAddress = [&](llvm::Value *value) { 78 auto *AI = cast<llvm::AllocaInst>(value); 79 return Address(value, AI->getAllocatedType(), 80 CharUnits::fromQuantity(AI->getAlign().value())); 81 }; 82 switch (K) { 83 case ScalarLiteral: 84 return RValue::get(Value); 85 case ScalarAddress: 86 return RValue::get(CGF.Builder.CreateLoad(getSavingAddress(Value))); 87 case AggregateLiteral: 88 return RValue::getAggregate( 89 Address(Value, ElementType, CharUnits::fromQuantity(Align))); 90 case AggregateAddress: { 91 auto addr = CGF.Builder.CreateLoad(getSavingAddress(Value)); 92 return RValue::getAggregate( 93 Address(addr, ElementType, CharUnits::fromQuantity(Align))); 94 } 95 case ComplexAddress: { 96 Address address = getSavingAddress(Value); 97 llvm::Value *real = 98 CGF.Builder.CreateLoad(CGF.Builder.CreateStructGEP(address, 0)); 99 llvm::Value *imag = 100 CGF.Builder.CreateLoad(CGF.Builder.CreateStructGEP(address, 1)); 101 return RValue::getComplex(real, imag); 102 } 103 } 104 105 llvm_unreachable("bad saved r-value kind"); 106 } 107 108 /// Push an entry of the given size onto this protected-scope stack. 109 char *EHScopeStack::allocate(size_t Size) { 110 Size = llvm::alignTo(Size, ScopeStackAlignment); 111 if (!StartOfBuffer) { 112 unsigned Capacity = 1024; 113 while (Capacity < Size) Capacity *= 2; 114 StartOfBuffer = new char[Capacity]; 115 StartOfData = EndOfBuffer = StartOfBuffer + Capacity; 116 } else if (static_cast<size_t>(StartOfData - StartOfBuffer) < Size) { 117 unsigned CurrentCapacity = EndOfBuffer - StartOfBuffer; 118 unsigned UsedCapacity = CurrentCapacity - (StartOfData - StartOfBuffer); 119 120 unsigned NewCapacity = CurrentCapacity; 121 do { 122 NewCapacity *= 2; 123 } while (NewCapacity < UsedCapacity + Size); 124 125 char *NewStartOfBuffer = new char[NewCapacity]; 126 char *NewEndOfBuffer = NewStartOfBuffer + NewCapacity; 127 char *NewStartOfData = NewEndOfBuffer - UsedCapacity; 128 memcpy(NewStartOfData, StartOfData, UsedCapacity); 129 delete [] StartOfBuffer; 130 StartOfBuffer = NewStartOfBuffer; 131 EndOfBuffer = NewEndOfBuffer; 132 StartOfData = NewStartOfData; 133 } 134 135 assert(StartOfBuffer + Size <= StartOfData); 136 StartOfData -= Size; 137 return StartOfData; 138 } 139 140 void EHScopeStack::deallocate(size_t Size) { 141 StartOfData += llvm::alignTo(Size, ScopeStackAlignment); 142 } 143 144 bool EHScopeStack::containsOnlyLifetimeMarkers( 145 EHScopeStack::stable_iterator Old) const { 146 for (EHScopeStack::iterator it = begin(); stabilize(it) != Old; it++) { 147 EHCleanupScope *cleanup = dyn_cast<EHCleanupScope>(&*it); 148 if (!cleanup || !cleanup->isLifetimeMarker()) 149 return false; 150 } 151 152 return true; 153 } 154 155 bool EHScopeStack::requiresLandingPad() const { 156 for (stable_iterator si = getInnermostEHScope(); si != stable_end(); ) { 157 // Skip lifetime markers. 158 if (auto *cleanup = dyn_cast<EHCleanupScope>(&*find(si))) 159 if (cleanup->isLifetimeMarker()) { 160 si = cleanup->getEnclosingEHScope(); 161 continue; 162 } 163 return true; 164 } 165 166 return false; 167 } 168 169 EHScopeStack::stable_iterator 170 EHScopeStack::getInnermostActiveNormalCleanup() const { 171 for (stable_iterator si = getInnermostNormalCleanup(), se = stable_end(); 172 si != se; ) { 173 EHCleanupScope &cleanup = cast<EHCleanupScope>(*find(si)); 174 if (cleanup.isActive()) return si; 175 si = cleanup.getEnclosingNormalCleanup(); 176 } 177 return stable_end(); 178 } 179 180 181 void *EHScopeStack::pushCleanup(CleanupKind Kind, size_t Size) { 182 char *Buffer = allocate(EHCleanupScope::getSizeForCleanupSize(Size)); 183 bool IsNormalCleanup = Kind & NormalCleanup; 184 bool IsEHCleanup = Kind & EHCleanup; 185 bool IsLifetimeMarker = Kind & LifetimeMarker; 186 187 // Per C++ [except.terminate], it is implementation-defined whether none, 188 // some, or all cleanups are called before std::terminate. Thus, when 189 // terminate is the current EH scope, we may skip adding any EH cleanup 190 // scopes. 191 if (InnermostEHScope != stable_end() && 192 find(InnermostEHScope)->getKind() == EHScope::Terminate) 193 IsEHCleanup = false; 194 195 EHCleanupScope *Scope = 196 new (Buffer) EHCleanupScope(IsNormalCleanup, 197 IsEHCleanup, 198 Size, 199 BranchFixups.size(), 200 InnermostNormalCleanup, 201 InnermostEHScope); 202 if (IsNormalCleanup) 203 InnermostNormalCleanup = stable_begin(); 204 if (IsEHCleanup) 205 InnermostEHScope = stable_begin(); 206 if (IsLifetimeMarker) 207 Scope->setLifetimeMarker(); 208 209 // With Windows -EHa, Invoke llvm.seh.scope.begin() for EHCleanup 210 // If exceptions are disabled/ignored and SEH is not in use, then there is no 211 // invoke destination. SEH "works" even if exceptions are off. In practice, 212 // this means that C++ destructors and other EH cleanups don't run, which is 213 // consistent with MSVC's behavior, except in the presence of -EHa. 214 // Check getInvokeDest() to generate llvm.seh.scope.begin() as needed. 215 if (CGF->getLangOpts().EHAsynch && IsEHCleanup && !IsLifetimeMarker && 216 CGF->getTarget().getCXXABI().isMicrosoft() && CGF->getInvokeDest()) 217 CGF->EmitSehCppScopeBegin(); 218 219 return Scope->getCleanupBuffer(); 220 } 221 222 void EHScopeStack::popCleanup() { 223 assert(!empty() && "popping exception stack when not empty"); 224 225 assert(isa<EHCleanupScope>(*begin())); 226 EHCleanupScope &Cleanup = cast<EHCleanupScope>(*begin()); 227 InnermostNormalCleanup = Cleanup.getEnclosingNormalCleanup(); 228 InnermostEHScope = Cleanup.getEnclosingEHScope(); 229 deallocate(Cleanup.getAllocatedSize()); 230 231 // Destroy the cleanup. 232 Cleanup.Destroy(); 233 234 // Check whether we can shrink the branch-fixups stack. 235 if (!BranchFixups.empty()) { 236 // If we no longer have any normal cleanups, all the fixups are 237 // complete. 238 if (!hasNormalCleanups()) 239 BranchFixups.clear(); 240 241 // Otherwise we can still trim out unnecessary nulls. 242 else 243 popNullFixups(); 244 } 245 } 246 247 EHFilterScope *EHScopeStack::pushFilter(unsigned numFilters) { 248 assert(getInnermostEHScope() == stable_end()); 249 char *buffer = allocate(EHFilterScope::getSizeForNumFilters(numFilters)); 250 EHFilterScope *filter = new (buffer) EHFilterScope(numFilters); 251 InnermostEHScope = stable_begin(); 252 return filter; 253 } 254 255 void EHScopeStack::popFilter() { 256 assert(!empty() && "popping exception stack when not empty"); 257 258 EHFilterScope &filter = cast<EHFilterScope>(*begin()); 259 deallocate(EHFilterScope::getSizeForNumFilters(filter.getNumFilters())); 260 261 InnermostEHScope = filter.getEnclosingEHScope(); 262 } 263 264 EHCatchScope *EHScopeStack::pushCatch(unsigned numHandlers) { 265 char *buffer = allocate(EHCatchScope::getSizeForNumHandlers(numHandlers)); 266 EHCatchScope *scope = 267 new (buffer) EHCatchScope(numHandlers, InnermostEHScope); 268 InnermostEHScope = stable_begin(); 269 return scope; 270 } 271 272 void EHScopeStack::pushTerminate() { 273 char *Buffer = allocate(EHTerminateScope::getSize()); 274 new (Buffer) EHTerminateScope(InnermostEHScope); 275 InnermostEHScope = stable_begin(); 276 } 277 278 /// Remove any 'null' fixups on the stack. However, we can't pop more 279 /// fixups than the fixup depth on the innermost normal cleanup, or 280 /// else fixups that we try to add to that cleanup will end up in the 281 /// wrong place. We *could* try to shrink fixup depths, but that's 282 /// actually a lot of work for little benefit. 283 void EHScopeStack::popNullFixups() { 284 // We expect this to only be called when there's still an innermost 285 // normal cleanup; otherwise there really shouldn't be any fixups. 286 assert(hasNormalCleanups()); 287 288 EHScopeStack::iterator it = find(InnermostNormalCleanup); 289 unsigned MinSize = cast<EHCleanupScope>(*it).getFixupDepth(); 290 assert(BranchFixups.size() >= MinSize && "fixup stack out of order"); 291 292 while (BranchFixups.size() > MinSize && 293 BranchFixups.back().Destination == nullptr) 294 BranchFixups.pop_back(); 295 } 296 297 Address CodeGenFunction::createCleanupActiveFlag() { 298 // Create a variable to decide whether the cleanup needs to be run. 299 Address active = CreateTempAllocaWithoutCast( 300 Builder.getInt1Ty(), CharUnits::One(), "cleanup.cond"); 301 302 // Initialize it to false at a site that's guaranteed to be run 303 // before each evaluation. 304 setBeforeOutermostConditional(Builder.getFalse(), active); 305 306 // Initialize it to true at the current location. 307 Builder.CreateStore(Builder.getTrue(), active); 308 309 return active; 310 } 311 312 void CodeGenFunction::initFullExprCleanupWithFlag(Address ActiveFlag) { 313 // Set that as the active flag in the cleanup. 314 EHCleanupScope &cleanup = cast<EHCleanupScope>(*EHStack.begin()); 315 assert(!cleanup.hasActiveFlag() && "cleanup already has active flag?"); 316 cleanup.setActiveFlag(ActiveFlag); 317 318 if (cleanup.isNormalCleanup()) cleanup.setTestFlagInNormalCleanup(); 319 if (cleanup.isEHCleanup()) cleanup.setTestFlagInEHCleanup(); 320 } 321 322 void EHScopeStack::Cleanup::anchor() {} 323 324 static void createStoreInstBefore(llvm::Value *value, Address addr, 325 llvm::Instruction *beforeInst) { 326 auto store = new llvm::StoreInst(value, addr.getPointer(), beforeInst); 327 store->setAlignment(addr.getAlignment().getAsAlign()); 328 } 329 330 static llvm::LoadInst *createLoadInstBefore(Address addr, const Twine &name, 331 llvm::Instruction *beforeInst) { 332 return new llvm::LoadInst(addr.getElementType(), addr.getPointer(), name, 333 false, addr.getAlignment().getAsAlign(), 334 beforeInst); 335 } 336 337 /// All the branch fixups on the EH stack have propagated out past the 338 /// outermost normal cleanup; resolve them all by adding cases to the 339 /// given switch instruction. 340 static void ResolveAllBranchFixups(CodeGenFunction &CGF, 341 llvm::SwitchInst *Switch, 342 llvm::BasicBlock *CleanupEntry) { 343 llvm::SmallPtrSet<llvm::BasicBlock*, 4> CasesAdded; 344 345 for (unsigned I = 0, E = CGF.EHStack.getNumBranchFixups(); I != E; ++I) { 346 // Skip this fixup if its destination isn't set. 347 BranchFixup &Fixup = CGF.EHStack.getBranchFixup(I); 348 if (Fixup.Destination == nullptr) continue; 349 350 // If there isn't an OptimisticBranchBlock, then InitialBranch is 351 // still pointing directly to its destination; forward it to the 352 // appropriate cleanup entry. This is required in the specific 353 // case of 354 // { std::string s; goto lbl; } 355 // lbl: 356 // i.e. where there's an unresolved fixup inside a single cleanup 357 // entry which we're currently popping. 358 if (Fixup.OptimisticBranchBlock == nullptr) { 359 createStoreInstBefore(CGF.Builder.getInt32(Fixup.DestinationIndex), 360 CGF.getNormalCleanupDestSlot(), 361 Fixup.InitialBranch); 362 Fixup.InitialBranch->setSuccessor(0, CleanupEntry); 363 } 364 365 // Don't add this case to the switch statement twice. 366 if (!CasesAdded.insert(Fixup.Destination).second) 367 continue; 368 369 Switch->addCase(CGF.Builder.getInt32(Fixup.DestinationIndex), 370 Fixup.Destination); 371 } 372 373 CGF.EHStack.clearFixups(); 374 } 375 376 /// Transitions the terminator of the given exit-block of a cleanup to 377 /// be a cleanup switch. 378 static llvm::SwitchInst *TransitionToCleanupSwitch(CodeGenFunction &CGF, 379 llvm::BasicBlock *Block) { 380 // If it's a branch, turn it into a switch whose default 381 // destination is its original target. 382 llvm::Instruction *Term = Block->getTerminator(); 383 assert(Term && "can't transition block without terminator"); 384 385 if (llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Term)) { 386 assert(Br->isUnconditional()); 387 auto Load = createLoadInstBefore(CGF.getNormalCleanupDestSlot(), 388 "cleanup.dest", Term); 389 llvm::SwitchInst *Switch = 390 llvm::SwitchInst::Create(Load, Br->getSuccessor(0), 4, Block); 391 Br->eraseFromParent(); 392 return Switch; 393 } else { 394 return cast<llvm::SwitchInst>(Term); 395 } 396 } 397 398 void CodeGenFunction::ResolveBranchFixups(llvm::BasicBlock *Block) { 399 assert(Block && "resolving a null target block"); 400 if (!EHStack.getNumBranchFixups()) return; 401 402 assert(EHStack.hasNormalCleanups() && 403 "branch fixups exist with no normal cleanups on stack"); 404 405 llvm::SmallPtrSet<llvm::BasicBlock*, 4> ModifiedOptimisticBlocks; 406 bool ResolvedAny = false; 407 408 for (unsigned I = 0, E = EHStack.getNumBranchFixups(); I != E; ++I) { 409 // Skip this fixup if its destination doesn't match. 410 BranchFixup &Fixup = EHStack.getBranchFixup(I); 411 if (Fixup.Destination != Block) continue; 412 413 Fixup.Destination = nullptr; 414 ResolvedAny = true; 415 416 // If it doesn't have an optimistic branch block, LatestBranch is 417 // already pointing to the right place. 418 llvm::BasicBlock *BranchBB = Fixup.OptimisticBranchBlock; 419 if (!BranchBB) 420 continue; 421 422 // Don't process the same optimistic branch block twice. 423 if (!ModifiedOptimisticBlocks.insert(BranchBB).second) 424 continue; 425 426 llvm::SwitchInst *Switch = TransitionToCleanupSwitch(*this, BranchBB); 427 428 // Add a case to the switch. 429 Switch->addCase(Builder.getInt32(Fixup.DestinationIndex), Block); 430 } 431 432 if (ResolvedAny) 433 EHStack.popNullFixups(); 434 } 435 436 /// Pops cleanup blocks until the given savepoint is reached. 437 void CodeGenFunction::PopCleanupBlocks( 438 EHScopeStack::stable_iterator Old, 439 std::initializer_list<llvm::Value **> ValuesToReload) { 440 assert(Old.isValid()); 441 442 bool HadBranches = false; 443 while (EHStack.stable_begin() != Old) { 444 EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.begin()); 445 HadBranches |= Scope.hasBranches(); 446 447 // As long as Old strictly encloses the scope's enclosing normal 448 // cleanup, we're going to emit another normal cleanup which 449 // fallthrough can propagate through. 450 bool FallThroughIsBranchThrough = 451 Old.strictlyEncloses(Scope.getEnclosingNormalCleanup()); 452 453 PopCleanupBlock(FallThroughIsBranchThrough); 454 } 455 456 // If we didn't have any branches, the insertion point before cleanups must 457 // dominate the current insertion point and we don't need to reload any 458 // values. 459 if (!HadBranches) 460 return; 461 462 // Spill and reload all values that the caller wants to be live at the current 463 // insertion point. 464 for (llvm::Value **ReloadedValue : ValuesToReload) { 465 auto *Inst = dyn_cast_or_null<llvm::Instruction>(*ReloadedValue); 466 if (!Inst) 467 continue; 468 469 // Don't spill static allocas, they dominate all cleanups. These are created 470 // by binding a reference to a local variable or temporary. 471 auto *AI = dyn_cast<llvm::AllocaInst>(Inst); 472 if (AI && AI->isStaticAlloca()) 473 continue; 474 475 Address Tmp = 476 CreateDefaultAlignTempAlloca(Inst->getType(), "tmp.exprcleanup"); 477 478 // Find an insertion point after Inst and spill it to the temporary. 479 llvm::BasicBlock::iterator InsertBefore; 480 if (auto *Invoke = dyn_cast<llvm::InvokeInst>(Inst)) 481 InsertBefore = Invoke->getNormalDest()->getFirstInsertionPt(); 482 else 483 InsertBefore = std::next(Inst->getIterator()); 484 CGBuilderTy(CGM, &*InsertBefore).CreateStore(Inst, Tmp); 485 486 // Reload the value at the current insertion point. 487 *ReloadedValue = Builder.CreateLoad(Tmp); 488 } 489 } 490 491 /// Pops cleanup blocks until the given savepoint is reached, then add the 492 /// cleanups from the given savepoint in the lifetime-extended cleanups stack. 493 void CodeGenFunction::PopCleanupBlocks( 494 EHScopeStack::stable_iterator Old, size_t OldLifetimeExtendedSize, 495 std::initializer_list<llvm::Value **> ValuesToReload) { 496 PopCleanupBlocks(Old, ValuesToReload); 497 498 // Move our deferred cleanups onto the EH stack. 499 for (size_t I = OldLifetimeExtendedSize, 500 E = LifetimeExtendedCleanupStack.size(); I != E; /**/) { 501 // Alignment should be guaranteed by the vptrs in the individual cleanups. 502 assert((I % alignof(LifetimeExtendedCleanupHeader) == 0) && 503 "misaligned cleanup stack entry"); 504 505 LifetimeExtendedCleanupHeader &Header = 506 reinterpret_cast<LifetimeExtendedCleanupHeader&>( 507 LifetimeExtendedCleanupStack[I]); 508 I += sizeof(Header); 509 510 EHStack.pushCopyOfCleanup(Header.getKind(), 511 &LifetimeExtendedCleanupStack[I], 512 Header.getSize()); 513 I += Header.getSize(); 514 515 if (Header.isConditional()) { 516 Address ActiveFlag = 517 reinterpret_cast<Address &>(LifetimeExtendedCleanupStack[I]); 518 initFullExprCleanupWithFlag(ActiveFlag); 519 I += sizeof(ActiveFlag); 520 } 521 } 522 LifetimeExtendedCleanupStack.resize(OldLifetimeExtendedSize); 523 } 524 525 static llvm::BasicBlock *CreateNormalEntry(CodeGenFunction &CGF, 526 EHCleanupScope &Scope) { 527 assert(Scope.isNormalCleanup()); 528 llvm::BasicBlock *Entry = Scope.getNormalBlock(); 529 if (!Entry) { 530 Entry = CGF.createBasicBlock("cleanup"); 531 Scope.setNormalBlock(Entry); 532 } 533 return Entry; 534 } 535 536 /// Attempts to reduce a cleanup's entry block to a fallthrough. This 537 /// is basically llvm::MergeBlockIntoPredecessor, except 538 /// simplified/optimized for the tighter constraints on cleanup blocks. 539 /// 540 /// Returns the new block, whatever it is. 541 static llvm::BasicBlock *SimplifyCleanupEntry(CodeGenFunction &CGF, 542 llvm::BasicBlock *Entry) { 543 llvm::BasicBlock *Pred = Entry->getSinglePredecessor(); 544 if (!Pred) return Entry; 545 546 llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Pred->getTerminator()); 547 if (!Br || Br->isConditional()) return Entry; 548 assert(Br->getSuccessor(0) == Entry); 549 550 // If we were previously inserting at the end of the cleanup entry 551 // block, we'll need to continue inserting at the end of the 552 // predecessor. 553 bool WasInsertBlock = CGF.Builder.GetInsertBlock() == Entry; 554 assert(!WasInsertBlock || CGF.Builder.GetInsertPoint() == Entry->end()); 555 556 // Kill the branch. 557 Br->eraseFromParent(); 558 559 // Replace all uses of the entry with the predecessor, in case there 560 // are phis in the cleanup. 561 Entry->replaceAllUsesWith(Pred); 562 563 // Merge the blocks. 564 Pred->splice(Pred->end(), Entry); 565 566 // Kill the entry block. 567 Entry->eraseFromParent(); 568 569 if (WasInsertBlock) 570 CGF.Builder.SetInsertPoint(Pred); 571 572 return Pred; 573 } 574 575 static void EmitCleanup(CodeGenFunction &CGF, 576 EHScopeStack::Cleanup *Fn, 577 EHScopeStack::Cleanup::Flags flags, 578 Address ActiveFlag) { 579 // If there's an active flag, load it and skip the cleanup if it's 580 // false. 581 llvm::BasicBlock *ContBB = nullptr; 582 if (ActiveFlag.isValid()) { 583 ContBB = CGF.createBasicBlock("cleanup.done"); 584 llvm::BasicBlock *CleanupBB = CGF.createBasicBlock("cleanup.action"); 585 llvm::Value *IsActive 586 = CGF.Builder.CreateLoad(ActiveFlag, "cleanup.is_active"); 587 CGF.Builder.CreateCondBr(IsActive, CleanupBB, ContBB); 588 CGF.EmitBlock(CleanupBB); 589 } 590 591 // Ask the cleanup to emit itself. 592 Fn->Emit(CGF, flags); 593 assert(CGF.HaveInsertPoint() && "cleanup ended with no insertion point?"); 594 595 // Emit the continuation block if there was an active flag. 596 if (ActiveFlag.isValid()) 597 CGF.EmitBlock(ContBB); 598 } 599 600 static void ForwardPrebranchedFallthrough(llvm::BasicBlock *Exit, 601 llvm::BasicBlock *From, 602 llvm::BasicBlock *To) { 603 // Exit is the exit block of a cleanup, so it always terminates in 604 // an unconditional branch or a switch. 605 llvm::Instruction *Term = Exit->getTerminator(); 606 607 if (llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Term)) { 608 assert(Br->isUnconditional() && Br->getSuccessor(0) == From); 609 Br->setSuccessor(0, To); 610 } else { 611 llvm::SwitchInst *Switch = cast<llvm::SwitchInst>(Term); 612 for (unsigned I = 0, E = Switch->getNumSuccessors(); I != E; ++I) 613 if (Switch->getSuccessor(I) == From) 614 Switch->setSuccessor(I, To); 615 } 616 } 617 618 /// We don't need a normal entry block for the given cleanup. 619 /// Optimistic fixup branches can cause these blocks to come into 620 /// existence anyway; if so, destroy it. 621 /// 622 /// The validity of this transformation is very much specific to the 623 /// exact ways in which we form branches to cleanup entries. 624 static void destroyOptimisticNormalEntry(CodeGenFunction &CGF, 625 EHCleanupScope &scope) { 626 llvm::BasicBlock *entry = scope.getNormalBlock(); 627 if (!entry) return; 628 629 // Replace all the uses with unreachable. 630 llvm::BasicBlock *unreachableBB = CGF.getUnreachableBlock(); 631 for (llvm::BasicBlock::use_iterator 632 i = entry->use_begin(), e = entry->use_end(); i != e; ) { 633 llvm::Use &use = *i; 634 ++i; 635 636 use.set(unreachableBB); 637 638 // The only uses should be fixup switches. 639 llvm::SwitchInst *si = cast<llvm::SwitchInst>(use.getUser()); 640 if (si->getNumCases() == 1 && si->getDefaultDest() == unreachableBB) { 641 // Replace the switch with a branch. 642 llvm::BranchInst::Create(si->case_begin()->getCaseSuccessor(), si); 643 644 // The switch operand is a load from the cleanup-dest alloca. 645 llvm::LoadInst *condition = cast<llvm::LoadInst>(si->getCondition()); 646 647 // Destroy the switch. 648 si->eraseFromParent(); 649 650 // Destroy the load. 651 assert(condition->getOperand(0) == CGF.NormalCleanupDest.getPointer()); 652 assert(condition->use_empty()); 653 condition->eraseFromParent(); 654 } 655 } 656 657 assert(entry->use_empty()); 658 delete entry; 659 } 660 661 /// Pops a cleanup block. If the block includes a normal cleanup, the 662 /// current insertion point is threaded through the cleanup, as are 663 /// any branch fixups on the cleanup. 664 void CodeGenFunction::PopCleanupBlock(bool FallthroughIsBranchThrough) { 665 assert(!EHStack.empty() && "cleanup stack is empty!"); 666 assert(isa<EHCleanupScope>(*EHStack.begin()) && "top not a cleanup!"); 667 EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.begin()); 668 assert(Scope.getFixupDepth() <= EHStack.getNumBranchFixups()); 669 670 // Remember activation information. 671 bool IsActive = Scope.isActive(); 672 Address NormalActiveFlag = 673 Scope.shouldTestFlagInNormalCleanup() ? Scope.getActiveFlag() 674 : Address::invalid(); 675 Address EHActiveFlag = 676 Scope.shouldTestFlagInEHCleanup() ? Scope.getActiveFlag() 677 : Address::invalid(); 678 679 // Check whether we need an EH cleanup. This is only true if we've 680 // generated a lazy EH cleanup block. 681 llvm::BasicBlock *EHEntry = Scope.getCachedEHDispatchBlock(); 682 assert(Scope.hasEHBranches() == (EHEntry != nullptr)); 683 bool RequiresEHCleanup = (EHEntry != nullptr); 684 EHScopeStack::stable_iterator EHParent = Scope.getEnclosingEHScope(); 685 686 // Check the three conditions which might require a normal cleanup: 687 688 // - whether there are branch fix-ups through this cleanup 689 unsigned FixupDepth = Scope.getFixupDepth(); 690 bool HasFixups = EHStack.getNumBranchFixups() != FixupDepth; 691 692 // - whether there are branch-throughs or branch-afters 693 bool HasExistingBranches = Scope.hasBranches(); 694 695 // - whether there's a fallthrough 696 llvm::BasicBlock *FallthroughSource = Builder.GetInsertBlock(); 697 bool HasFallthrough = (FallthroughSource != nullptr && IsActive); 698 699 // Branch-through fall-throughs leave the insertion point set to the 700 // end of the last cleanup, which points to the current scope. The 701 // rest of IR gen doesn't need to worry about this; it only happens 702 // during the execution of PopCleanupBlocks(). 703 bool HasPrebranchedFallthrough = 704 (FallthroughSource && FallthroughSource->getTerminator()); 705 706 // If this is a normal cleanup, then having a prebranched 707 // fallthrough implies that the fallthrough source unconditionally 708 // jumps here. 709 assert(!Scope.isNormalCleanup() || !HasPrebranchedFallthrough || 710 (Scope.getNormalBlock() && 711 FallthroughSource->getTerminator()->getSuccessor(0) 712 == Scope.getNormalBlock())); 713 714 bool RequiresNormalCleanup = false; 715 if (Scope.isNormalCleanup() && 716 (HasFixups || HasExistingBranches || HasFallthrough)) { 717 RequiresNormalCleanup = true; 718 } 719 720 // If we have a prebranched fallthrough into an inactive normal 721 // cleanup, rewrite it so that it leads to the appropriate place. 722 if (Scope.isNormalCleanup() && HasPrebranchedFallthrough && !IsActive) { 723 llvm::BasicBlock *prebranchDest; 724 725 // If the prebranch is semantically branching through the next 726 // cleanup, just forward it to the next block, leaving the 727 // insertion point in the prebranched block. 728 if (FallthroughIsBranchThrough) { 729 EHScope &enclosing = *EHStack.find(Scope.getEnclosingNormalCleanup()); 730 prebranchDest = CreateNormalEntry(*this, cast<EHCleanupScope>(enclosing)); 731 732 // Otherwise, we need to make a new block. If the normal cleanup 733 // isn't being used at all, we could actually reuse the normal 734 // entry block, but this is simpler, and it avoids conflicts with 735 // dead optimistic fixup branches. 736 } else { 737 prebranchDest = createBasicBlock("forwarded-prebranch"); 738 EmitBlock(prebranchDest); 739 } 740 741 llvm::BasicBlock *normalEntry = Scope.getNormalBlock(); 742 assert(normalEntry && !normalEntry->use_empty()); 743 744 ForwardPrebranchedFallthrough(FallthroughSource, 745 normalEntry, prebranchDest); 746 } 747 748 // If we don't need the cleanup at all, we're done. 749 if (!RequiresNormalCleanup && !RequiresEHCleanup) { 750 destroyOptimisticNormalEntry(*this, Scope); 751 EHStack.popCleanup(); // safe because there are no fixups 752 assert(EHStack.getNumBranchFixups() == 0 || 753 EHStack.hasNormalCleanups()); 754 return; 755 } 756 757 // Copy the cleanup emission data out. This uses either a stack 758 // array or malloc'd memory, depending on the size, which is 759 // behavior that SmallVector would provide, if we could use it 760 // here. Unfortunately, if you ask for a SmallVector<char>, the 761 // alignment isn't sufficient. 762 auto *CleanupSource = reinterpret_cast<char *>(Scope.getCleanupBuffer()); 763 alignas(EHScopeStack::ScopeStackAlignment) char 764 CleanupBufferStack[8 * sizeof(void *)]; 765 std::unique_ptr<char[]> CleanupBufferHeap; 766 size_t CleanupSize = Scope.getCleanupSize(); 767 EHScopeStack::Cleanup *Fn; 768 769 if (CleanupSize <= sizeof(CleanupBufferStack)) { 770 memcpy(CleanupBufferStack, CleanupSource, CleanupSize); 771 Fn = reinterpret_cast<EHScopeStack::Cleanup *>(CleanupBufferStack); 772 } else { 773 CleanupBufferHeap.reset(new char[CleanupSize]); 774 memcpy(CleanupBufferHeap.get(), CleanupSource, CleanupSize); 775 Fn = reinterpret_cast<EHScopeStack::Cleanup *>(CleanupBufferHeap.get()); 776 } 777 778 EHScopeStack::Cleanup::Flags cleanupFlags; 779 if (Scope.isNormalCleanup()) 780 cleanupFlags.setIsNormalCleanupKind(); 781 if (Scope.isEHCleanup()) 782 cleanupFlags.setIsEHCleanupKind(); 783 784 // Under -EHa, invoke seh.scope.end() to mark scope end before dtor 785 bool IsEHa = getLangOpts().EHAsynch && !Scope.isLifetimeMarker(); 786 const EHPersonality &Personality = EHPersonality::get(*this); 787 if (!RequiresNormalCleanup) { 788 // Mark CPP scope end for passed-by-value Arg temp 789 // per Windows ABI which is "normally" Cleanup in callee 790 if (IsEHa && getInvokeDest() && Builder.GetInsertBlock()) { 791 if (Personality.isMSVCXXPersonality()) 792 EmitSehCppScopeEnd(); 793 } 794 destroyOptimisticNormalEntry(*this, Scope); 795 EHStack.popCleanup(); 796 } else { 797 // If we have a fallthrough and no other need for the cleanup, 798 // emit it directly. 799 if (HasFallthrough && !HasPrebranchedFallthrough && !HasFixups && 800 !HasExistingBranches) { 801 802 // mark SEH scope end for fall-through flow 803 if (IsEHa && getInvokeDest()) { 804 if (Personality.isMSVCXXPersonality()) 805 EmitSehCppScopeEnd(); 806 else 807 EmitSehTryScopeEnd(); 808 } 809 810 destroyOptimisticNormalEntry(*this, Scope); 811 EHStack.popCleanup(); 812 813 EmitCleanup(*this, Fn, cleanupFlags, NormalActiveFlag); 814 815 // Otherwise, the best approach is to thread everything through 816 // the cleanup block and then try to clean up after ourselves. 817 } else { 818 // Force the entry block to exist. 819 llvm::BasicBlock *NormalEntry = CreateNormalEntry(*this, Scope); 820 821 // I. Set up the fallthrough edge in. 822 823 CGBuilderTy::InsertPoint savedInactiveFallthroughIP; 824 825 // If there's a fallthrough, we need to store the cleanup 826 // destination index. For fall-throughs this is always zero. 827 if (HasFallthrough) { 828 if (!HasPrebranchedFallthrough) 829 Builder.CreateStore(Builder.getInt32(0), getNormalCleanupDestSlot()); 830 831 // Otherwise, save and clear the IP if we don't have fallthrough 832 // because the cleanup is inactive. 833 } else if (FallthroughSource) { 834 assert(!IsActive && "source without fallthrough for active cleanup"); 835 savedInactiveFallthroughIP = Builder.saveAndClearIP(); 836 } 837 838 // II. Emit the entry block. This implicitly branches to it if 839 // we have fallthrough. All the fixups and existing branches 840 // should already be branched to it. 841 EmitBlock(NormalEntry); 842 843 // intercept normal cleanup to mark SEH scope end 844 if (IsEHa && getInvokeDest()) { 845 if (Personality.isMSVCXXPersonality()) 846 EmitSehCppScopeEnd(); 847 else 848 EmitSehTryScopeEnd(); 849 } 850 851 // III. Figure out where we're going and build the cleanup 852 // epilogue. 853 854 bool HasEnclosingCleanups = 855 (Scope.getEnclosingNormalCleanup() != EHStack.stable_end()); 856 857 // Compute the branch-through dest if we need it: 858 // - if there are branch-throughs threaded through the scope 859 // - if fall-through is a branch-through 860 // - if there are fixups that will be optimistically forwarded 861 // to the enclosing cleanup 862 llvm::BasicBlock *BranchThroughDest = nullptr; 863 if (Scope.hasBranchThroughs() || 864 (FallthroughSource && FallthroughIsBranchThrough) || 865 (HasFixups && HasEnclosingCleanups)) { 866 assert(HasEnclosingCleanups); 867 EHScope &S = *EHStack.find(Scope.getEnclosingNormalCleanup()); 868 BranchThroughDest = CreateNormalEntry(*this, cast<EHCleanupScope>(S)); 869 } 870 871 llvm::BasicBlock *FallthroughDest = nullptr; 872 SmallVector<llvm::Instruction*, 2> InstsToAppend; 873 874 // If there's exactly one branch-after and no other threads, 875 // we can route it without a switch. 876 // Skip for SEH, since ExitSwitch is used to generate code to indicate 877 // abnormal termination. (SEH: Except _leave and fall-through at 878 // the end, all other exits in a _try (return/goto/continue/break) 879 // are considered as abnormal terminations, using NormalCleanupDestSlot 880 // to indicate abnormal termination) 881 if (!Scope.hasBranchThroughs() && !HasFixups && !HasFallthrough && 882 !currentFunctionUsesSEHTry() && Scope.getNumBranchAfters() == 1) { 883 assert(!BranchThroughDest || !IsActive); 884 885 // Clean up the possibly dead store to the cleanup dest slot. 886 llvm::Instruction *NormalCleanupDestSlot = 887 cast<llvm::Instruction>(getNormalCleanupDestSlot().getPointer()); 888 if (NormalCleanupDestSlot->hasOneUse()) { 889 NormalCleanupDestSlot->user_back()->eraseFromParent(); 890 NormalCleanupDestSlot->eraseFromParent(); 891 NormalCleanupDest = Address::invalid(); 892 } 893 894 llvm::BasicBlock *BranchAfter = Scope.getBranchAfterBlock(0); 895 InstsToAppend.push_back(llvm::BranchInst::Create(BranchAfter)); 896 897 // Build a switch-out if we need it: 898 // - if there are branch-afters threaded through the scope 899 // - if fall-through is a branch-after 900 // - if there are fixups that have nowhere left to go and 901 // so must be immediately resolved 902 } else if (Scope.getNumBranchAfters() || 903 (HasFallthrough && !FallthroughIsBranchThrough) || 904 (HasFixups && !HasEnclosingCleanups)) { 905 906 llvm::BasicBlock *Default = 907 (BranchThroughDest ? BranchThroughDest : getUnreachableBlock()); 908 909 // TODO: base this on the number of branch-afters and fixups 910 const unsigned SwitchCapacity = 10; 911 912 // pass the abnormal exit flag to Fn (SEH cleanup) 913 cleanupFlags.setHasExitSwitch(); 914 915 llvm::LoadInst *Load = 916 createLoadInstBefore(getNormalCleanupDestSlot(), "cleanup.dest", 917 nullptr); 918 llvm::SwitchInst *Switch = 919 llvm::SwitchInst::Create(Load, Default, SwitchCapacity); 920 921 InstsToAppend.push_back(Load); 922 InstsToAppend.push_back(Switch); 923 924 // Branch-after fallthrough. 925 if (FallthroughSource && !FallthroughIsBranchThrough) { 926 FallthroughDest = createBasicBlock("cleanup.cont"); 927 if (HasFallthrough) 928 Switch->addCase(Builder.getInt32(0), FallthroughDest); 929 } 930 931 for (unsigned I = 0, E = Scope.getNumBranchAfters(); I != E; ++I) { 932 Switch->addCase(Scope.getBranchAfterIndex(I), 933 Scope.getBranchAfterBlock(I)); 934 } 935 936 // If there aren't any enclosing cleanups, we can resolve all 937 // the fixups now. 938 if (HasFixups && !HasEnclosingCleanups) 939 ResolveAllBranchFixups(*this, Switch, NormalEntry); 940 } else { 941 // We should always have a branch-through destination in this case. 942 assert(BranchThroughDest); 943 InstsToAppend.push_back(llvm::BranchInst::Create(BranchThroughDest)); 944 } 945 946 // IV. Pop the cleanup and emit it. 947 EHStack.popCleanup(); 948 assert(EHStack.hasNormalCleanups() == HasEnclosingCleanups); 949 950 EmitCleanup(*this, Fn, cleanupFlags, NormalActiveFlag); 951 952 // Append the prepared cleanup prologue from above. 953 llvm::BasicBlock *NormalExit = Builder.GetInsertBlock(); 954 for (unsigned I = 0, E = InstsToAppend.size(); I != E; ++I) 955 InstsToAppend[I]->insertInto(NormalExit, NormalExit->end()); 956 957 // Optimistically hope that any fixups will continue falling through. 958 for (unsigned I = FixupDepth, E = EHStack.getNumBranchFixups(); 959 I < E; ++I) { 960 BranchFixup &Fixup = EHStack.getBranchFixup(I); 961 if (!Fixup.Destination) continue; 962 if (!Fixup.OptimisticBranchBlock) { 963 createStoreInstBefore(Builder.getInt32(Fixup.DestinationIndex), 964 getNormalCleanupDestSlot(), 965 Fixup.InitialBranch); 966 Fixup.InitialBranch->setSuccessor(0, NormalEntry); 967 } 968 Fixup.OptimisticBranchBlock = NormalExit; 969 } 970 971 // V. Set up the fallthrough edge out. 972 973 // Case 1: a fallthrough source exists but doesn't branch to the 974 // cleanup because the cleanup is inactive. 975 if (!HasFallthrough && FallthroughSource) { 976 // Prebranched fallthrough was forwarded earlier. 977 // Non-prebranched fallthrough doesn't need to be forwarded. 978 // Either way, all we need to do is restore the IP we cleared before. 979 assert(!IsActive); 980 Builder.restoreIP(savedInactiveFallthroughIP); 981 982 // Case 2: a fallthrough source exists and should branch to the 983 // cleanup, but we're not supposed to branch through to the next 984 // cleanup. 985 } else if (HasFallthrough && FallthroughDest) { 986 assert(!FallthroughIsBranchThrough); 987 EmitBlock(FallthroughDest); 988 989 // Case 3: a fallthrough source exists and should branch to the 990 // cleanup and then through to the next. 991 } else if (HasFallthrough) { 992 // Everything is already set up for this. 993 994 // Case 4: no fallthrough source exists. 995 } else { 996 Builder.ClearInsertionPoint(); 997 } 998 999 // VI. Assorted cleaning. 1000 1001 // Check whether we can merge NormalEntry into a single predecessor. 1002 // This might invalidate (non-IR) pointers to NormalEntry. 1003 llvm::BasicBlock *NewNormalEntry = 1004 SimplifyCleanupEntry(*this, NormalEntry); 1005 1006 // If it did invalidate those pointers, and NormalEntry was the same 1007 // as NormalExit, go back and patch up the fixups. 1008 if (NewNormalEntry != NormalEntry && NormalEntry == NormalExit) 1009 for (unsigned I = FixupDepth, E = EHStack.getNumBranchFixups(); 1010 I < E; ++I) 1011 EHStack.getBranchFixup(I).OptimisticBranchBlock = NewNormalEntry; 1012 } 1013 } 1014 1015 assert(EHStack.hasNormalCleanups() || EHStack.getNumBranchFixups() == 0); 1016 1017 // Emit the EH cleanup if required. 1018 if (RequiresEHCleanup) { 1019 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); 1020 1021 EmitBlock(EHEntry); 1022 1023 llvm::BasicBlock *NextAction = getEHDispatchBlock(EHParent); 1024 1025 // Push a terminate scope or cleanupendpad scope around the potentially 1026 // throwing cleanups. For funclet EH personalities, the cleanupendpad models 1027 // program termination when cleanups throw. 1028 bool PushedTerminate = false; 1029 SaveAndRestore RestoreCurrentFuncletPad(CurrentFuncletPad); 1030 llvm::CleanupPadInst *CPI = nullptr; 1031 1032 const EHPersonality &Personality = EHPersonality::get(*this); 1033 if (Personality.usesFuncletPads()) { 1034 llvm::Value *ParentPad = CurrentFuncletPad; 1035 if (!ParentPad) 1036 ParentPad = llvm::ConstantTokenNone::get(CGM.getLLVMContext()); 1037 CurrentFuncletPad = CPI = Builder.CreateCleanupPad(ParentPad); 1038 } 1039 1040 // Non-MSVC personalities need to terminate when an EH cleanup throws. 1041 if (!Personality.isMSVCPersonality()) { 1042 EHStack.pushTerminate(); 1043 PushedTerminate = true; 1044 } else if (IsEHa && getInvokeDest()) { 1045 EmitSehCppScopeEnd(); 1046 } 1047 1048 // We only actually emit the cleanup code if the cleanup is either 1049 // active or was used before it was deactivated. 1050 if (EHActiveFlag.isValid() || IsActive) { 1051 cleanupFlags.setIsForEHCleanup(); 1052 EmitCleanup(*this, Fn, cleanupFlags, EHActiveFlag); 1053 } 1054 1055 if (CPI) 1056 Builder.CreateCleanupRet(CPI, NextAction); 1057 else 1058 Builder.CreateBr(NextAction); 1059 1060 // Leave the terminate scope. 1061 if (PushedTerminate) 1062 EHStack.popTerminate(); 1063 1064 Builder.restoreIP(SavedIP); 1065 1066 SimplifyCleanupEntry(*this, EHEntry); 1067 } 1068 } 1069 1070 /// isObviouslyBranchWithoutCleanups - Return true if a branch to the 1071 /// specified destination obviously has no cleanups to run. 'false' is always 1072 /// a conservatively correct answer for this method. 1073 bool CodeGenFunction::isObviouslyBranchWithoutCleanups(JumpDest Dest) const { 1074 assert(Dest.getScopeDepth().encloses(EHStack.stable_begin()) 1075 && "stale jump destination"); 1076 1077 // Calculate the innermost active normal cleanup. 1078 EHScopeStack::stable_iterator TopCleanup = 1079 EHStack.getInnermostActiveNormalCleanup(); 1080 1081 // If we're not in an active normal cleanup scope, or if the 1082 // destination scope is within the innermost active normal cleanup 1083 // scope, we don't need to worry about fixups. 1084 if (TopCleanup == EHStack.stable_end() || 1085 TopCleanup.encloses(Dest.getScopeDepth())) // works for invalid 1086 return true; 1087 1088 // Otherwise, we might need some cleanups. 1089 return false; 1090 } 1091 1092 1093 /// Terminate the current block by emitting a branch which might leave 1094 /// the current cleanup-protected scope. The target scope may not yet 1095 /// be known, in which case this will require a fixup. 1096 /// 1097 /// As a side-effect, this method clears the insertion point. 1098 void CodeGenFunction::EmitBranchThroughCleanup(JumpDest Dest) { 1099 assert(Dest.getScopeDepth().encloses(EHStack.stable_begin()) 1100 && "stale jump destination"); 1101 1102 if (!HaveInsertPoint()) 1103 return; 1104 1105 // Create the branch. 1106 llvm::BranchInst *BI = Builder.CreateBr(Dest.getBlock()); 1107 1108 // Calculate the innermost active normal cleanup. 1109 EHScopeStack::stable_iterator 1110 TopCleanup = EHStack.getInnermostActiveNormalCleanup(); 1111 1112 // If we're not in an active normal cleanup scope, or if the 1113 // destination scope is within the innermost active normal cleanup 1114 // scope, we don't need to worry about fixups. 1115 if (TopCleanup == EHStack.stable_end() || 1116 TopCleanup.encloses(Dest.getScopeDepth())) { // works for invalid 1117 Builder.ClearInsertionPoint(); 1118 return; 1119 } 1120 1121 // If we can't resolve the destination cleanup scope, just add this 1122 // to the current cleanup scope as a branch fixup. 1123 if (!Dest.getScopeDepth().isValid()) { 1124 BranchFixup &Fixup = EHStack.addBranchFixup(); 1125 Fixup.Destination = Dest.getBlock(); 1126 Fixup.DestinationIndex = Dest.getDestIndex(); 1127 Fixup.InitialBranch = BI; 1128 Fixup.OptimisticBranchBlock = nullptr; 1129 1130 Builder.ClearInsertionPoint(); 1131 return; 1132 } 1133 1134 // Otherwise, thread through all the normal cleanups in scope. 1135 1136 // Store the index at the start. 1137 llvm::ConstantInt *Index = Builder.getInt32(Dest.getDestIndex()); 1138 createStoreInstBefore(Index, getNormalCleanupDestSlot(), BI); 1139 1140 // Adjust BI to point to the first cleanup block. 1141 { 1142 EHCleanupScope &Scope = 1143 cast<EHCleanupScope>(*EHStack.find(TopCleanup)); 1144 BI->setSuccessor(0, CreateNormalEntry(*this, Scope)); 1145 } 1146 1147 // Add this destination to all the scopes involved. 1148 EHScopeStack::stable_iterator I = TopCleanup; 1149 EHScopeStack::stable_iterator E = Dest.getScopeDepth(); 1150 if (E.strictlyEncloses(I)) { 1151 while (true) { 1152 EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.find(I)); 1153 assert(Scope.isNormalCleanup()); 1154 I = Scope.getEnclosingNormalCleanup(); 1155 1156 // If this is the last cleanup we're propagating through, tell it 1157 // that there's a resolved jump moving through it. 1158 if (!E.strictlyEncloses(I)) { 1159 Scope.addBranchAfter(Index, Dest.getBlock()); 1160 break; 1161 } 1162 1163 // Otherwise, tell the scope that there's a jump propagating 1164 // through it. If this isn't new information, all the rest of 1165 // the work has been done before. 1166 if (!Scope.addBranchThrough(Dest.getBlock())) 1167 break; 1168 } 1169 } 1170 1171 Builder.ClearInsertionPoint(); 1172 } 1173 1174 static bool IsUsedAsNormalCleanup(EHScopeStack &EHStack, 1175 EHScopeStack::stable_iterator C) { 1176 // If we needed a normal block for any reason, that counts. 1177 if (cast<EHCleanupScope>(*EHStack.find(C)).getNormalBlock()) 1178 return true; 1179 1180 // Check whether any enclosed cleanups were needed. 1181 for (EHScopeStack::stable_iterator 1182 I = EHStack.getInnermostNormalCleanup(); 1183 I != C; ) { 1184 assert(C.strictlyEncloses(I)); 1185 EHCleanupScope &S = cast<EHCleanupScope>(*EHStack.find(I)); 1186 if (S.getNormalBlock()) return true; 1187 I = S.getEnclosingNormalCleanup(); 1188 } 1189 1190 return false; 1191 } 1192 1193 static bool IsUsedAsEHCleanup(EHScopeStack &EHStack, 1194 EHScopeStack::stable_iterator cleanup) { 1195 // If we needed an EH block for any reason, that counts. 1196 if (EHStack.find(cleanup)->hasEHBranches()) 1197 return true; 1198 1199 // Check whether any enclosed cleanups were needed. 1200 for (EHScopeStack::stable_iterator 1201 i = EHStack.getInnermostEHScope(); i != cleanup; ) { 1202 assert(cleanup.strictlyEncloses(i)); 1203 1204 EHScope &scope = *EHStack.find(i); 1205 if (scope.hasEHBranches()) 1206 return true; 1207 1208 i = scope.getEnclosingEHScope(); 1209 } 1210 1211 return false; 1212 } 1213 1214 enum ForActivation_t { 1215 ForActivation, 1216 ForDeactivation 1217 }; 1218 1219 /// The given cleanup block is changing activation state. Configure a 1220 /// cleanup variable if necessary. 1221 /// 1222 /// It would be good if we had some way of determining if there were 1223 /// extra uses *after* the change-over point. 1224 static void SetupCleanupBlockActivation(CodeGenFunction &CGF, 1225 EHScopeStack::stable_iterator C, 1226 ForActivation_t kind, 1227 llvm::Instruction *dominatingIP) { 1228 EHCleanupScope &Scope = cast<EHCleanupScope>(*CGF.EHStack.find(C)); 1229 1230 // We always need the flag if we're activating the cleanup in a 1231 // conditional context, because we have to assume that the current 1232 // location doesn't necessarily dominate the cleanup's code. 1233 bool isActivatedInConditional = 1234 (kind == ForActivation && CGF.isInConditionalBranch()); 1235 1236 bool needFlag = false; 1237 1238 // Calculate whether the cleanup was used: 1239 1240 // - as a normal cleanup 1241 if (Scope.isNormalCleanup() && 1242 (isActivatedInConditional || IsUsedAsNormalCleanup(CGF.EHStack, C))) { 1243 Scope.setTestFlagInNormalCleanup(); 1244 needFlag = true; 1245 } 1246 1247 // - as an EH cleanup 1248 if (Scope.isEHCleanup() && 1249 (isActivatedInConditional || IsUsedAsEHCleanup(CGF.EHStack, C))) { 1250 Scope.setTestFlagInEHCleanup(); 1251 needFlag = true; 1252 } 1253 1254 // If it hasn't yet been used as either, we're done. 1255 if (!needFlag) return; 1256 1257 Address var = Scope.getActiveFlag(); 1258 if (!var.isValid()) { 1259 var = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), CharUnits::One(), 1260 "cleanup.isactive"); 1261 Scope.setActiveFlag(var); 1262 1263 assert(dominatingIP && "no existing variable and no dominating IP!"); 1264 1265 // Initialize to true or false depending on whether it was 1266 // active up to this point. 1267 llvm::Constant *value = CGF.Builder.getInt1(kind == ForDeactivation); 1268 1269 // If we're in a conditional block, ignore the dominating IP and 1270 // use the outermost conditional branch. 1271 if (CGF.isInConditionalBranch()) { 1272 CGF.setBeforeOutermostConditional(value, var); 1273 } else { 1274 createStoreInstBefore(value, var, dominatingIP); 1275 } 1276 } 1277 1278 CGF.Builder.CreateStore(CGF.Builder.getInt1(kind == ForActivation), var); 1279 } 1280 1281 /// Activate a cleanup that was created in an inactivated state. 1282 void CodeGenFunction::ActivateCleanupBlock(EHScopeStack::stable_iterator C, 1283 llvm::Instruction *dominatingIP) { 1284 assert(C != EHStack.stable_end() && "activating bottom of stack?"); 1285 EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.find(C)); 1286 assert(!Scope.isActive() && "double activation"); 1287 1288 SetupCleanupBlockActivation(*this, C, ForActivation, dominatingIP); 1289 1290 Scope.setActive(true); 1291 } 1292 1293 /// Deactive a cleanup that was created in an active state. 1294 void CodeGenFunction::DeactivateCleanupBlock(EHScopeStack::stable_iterator C, 1295 llvm::Instruction *dominatingIP) { 1296 assert(C != EHStack.stable_end() && "deactivating bottom of stack?"); 1297 EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.find(C)); 1298 assert(Scope.isActive() && "double deactivation"); 1299 1300 // If it's the top of the stack, just pop it, but do so only if it belongs 1301 // to the current RunCleanupsScope. 1302 if (C == EHStack.stable_begin() && 1303 CurrentCleanupScopeDepth.strictlyEncloses(C)) { 1304 // Per comment below, checking EHAsynch is not really necessary 1305 // it's there to assure zero-impact w/o EHAsynch option 1306 if (!Scope.isNormalCleanup() && getLangOpts().EHAsynch) { 1307 PopCleanupBlock(); 1308 } else { 1309 // If it's a normal cleanup, we need to pretend that the 1310 // fallthrough is unreachable. 1311 CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); 1312 PopCleanupBlock(); 1313 Builder.restoreIP(SavedIP); 1314 } 1315 return; 1316 } 1317 1318 // Otherwise, follow the general case. 1319 SetupCleanupBlockActivation(*this, C, ForDeactivation, dominatingIP); 1320 1321 Scope.setActive(false); 1322 } 1323 1324 Address CodeGenFunction::getNormalCleanupDestSlot() { 1325 if (!NormalCleanupDest.isValid()) 1326 NormalCleanupDest = 1327 CreateDefaultAlignTempAlloca(Builder.getInt32Ty(), "cleanup.dest.slot"); 1328 return NormalCleanupDest; 1329 } 1330 1331 /// Emits all the code to cause the given temporary to be cleaned up. 1332 void CodeGenFunction::EmitCXXTemporary(const CXXTemporary *Temporary, 1333 QualType TempType, 1334 Address Ptr) { 1335 pushDestroy(NormalAndEHCleanup, Ptr, TempType, destroyCXXObject, 1336 /*useEHCleanup*/ true); 1337 } 1338 1339 // Need to set "funclet" in OperandBundle properly for noThrow 1340 // intrinsic (see CGCall.cpp) 1341 static void EmitSehScope(CodeGenFunction &CGF, 1342 llvm::FunctionCallee &SehCppScope) { 1343 llvm::BasicBlock *InvokeDest = CGF.getInvokeDest(); 1344 assert(CGF.Builder.GetInsertBlock() && InvokeDest); 1345 llvm::BasicBlock *Cont = CGF.createBasicBlock("invoke.cont"); 1346 SmallVector<llvm::OperandBundleDef, 1> BundleList = 1347 CGF.getBundlesForFunclet(SehCppScope.getCallee()); 1348 if (CGF.CurrentFuncletPad) 1349 BundleList.emplace_back("funclet", CGF.CurrentFuncletPad); 1350 CGF.Builder.CreateInvoke(SehCppScope, Cont, InvokeDest, std::nullopt, 1351 BundleList); 1352 CGF.EmitBlock(Cont); 1353 } 1354 1355 // Invoke a llvm.seh.scope.begin at the beginning of a CPP scope for -EHa 1356 void CodeGenFunction::EmitSehCppScopeBegin() { 1357 assert(getLangOpts().EHAsynch); 1358 llvm::FunctionType *FTy = 1359 llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false); 1360 llvm::FunctionCallee SehCppScope = 1361 CGM.CreateRuntimeFunction(FTy, "llvm.seh.scope.begin"); 1362 EmitSehScope(*this, SehCppScope); 1363 } 1364 1365 // Invoke a llvm.seh.scope.end at the end of a CPP scope for -EHa 1366 // llvm.seh.scope.end is emitted before popCleanup, so it's "invoked" 1367 void CodeGenFunction::EmitSehCppScopeEnd() { 1368 assert(getLangOpts().EHAsynch); 1369 llvm::FunctionType *FTy = 1370 llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false); 1371 llvm::FunctionCallee SehCppScope = 1372 CGM.CreateRuntimeFunction(FTy, "llvm.seh.scope.end"); 1373 EmitSehScope(*this, SehCppScope); 1374 } 1375 1376 // Invoke a llvm.seh.try.begin at the beginning of a SEH scope for -EHa 1377 void CodeGenFunction::EmitSehTryScopeBegin() { 1378 assert(getLangOpts().EHAsynch); 1379 llvm::FunctionType *FTy = 1380 llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false); 1381 llvm::FunctionCallee SehCppScope = 1382 CGM.CreateRuntimeFunction(FTy, "llvm.seh.try.begin"); 1383 EmitSehScope(*this, SehCppScope); 1384 } 1385 1386 // Invoke a llvm.seh.try.end at the end of a SEH scope for -EHa 1387 void CodeGenFunction::EmitSehTryScopeEnd() { 1388 assert(getLangOpts().EHAsynch); 1389 llvm::FunctionType *FTy = 1390 llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false); 1391 llvm::FunctionCallee SehCppScope = 1392 CGM.CreateRuntimeFunction(FTy, "llvm.seh.try.end"); 1393 EmitSehScope(*this, SehCppScope); 1394 } 1395