1 //===-- CGCleanup.h - Classes for cleanups IR generation --------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // These classes support the generation of LLVM IR for cleanups. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CLANG_LIB_CODEGEN_CGCLEANUP_H 15 #define LLVM_CLANG_LIB_CODEGEN_CGCLEANUP_H 16 17 #include "EHScopeStack.h" 18 19 #include "Address.h" 20 #include "llvm/ADT/SmallPtrSet.h" 21 #include "llvm/ADT/SmallVector.h" 22 23 namespace llvm { 24 class BasicBlock; 25 class Value; 26 class ConstantInt; 27 class AllocaInst; 28 } 29 30 namespace clang { 31 class FunctionDecl; 32 namespace CodeGen { 33 class CodeGenModule; 34 class CodeGenFunction; 35 36 /// The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the 37 /// type of a catch handler, so we use this wrapper. 38 struct CatchTypeInfo { 39 llvm::Constant *RTTI; 40 unsigned Flags; 41 }; 42 43 /// A protected scope for zero-cost EH handling. 44 class EHScope { 45 llvm::BasicBlock *CachedLandingPad; 46 llvm::BasicBlock *CachedEHDispatchBlock; 47 48 EHScopeStack::stable_iterator EnclosingEHScope; 49 50 class CommonBitFields { 51 friend class EHScope; 52 unsigned Kind : 3; 53 }; 54 enum { NumCommonBits = 3 }; 55 56 protected: 57 class CatchBitFields { 58 friend class EHCatchScope; 59 unsigned : NumCommonBits; 60 61 unsigned NumHandlers : 32 - NumCommonBits; 62 }; 63 64 class CleanupBitFields { 65 friend class EHCleanupScope; 66 unsigned : NumCommonBits; 67 68 /// Whether this cleanup needs to be run along normal edges. 69 unsigned IsNormalCleanup : 1; 70 71 /// Whether this cleanup needs to be run along exception edges. 72 unsigned IsEHCleanup : 1; 73 74 /// Whether this cleanup is currently active. 75 unsigned IsActive : 1; 76 77 /// Whether this cleanup is a lifetime marker 78 unsigned IsLifetimeMarker : 1; 79 80 /// Whether the normal cleanup should test the activation flag. 81 unsigned TestFlagInNormalCleanup : 1; 82 83 /// Whether the EH cleanup should test the activation flag. 84 unsigned TestFlagInEHCleanup : 1; 85 86 /// The amount of extra storage needed by the Cleanup. 87 /// Always a multiple of the scope-stack alignment. 88 unsigned CleanupSize : 12; 89 90 /// The number of fixups required by enclosing scopes (not including 91 /// this one). If this is the top cleanup scope, all the fixups 92 /// from this index onwards belong to this scope. 93 unsigned FixupDepth : 32 - 18 - NumCommonBits; // currently 12 94 }; 95 96 class FilterBitFields { 97 friend class EHFilterScope; 98 unsigned : NumCommonBits; 99 100 unsigned NumFilters : 32 - NumCommonBits; 101 }; 102 103 union { 104 CommonBitFields CommonBits; 105 CatchBitFields CatchBits; 106 CleanupBitFields CleanupBits; 107 FilterBitFields FilterBits; 108 }; 109 110 public: 111 enum Kind { Cleanup, Catch, Terminate, Filter, PadEnd }; 112 113 EHScope(Kind kind, EHScopeStack::stable_iterator enclosingEHScope) 114 : CachedLandingPad(nullptr), CachedEHDispatchBlock(nullptr), 115 EnclosingEHScope(enclosingEHScope) { 116 CommonBits.Kind = kind; 117 } 118 119 Kind getKind() const { return static_cast<Kind>(CommonBits.Kind); } 120 121 llvm::BasicBlock *getCachedLandingPad() const { 122 return CachedLandingPad; 123 } 124 125 void setCachedLandingPad(llvm::BasicBlock *block) { 126 CachedLandingPad = block; 127 } 128 129 llvm::BasicBlock *getCachedEHDispatchBlock() const { 130 return CachedEHDispatchBlock; 131 } 132 133 void setCachedEHDispatchBlock(llvm::BasicBlock *block) { 134 CachedEHDispatchBlock = block; 135 } 136 137 bool hasEHBranches() const { 138 if (llvm::BasicBlock *block = getCachedEHDispatchBlock()) 139 return !block->use_empty(); 140 return false; 141 } 142 143 EHScopeStack::stable_iterator getEnclosingEHScope() const { 144 return EnclosingEHScope; 145 } 146 }; 147 148 /// A scope which attempts to handle some, possibly all, types of 149 /// exceptions. 150 /// 151 /// Objective C \@finally blocks are represented using a cleanup scope 152 /// after the catch scope. 153 class EHCatchScope : public EHScope { 154 // In effect, we have a flexible array member 155 // Handler Handlers[0]; 156 // But that's only standard in C99, not C++, so we have to do 157 // annoying pointer arithmetic instead. 158 159 public: 160 struct Handler { 161 /// A type info value, or null (C++ null, not an LLVM null pointer) 162 /// for a catch-all. 163 CatchTypeInfo Type; 164 165 /// The catch handler for this type. 166 llvm::BasicBlock *Block; 167 168 bool isCatchAll() const { return Type.RTTI == nullptr; } 169 }; 170 171 private: 172 friend class EHScopeStack; 173 174 Handler *getHandlers() { 175 return reinterpret_cast<Handler*>(this+1); 176 } 177 178 const Handler *getHandlers() const { 179 return reinterpret_cast<const Handler*>(this+1); 180 } 181 182 public: 183 static size_t getSizeForNumHandlers(unsigned N) { 184 return sizeof(EHCatchScope) + N * sizeof(Handler); 185 } 186 187 EHCatchScope(unsigned numHandlers, 188 EHScopeStack::stable_iterator enclosingEHScope) 189 : EHScope(Catch, enclosingEHScope) { 190 CatchBits.NumHandlers = numHandlers; 191 } 192 193 unsigned getNumHandlers() const { 194 return CatchBits.NumHandlers; 195 } 196 197 void setCatchAllHandler(unsigned I, llvm::BasicBlock *Block) { 198 setHandler(I, CatchTypeInfo{nullptr, 0}, Block); 199 } 200 201 void setHandler(unsigned I, llvm::Constant *Type, llvm::BasicBlock *Block) { 202 assert(I < getNumHandlers()); 203 getHandlers()[I].Type = CatchTypeInfo{Type, 0}; 204 getHandlers()[I].Block = Block; 205 } 206 207 void setHandler(unsigned I, CatchTypeInfo Type, llvm::BasicBlock *Block) { 208 assert(I < getNumHandlers()); 209 getHandlers()[I].Type = Type; 210 getHandlers()[I].Block = Block; 211 } 212 213 const Handler &getHandler(unsigned I) const { 214 assert(I < getNumHandlers()); 215 return getHandlers()[I]; 216 } 217 218 // Clear all handler blocks. 219 // FIXME: it's better to always call clearHandlerBlocks in DTOR and have a 220 // 'takeHandler' or some such function which removes ownership from the 221 // EHCatchScope object if the handlers should live longer than EHCatchScope. 222 void clearHandlerBlocks() { 223 for (unsigned I = 0, N = getNumHandlers(); I != N; ++I) 224 delete getHandler(I).Block; 225 } 226 227 typedef const Handler *iterator; 228 iterator begin() const { return getHandlers(); } 229 iterator end() const { return getHandlers() + getNumHandlers(); } 230 231 static bool classof(const EHScope *Scope) { 232 return Scope->getKind() == Catch; 233 } 234 }; 235 236 /// A cleanup scope which generates the cleanup blocks lazily. 237 class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) EHCleanupScope : public EHScope { 238 /// The nearest normal cleanup scope enclosing this one. 239 EHScopeStack::stable_iterator EnclosingNormal; 240 241 /// The nearest EH scope enclosing this one. 242 EHScopeStack::stable_iterator EnclosingEH; 243 244 /// The dual entry/exit block along the normal edge. This is lazily 245 /// created if needed before the cleanup is popped. 246 llvm::BasicBlock *NormalBlock; 247 248 /// An optional i1 variable indicating whether this cleanup has been 249 /// activated yet. 250 llvm::AllocaInst *ActiveFlag; 251 252 /// Extra information required for cleanups that have resolved 253 /// branches through them. This has to be allocated on the side 254 /// because everything on the cleanup stack has be trivially 255 /// movable. 256 struct ExtInfo { 257 /// The destinations of normal branch-afters and branch-throughs. 258 llvm::SmallPtrSet<llvm::BasicBlock*, 4> Branches; 259 260 /// Normal branch-afters. 261 SmallVector<std::pair<llvm::BasicBlock*,llvm::ConstantInt*>, 4> 262 BranchAfters; 263 }; 264 mutable struct ExtInfo *ExtInfo; 265 266 struct ExtInfo &getExtInfo() { 267 if (!ExtInfo) ExtInfo = new struct ExtInfo(); 268 return *ExtInfo; 269 } 270 271 const struct ExtInfo &getExtInfo() const { 272 if (!ExtInfo) ExtInfo = new struct ExtInfo(); 273 return *ExtInfo; 274 } 275 276 public: 277 /// Gets the size required for a lazy cleanup scope with the given 278 /// cleanup-data requirements. 279 static size_t getSizeForCleanupSize(size_t Size) { 280 return sizeof(EHCleanupScope) + Size; 281 } 282 283 size_t getAllocatedSize() const { 284 return sizeof(EHCleanupScope) + CleanupBits.CleanupSize; 285 } 286 287 EHCleanupScope(bool isNormal, bool isEH, bool isActive, 288 unsigned cleanupSize, unsigned fixupDepth, 289 EHScopeStack::stable_iterator enclosingNormal, 290 EHScopeStack::stable_iterator enclosingEH) 291 : EHScope(EHScope::Cleanup, enclosingEH), EnclosingNormal(enclosingNormal), 292 NormalBlock(nullptr), ActiveFlag(nullptr), ExtInfo(nullptr) { 293 CleanupBits.IsNormalCleanup = isNormal; 294 CleanupBits.IsEHCleanup = isEH; 295 CleanupBits.IsActive = isActive; 296 CleanupBits.IsLifetimeMarker = false; 297 CleanupBits.TestFlagInNormalCleanup = false; 298 CleanupBits.TestFlagInEHCleanup = false; 299 CleanupBits.CleanupSize = cleanupSize; 300 CleanupBits.FixupDepth = fixupDepth; 301 302 assert(CleanupBits.CleanupSize == cleanupSize && "cleanup size overflow"); 303 } 304 305 void Destroy() { 306 delete ExtInfo; 307 } 308 // Objects of EHCleanupScope are not destructed. Use Destroy(). 309 ~EHCleanupScope() = delete; 310 311 bool isNormalCleanup() const { return CleanupBits.IsNormalCleanup; } 312 llvm::BasicBlock *getNormalBlock() const { return NormalBlock; } 313 void setNormalBlock(llvm::BasicBlock *BB) { NormalBlock = BB; } 314 315 bool isEHCleanup() const { return CleanupBits.IsEHCleanup; } 316 317 bool isActive() const { return CleanupBits.IsActive; } 318 void setActive(bool A) { CleanupBits.IsActive = A; } 319 320 bool isLifetimeMarker() const { return CleanupBits.IsLifetimeMarker; } 321 void setLifetimeMarker() { CleanupBits.IsLifetimeMarker = true; } 322 323 bool hasActiveFlag() const { return ActiveFlag != nullptr; } 324 Address getActiveFlag() const { 325 return Address(ActiveFlag, CharUnits::One()); 326 } 327 void setActiveFlag(Address Var) { 328 assert(Var.getAlignment().isOne()); 329 ActiveFlag = cast<llvm::AllocaInst>(Var.getPointer()); 330 } 331 332 void setTestFlagInNormalCleanup() { 333 CleanupBits.TestFlagInNormalCleanup = true; 334 } 335 bool shouldTestFlagInNormalCleanup() const { 336 return CleanupBits.TestFlagInNormalCleanup; 337 } 338 339 void setTestFlagInEHCleanup() { 340 CleanupBits.TestFlagInEHCleanup = true; 341 } 342 bool shouldTestFlagInEHCleanup() const { 343 return CleanupBits.TestFlagInEHCleanup; 344 } 345 346 unsigned getFixupDepth() const { return CleanupBits.FixupDepth; } 347 EHScopeStack::stable_iterator getEnclosingNormalCleanup() const { 348 return EnclosingNormal; 349 } 350 351 size_t getCleanupSize() const { return CleanupBits.CleanupSize; } 352 void *getCleanupBuffer() { return this + 1; } 353 354 EHScopeStack::Cleanup *getCleanup() { 355 return reinterpret_cast<EHScopeStack::Cleanup*>(getCleanupBuffer()); 356 } 357 358 /// True if this cleanup scope has any branch-afters or branch-throughs. 359 bool hasBranches() const { return ExtInfo && !ExtInfo->Branches.empty(); } 360 361 /// Add a branch-after to this cleanup scope. A branch-after is a 362 /// branch from a point protected by this (normal) cleanup to a 363 /// point in the normal cleanup scope immediately containing it. 364 /// For example, 365 /// for (;;) { A a; break; } 366 /// contains a branch-after. 367 /// 368 /// Branch-afters each have their own destination out of the 369 /// cleanup, guaranteed distinct from anything else threaded through 370 /// it. Therefore branch-afters usually force a switch after the 371 /// cleanup. 372 void addBranchAfter(llvm::ConstantInt *Index, 373 llvm::BasicBlock *Block) { 374 struct ExtInfo &ExtInfo = getExtInfo(); 375 if (ExtInfo.Branches.insert(Block).second) 376 ExtInfo.BranchAfters.push_back(std::make_pair(Block, Index)); 377 } 378 379 /// Return the number of unique branch-afters on this scope. 380 unsigned getNumBranchAfters() const { 381 return ExtInfo ? ExtInfo->BranchAfters.size() : 0; 382 } 383 384 llvm::BasicBlock *getBranchAfterBlock(unsigned I) const { 385 assert(I < getNumBranchAfters()); 386 return ExtInfo->BranchAfters[I].first; 387 } 388 389 llvm::ConstantInt *getBranchAfterIndex(unsigned I) const { 390 assert(I < getNumBranchAfters()); 391 return ExtInfo->BranchAfters[I].second; 392 } 393 394 /// Add a branch-through to this cleanup scope. A branch-through is 395 /// a branch from a scope protected by this (normal) cleanup to an 396 /// enclosing scope other than the immediately-enclosing normal 397 /// cleanup scope. 398 /// 399 /// In the following example, the branch through B's scope is a 400 /// branch-through, while the branch through A's scope is a 401 /// branch-after: 402 /// for (;;) { A a; B b; break; } 403 /// 404 /// All branch-throughs have a common destination out of the 405 /// cleanup, one possibly shared with the fall-through. Therefore 406 /// branch-throughs usually don't force a switch after the cleanup. 407 /// 408 /// \return true if the branch-through was new to this scope 409 bool addBranchThrough(llvm::BasicBlock *Block) { 410 return getExtInfo().Branches.insert(Block).second; 411 } 412 413 /// Determines if this cleanup scope has any branch throughs. 414 bool hasBranchThroughs() const { 415 if (!ExtInfo) return false; 416 return (ExtInfo->BranchAfters.size() != ExtInfo->Branches.size()); 417 } 418 419 static bool classof(const EHScope *Scope) { 420 return (Scope->getKind() == Cleanup); 421 } 422 }; 423 // NOTE: there's a bunch of different data classes tacked on after an 424 // EHCleanupScope. It is asserted (in EHScopeStack::pushCleanup*) that 425 // they don't require greater alignment than ScopeStackAlignment. So, 426 // EHCleanupScope ought to have alignment equal to that -- not more 427 // (would be misaligned by the stack allocator), and not less (would 428 // break the appended classes). 429 static_assert(llvm::AlignOf<EHCleanupScope>::Alignment == 430 EHScopeStack::ScopeStackAlignment, 431 "EHCleanupScope expected alignment"); 432 433 /// An exceptions scope which filters exceptions thrown through it. 434 /// Only exceptions matching the filter types will be permitted to be 435 /// thrown. 436 /// 437 /// This is used to implement C++ exception specifications. 438 class EHFilterScope : public EHScope { 439 // Essentially ends in a flexible array member: 440 // llvm::Value *FilterTypes[0]; 441 442 llvm::Value **getFilters() { 443 return reinterpret_cast<llvm::Value**>(this+1); 444 } 445 446 llvm::Value * const *getFilters() const { 447 return reinterpret_cast<llvm::Value* const *>(this+1); 448 } 449 450 public: 451 EHFilterScope(unsigned numFilters) 452 : EHScope(Filter, EHScopeStack::stable_end()) { 453 FilterBits.NumFilters = numFilters; 454 } 455 456 static size_t getSizeForNumFilters(unsigned numFilters) { 457 return sizeof(EHFilterScope) + numFilters * sizeof(llvm::Value*); 458 } 459 460 unsigned getNumFilters() const { return FilterBits.NumFilters; } 461 462 void setFilter(unsigned i, llvm::Value *filterValue) { 463 assert(i < getNumFilters()); 464 getFilters()[i] = filterValue; 465 } 466 467 llvm::Value *getFilter(unsigned i) const { 468 assert(i < getNumFilters()); 469 return getFilters()[i]; 470 } 471 472 static bool classof(const EHScope *scope) { 473 return scope->getKind() == Filter; 474 } 475 }; 476 477 /// An exceptions scope which calls std::terminate if any exception 478 /// reaches it. 479 class EHTerminateScope : public EHScope { 480 public: 481 EHTerminateScope(EHScopeStack::stable_iterator enclosingEHScope) 482 : EHScope(Terminate, enclosingEHScope) {} 483 static size_t getSize() { return sizeof(EHTerminateScope); } 484 485 static bool classof(const EHScope *scope) { 486 return scope->getKind() == Terminate; 487 } 488 }; 489 490 class EHPadEndScope : public EHScope { 491 public: 492 EHPadEndScope(EHScopeStack::stable_iterator enclosingEHScope) 493 : EHScope(PadEnd, enclosingEHScope) {} 494 static size_t getSize() { return sizeof(EHPadEndScope); } 495 496 static bool classof(const EHScope *scope) { 497 return scope->getKind() == PadEnd; 498 } 499 }; 500 501 /// A non-stable pointer into the scope stack. 502 class EHScopeStack::iterator { 503 char *Ptr; 504 505 friend class EHScopeStack; 506 explicit iterator(char *Ptr) : Ptr(Ptr) {} 507 508 public: 509 iterator() : Ptr(nullptr) {} 510 511 EHScope *get() const { 512 return reinterpret_cast<EHScope*>(Ptr); 513 } 514 515 EHScope *operator->() const { return get(); } 516 EHScope &operator*() const { return *get(); } 517 518 iterator &operator++() { 519 size_t Size; 520 switch (get()->getKind()) { 521 case EHScope::Catch: 522 Size = EHCatchScope::getSizeForNumHandlers( 523 static_cast<const EHCatchScope *>(get())->getNumHandlers()); 524 break; 525 526 case EHScope::Filter: 527 Size = EHFilterScope::getSizeForNumFilters( 528 static_cast<const EHFilterScope *>(get())->getNumFilters()); 529 break; 530 531 case EHScope::Cleanup: 532 Size = static_cast<const EHCleanupScope *>(get())->getAllocatedSize(); 533 break; 534 535 case EHScope::Terminate: 536 Size = EHTerminateScope::getSize(); 537 break; 538 539 case EHScope::PadEnd: 540 Size = EHPadEndScope::getSize(); 541 break; 542 } 543 Ptr += llvm::RoundUpToAlignment(Size, ScopeStackAlignment); 544 return *this; 545 } 546 547 iterator next() { 548 iterator copy = *this; 549 ++copy; 550 return copy; 551 } 552 553 iterator operator++(int) { 554 iterator copy = *this; 555 operator++(); 556 return copy; 557 } 558 559 bool encloses(iterator other) const { return Ptr >= other.Ptr; } 560 bool strictlyEncloses(iterator other) const { return Ptr > other.Ptr; } 561 562 bool operator==(iterator other) const { return Ptr == other.Ptr; } 563 bool operator!=(iterator other) const { return Ptr != other.Ptr; } 564 }; 565 566 inline EHScopeStack::iterator EHScopeStack::begin() const { 567 return iterator(StartOfData); 568 } 569 570 inline EHScopeStack::iterator EHScopeStack::end() const { 571 return iterator(EndOfBuffer); 572 } 573 574 inline void EHScopeStack::popCatch() { 575 assert(!empty() && "popping exception stack when not empty"); 576 577 EHCatchScope &scope = cast<EHCatchScope>(*begin()); 578 InnermostEHScope = scope.getEnclosingEHScope(); 579 deallocate(EHCatchScope::getSizeForNumHandlers(scope.getNumHandlers())); 580 } 581 582 inline void EHScopeStack::popTerminate() { 583 assert(!empty() && "popping exception stack when not empty"); 584 585 EHTerminateScope &scope = cast<EHTerminateScope>(*begin()); 586 InnermostEHScope = scope.getEnclosingEHScope(); 587 deallocate(EHTerminateScope::getSize()); 588 } 589 590 inline EHScopeStack::iterator EHScopeStack::find(stable_iterator sp) const { 591 assert(sp.isValid() && "finding invalid savepoint"); 592 assert(sp.Size <= stable_begin().Size && "finding savepoint after pop"); 593 return iterator(EndOfBuffer - sp.Size); 594 } 595 596 inline EHScopeStack::stable_iterator 597 EHScopeStack::stabilize(iterator ir) const { 598 assert(StartOfData <= ir.Ptr && ir.Ptr <= EndOfBuffer); 599 return stable_iterator(EndOfBuffer - ir.Ptr); 600 } 601 602 /// The exceptions personality for a function. 603 struct EHPersonality { 604 const char *PersonalityFn; 605 606 // If this is non-null, this personality requires a non-standard 607 // function for rethrowing an exception after a catchall cleanup. 608 // This function must have prototype void(void*). 609 const char *CatchallRethrowFn; 610 611 static const EHPersonality &get(CodeGenModule &CGM, const FunctionDecl *FD); 612 static const EHPersonality &get(CodeGenFunction &CGF); 613 614 static const EHPersonality GNU_C; 615 static const EHPersonality GNU_C_SJLJ; 616 static const EHPersonality GNU_C_SEH; 617 static const EHPersonality GNU_ObjC; 618 static const EHPersonality GNUstep_ObjC; 619 static const EHPersonality GNU_ObjCXX; 620 static const EHPersonality NeXT_ObjC; 621 static const EHPersonality GNU_CPlusPlus; 622 static const EHPersonality GNU_CPlusPlus_SJLJ; 623 static const EHPersonality GNU_CPlusPlus_SEH; 624 static const EHPersonality MSVC_except_handler; 625 static const EHPersonality MSVC_C_specific_handler; 626 static const EHPersonality MSVC_CxxFrameHandler3; 627 628 /// Does this personality use landingpads or the family of pad instructions 629 /// designed to form funclets? 630 bool usesFuncletPads() const { return isMSVCPersonality(); } 631 632 bool isMSVCPersonality() const { 633 return this == &MSVC_except_handler || this == &MSVC_C_specific_handler || 634 this == &MSVC_CxxFrameHandler3; 635 } 636 637 bool isMSVCXXPersonality() const { return this == &MSVC_CxxFrameHandler3; } 638 }; 639 } 640 } 641 642 #endif 643