CodeGenFunction.cpp revision 4c40d98ab7acf5f27fa89b17bd8fc0ef7683df37
15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- CodeGenFunction.cpp - Emit LLVM Code from ASTs for a Function ----===// 25f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 35f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// The LLVM Compiler Infrastructure 45f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 75f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 85f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 95f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// This coordinates the per-function state used while generating code. 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "CodeGenFunction.h" 155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "CodeGenModule.h" 164c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall#include "CGCXXABI.h" 173f2af1002249c8acc9ce17f1fc50324864feb8e1Eli Friedman#include "CGDebugInfo.h" 18f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall#include "CGException.h" 195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Basic/TargetInfo.h" 2031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner#include "clang/AST/APValue.h" 21de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 22c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/Decl.h" 232b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson#include "clang/AST/DeclCXX.h" 246a1e0eb557d47e85185e09bdf8721f53f4bf9c9cMike Stump#include "clang/AST/StmtCXX.h" 257255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner#include "clang/Frontend/CodeGenOptions.h" 264e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump#include "llvm/Target/TargetData.h" 277255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner#include "llvm/Intrinsics.h" 285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace CodeGen; 305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 311eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpCodeGenFunction::CodeGenFunction(CodeGenModule &cgm) 32a4f668f3b7e03629066a01b04e415cb2b4655dafMike Stump : BlockFunction(cgm, *this, Builder), CGM(cgm), 33a4f668f3b7e03629066a01b04e415cb2b4655dafMike Stump Target(CGM.getContext().Target), 34aac8705c046f01a264a4f82832895a5d9e695633Owen Anderson Builder(cgm.getModule().getContext()), 35ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall NormalCleanupDest(0), EHCleanupDest(0), NextCleanupDestIndex(1), 36f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall ExceptionSlot(0), DebugInfo(0), IndirectBranch(0), 37ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall SwitchInsn(0), CaseRangeBlock(0), 38f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall DidCallStackSave(false), UnreachableBlock(0), 392504941793b549323f9d29c62507cf21d865fadeJohn McCall CXXThisDecl(0), CXXThisValue(0), CXXVTTDecl(0), CXXVTTValue(0), 40f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall ConditionalBranchLevel(0), TerminateLandingPad(0), TerminateHandler(0), 4183252dcfe61aaebcb6bc117e71dc12968729513fChris Lattner TrapBB(0) { 4277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner 4377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner // Get some frequently used types. 444e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump LLVMPointerWidth = Target.getPointerWidth(0); 4577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::LLVMContext &LLVMContext = CGM.getLLVMContext(); 4677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner IntPtrTy = llvm::IntegerType::get(LLVMContext, LLVMPointerWidth); 4777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Int32Ty = llvm::Type::getInt32Ty(LLVMContext); 4877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Int64Ty = llvm::Type::getInt64Ty(LLVMContext); 4977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner 50d88ea5687968640ada2bc5a10211cbeb68a671ecMike Stump Exceptions = getContext().getLangOptions().Exceptions; 519c276ae0f24d4cee8f7954069d4b8eae45d0447dMike Stump CatchUndefined = getContext().getLangOptions().CatchUndefined; 524c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().getMangleContext().startNewFunction(); 534111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner} 545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerASTContext &CodeGenFunction::getContext() const { 565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return CGM.getContext(); 575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 608b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbarconst llvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) { 618b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar return CGM.getTypes().ConvertTypeForMem(T); 628b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar} 638b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar 645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst llvm::Type *CodeGenFunction::ConvertType(QualType T) { 655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return CGM.getTypes().ConvertType(T); 665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 684111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattnerbool CodeGenFunction::hasAggregateLLVMType(QualType T) { 69e9d34dc7afe06c9adaacad7a678a0cbbf749ea75Anders Carlsson return T->isRecordType() || T->isArrayType() || T->isAnyComplexType() || 70d608cdb7c044365cf4e8764ade1e11e99c176078John McCall T->isObjCObjectType(); 714111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner} 72391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 731c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbarvoid CodeGenFunction::EmitReturnBlock() { 741c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // For cleanliness, we try to avoid emitting the return block for 751c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // simple cases. 761c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); 771c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 781c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar if (CurBB) { 791c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar assert(!CurBB->getTerminator() && "Unexpected terminated block."); 801c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 8196e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar // We have a valid insert point, reuse it if it is empty or there are no 8296e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar // explicit jumps to the return block. 83ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) { 84ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall ReturnBlock.getBlock()->replaceAllUsesWith(CurBB); 85ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall delete ReturnBlock.getBlock(); 8696e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar } else 87ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitBlock(ReturnBlock.getBlock()); 881c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar return; 891c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 901c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 911c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // Otherwise, if the return block is the target of a single direct 921c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // branch then we can just put the code in that block instead. This 931c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // cleans up functions which started with a unified return block. 94ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (ReturnBlock.getBlock()->hasOneUse()) { 951eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump llvm::BranchInst *BI = 96ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->use_begin()); 97f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (BI && BI->isUnconditional() && 98ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BI->getSuccessor(0) == ReturnBlock.getBlock()) { 991c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // Reset insertion point and delete the branch. 1001c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar Builder.SetInsertPoint(BI->getParent()); 1011c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar BI->eraseFromParent(); 102ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall delete ReturnBlock.getBlock(); 1031c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar return; 1041c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 1051c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 1061c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 107f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // FIXME: We are at an unreachable point, there is no reason to emit the block 108f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // unless it has uses. However, we still need a place to put the debug 109f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // region.end for now. 1101c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 111ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitBlock(ReturnBlock.getBlock()); 112f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall} 113f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 114f1549f66a8216a78112286e3978cea2c29d6334cJohn McCallstatic void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) { 115f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (!BB) return; 116f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (!BB->use_empty()) 117f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall return CGF.CurFn->getBasicBlockList().push_back(BB); 118f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall delete BB; 1191c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar} 1201c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 121af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbarvoid CodeGenFunction::FinishFunction(SourceLocation EndLoc) { 122391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner assert(BreakContinueStack.empty() && 123391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner "mismatched push/pop in break/continue stack!"); 1241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Emit function epilog (to return). 1261c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar EmitReturnBlock(); 127f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar 1287255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner EmitFunctionInstrumentation("__cyg_profile_func_exit"); 1297255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 130f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar // Emit debug descriptor for function end. 131e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson if (CGDebugInfo *DI = getDebugInfo()) { 132f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar DI->setLocation(EndLoc); 1335a6fbcfd8c15a2296f94a0473a68ec09d429827fDevang Patel DI->EmitFunctionEnd(Builder); 134f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar } 135f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar 13635b21b884e5c3447a52a74d7ffaba966b07ac81fChris Lattner EmitFunctionEpilog(*CurFnInfo); 137cce3d4f9812182ed4e551b7cf0fc86576be8d9c5Mike Stump EmitEndEHSpec(CurCodeDecl); 1385ca2084cf9b529563209429857f01fdae9dcdfa5Daniel Dunbar 139f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall assert(EHStack.empty() && 140f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall "did not remove all scopes from cleanup stack!"); 141f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 142d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If someone did an indirect goto, emit the indirect goto block at the end of 143d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // the function. 144d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) { 145d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner EmitBlock(IndirectBranch->getParent()); 146d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner Builder.ClearInsertionPoint(); 147d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 148d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner 149391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // Remove the AllocaInsertPt instruction, which is just a convenience for us. 150481769b5dc102b0256b35581e787909ad5edfab5Chris Lattner llvm::Instruction *Ptr = AllocaInsertPt; 151391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner AllocaInsertPt = 0; 152481769b5dc102b0256b35581e787909ad5edfab5Chris Lattner Ptr->eraseFromParent(); 153d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner 154d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If someone took the address of a label but never did an indirect goto, we 155d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // made a zero entry PHI node, which is illegal, zap it now. 156d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) { 157d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress()); 158d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (PN->getNumIncomingValues() == 0) { 159d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType())); 160d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner PN->eraseFromParent(); 161d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 162d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 163f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 164ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitIfUsed(*this, RethrowBlock.getBlock()); 165f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, TerminateLandingPad); 166f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, TerminateHandler); 167f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, UnreachableBlock); 168744016dde06fcffd50931e94a98c850f8b12cd87John McCall 169744016dde06fcffd50931e94a98c850f8b12cd87John McCall if (CGM.getCodeGenOpts().EmitDeclMetadata) 170744016dde06fcffd50931e94a98c850f8b12cd87John McCall EmitDeclMetadata(); 171c8aa5f1f264fb230c38182adab944232bb160c2bChris Lattner} 172c8aa5f1f264fb230c38182adab944232bb160c2bChris Lattner 1737255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// ShouldInstrumentFunction - Return true if the current function should be 1747255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// instrumented with __cyg_profile_func_* calls 1757255a2d997b15beae82e627052fdb1b2474495c2Chris Lattnerbool CodeGenFunction::ShouldInstrumentFunction() { 1767255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner if (!CGM.getCodeGenOpts().InstrumentFunctions) 1777255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return false; 1787255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner if (CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>()) 1797255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return false; 1807255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return true; 1817255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner} 1827255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 1837255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// EmitFunctionInstrumentation - Emit LLVM code to call the specified 1847255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// instrumentation function with the current function and the call site, if 1857255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// function instrumentation is enabled. 1867255a2d997b15beae82e627052fdb1b2474495c2Chris Lattnervoid CodeGenFunction::EmitFunctionInstrumentation(const char *Fn) { 1877255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner if (!ShouldInstrumentFunction()) 1887255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return; 1897255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 1908dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner const llvm::PointerType *PointerTy; 1917255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner const llvm::FunctionType *FunctionTy; 1927255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner std::vector<const llvm::Type*> ProfileFuncArgs; 1937255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 1948dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner // void __cyg_profile_func_{enter,exit} (void *this_fn, void *call_site); 1958dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner PointerTy = llvm::Type::getInt8PtrTy(VMContext); 1968dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner ProfileFuncArgs.push_back(PointerTy); 1978dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner ProfileFuncArgs.push_back(PointerTy); 1987255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner FunctionTy = llvm::FunctionType::get( 1997255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner llvm::Type::getVoidTy(VMContext), 2007255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner ProfileFuncArgs, false); 2017255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 2027255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner llvm::Constant *F = CGM.CreateRuntimeFunction(FunctionTy, Fn); 2037255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner llvm::CallInst *CallSite = Builder.CreateCall( 2047255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner CGM.getIntrinsic(llvm::Intrinsic::returnaddress, 0, 0), 20577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::ConstantInt::get(Int32Ty, 0), 2067255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner "callsite"); 2077255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 2088dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner Builder.CreateCall2(F, 2098dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner llvm::ConstantExpr::getBitCast(CurFn, PointerTy), 2108dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner CallSite); 2117255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner} 2127255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 2130ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlssonvoid CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy, 2147c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar llvm::Function *Fn, 2152284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar const FunctionArgList &Args, 2162284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar SourceLocation StartLoc) { 2170ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson const Decl *D = GD.getDecl(); 2180ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson 2194cc1a4703363ff940b6273aeef9d96a87edeb04bAnders Carlsson DidCallStackSave = false; 220b5437d238752dc297e42410e98d38d5250fe0463Chris Lattner CurCodeDecl = CurFuncDecl = D; 2217c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FnRetTy = RetTy; 222bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar CurFn = Fn; 2235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(CurFn->isDeclaration() && "Function already has body?"); 224ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner 225a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen // Pass inline keyword to optimizer if it appears explicitly on any 226a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen // declaration. 227a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) 228a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen for (FunctionDecl::redecl_iterator RI = FD->redecls_begin(), 229a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen RE = FD->redecls_end(); RI != RE; ++RI) 230a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen if (RI->isInlineSpecified()) { 231a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen Fn->addFnAttr(llvm::Attribute::InlineHint); 232a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen break; 233a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen } 234a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen 23555e874299f2ad827646a4ca9ea38c402aaeb38c9Daniel Dunbar llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn); 2365ca2084cf9b529563209429857f01fdae9dcdfa5Daniel Dunbar 2375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Create a marker to make it easy to insert allocas into the entryblock 23855352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner // later. Don't create this with the builder, because we don't want it 23955352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner // folded. 24077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Value *Undef = llvm::UndefValue::get(Int32Ty); 24177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "", EntryBB); 242f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner if (Builder.isNamePreserving()) 243f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner AllocaInsertPt->setName("allocapt"); 2441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 245f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall ReturnBlock = getJumpDestInCurrentScope("return"); 2461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 24755352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner Builder.SetInsertPoint(EntryBB); 2481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 249ce056bcaa1c97b89a4b2de2112c62d060863be2bDouglas Gregor QualType FnType = getContext().getFunctionType(RetTy, 0, 0, false, 0, 250ce056bcaa1c97b89a4b2de2112c62d060863be2bDouglas Gregor false, false, 0, 0, 251264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola /*FIXME?*/ 252264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo()); 25391cc815ffd13d4a78ae1b5bd617e19dd555de4f4Mike Stump 254af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta // Emit subprogram debug descriptor. 255e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson if (CGDebugInfo *DI = getDebugInfo()) { 2562284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar DI->setLocation(StartLoc); 2579c6c3a0e3ae09626d2d4b04e4ffa42c3d7cab32bDevang Patel DI->EmitFunctionStart(GD, FnType, CurFn, Builder); 258af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta } 259af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta 2607255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner EmitFunctionInstrumentation("__cyg_profile_func_enter"); 2617255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 26288b5396b0897f28d22ae3debf4a0d97b33b6c362Daniel Dunbar // FIXME: Leaked. 26304a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // CC info is ignored, hopefully? 26404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall CurFnInfo = &CGM.getTypes().getFunctionInfo(FnRetTy, Args, 265264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo()); 266b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman 267b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman if (RetTy->isVoidType()) { 268b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman // Void type; nothing to return. 269b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman ReturnValue = 0; 270b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect && 271b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman hasAggregateLLVMType(CurFnInfo->getReturnType())) { 272b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman // Indirect aggregate return; emit returned value directly into sret slot. 273647a1ec397fa13af176d07d9f5d071560a94c7a9Daniel Dunbar // This reduces code size, and affects correctness in C++. 274b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman ReturnValue = CurFn->arg_begin(); 275b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } else { 276647a1ec397fa13af176d07d9f5d071560a94c7a9Daniel Dunbar ReturnValue = CreateIRTemp(RetTy, "retval"); 277b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } 278b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman 279cce3d4f9812182ed4e551b7cf0fc86576be8d9c5Mike Stump EmitStartEHSpec(CurCodeDecl); 28088b5396b0897f28d22ae3debf4a0d97b33b6c362Daniel Dunbar EmitFunctionProlog(*CurFnInfo, CurFn, Args); 2811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2824c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) 2834c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().EmitInstanceFunctionProlog(*this); 2842504941793b549323f9d29c62507cf21d865fadeJohn McCall 285751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson // If any of the arguments have a variably modified type, make sure to 286751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson // emit the type size. 287751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); 288751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson i != e; ++i) { 289751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson QualType Ty = i->second; 290751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson 291751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson if (Ty->isVariablyModifiedType()) 292751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson EmitVLASize(Ty); 293751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson } 2947c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar} 295eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman 2969fc6a7774643a810c8501dae2323e863fefb623eJohn McCallvoid CodeGenFunction::EmitFunctionBody(FunctionArgList &Args) { 2979fc6a7774643a810c8501dae2323e863fefb623eJohn McCall const FunctionDecl *FD = cast<FunctionDecl>(CurGD.getDecl()); 29806a9f3680d22529a2fcf20c52d71cf221d99d910Douglas Gregor assert(FD->getBody()); 29906a9f3680d22529a2fcf20c52d71cf221d99d910Douglas Gregor EmitStmt(FD->getBody()); 300a355e07454463b19829ac92ffd115a097faff0e0John McCall} 301a355e07454463b19829ac92ffd115a097faff0e0John McCall 30239dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// Tries to mark the given function nounwind based on the 30339dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// non-existence of any throwing calls within it. We believe this is 30439dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// lightweight enough to do at -O0. 30539dad53772c42eb36ebec1c81c56ba99d038fb94John McCallstatic void TryMarkNoThrow(llvm::Function *F) { 306b3a29f132794f67108bccc9c7cc3795365e8a965John McCall // LLVM treats 'nounwind' on a function as part of the type, so we 307b3a29f132794f67108bccc9c7cc3795365e8a965John McCall // can't do this on functions that can be overwritten. 308b3a29f132794f67108bccc9c7cc3795365e8a965John McCall if (F->mayBeOverridden()) return; 309b3a29f132794f67108bccc9c7cc3795365e8a965John McCall 31039dad53772c42eb36ebec1c81c56ba99d038fb94John McCall for (llvm::Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI) 31139dad53772c42eb36ebec1c81c56ba99d038fb94John McCall for (llvm::BasicBlock::iterator 31239dad53772c42eb36ebec1c81c56ba99d038fb94John McCall BI = FI->begin(), BE = FI->end(); BI != BE; ++BI) 31339dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(&*BI)) 31439dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (!Call->doesNotThrow()) 31539dad53772c42eb36ebec1c81c56ba99d038fb94John McCall return; 31639dad53772c42eb36ebec1c81c56ba99d038fb94John McCall F->setDoesNotThrow(true); 31739dad53772c42eb36ebec1c81c56ba99d038fb94John McCall} 31839dad53772c42eb36ebec1c81c56ba99d038fb94John McCall 319c997d4278d329e18891aac9698fb991b2d4622ebAnders Carlssonvoid CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn) { 3200ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 3210ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson 322e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson // Check if we should generate debug info for this function. 3231feade8e520be483293dbf55eb57a51720899589Mike Stump if (CGM.getDebugInfo() && !FD->hasAttr<NoDebugAttr>()) 324e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson DebugInfo = CGM.getDebugInfo(); 3251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3267c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FunctionArgList Args; 3274c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall QualType ResTy = FD->getResultType(); 3281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3296a1e0eb557d47e85185e09bdf8721f53f4bf9c9cMike Stump CurGD = GD; 3304c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall if (isa<CXXMethodDecl>(FD) && cast<CXXMethodDecl>(FD)->isInstance()) 3314c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResTy, Args); 3321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 333eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman if (FD->getNumParams()) { 334183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const FunctionProtoType* FProto = FD->getType()->getAs<FunctionProtoType>(); 335eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman assert(FProto && "Function def must have prototype!"); 3367c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar 3377c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) 3381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Args.push_back(std::make_pair(FD->getParamDecl(i), 3397c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FProto->getArgType(i))); 3405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 341af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar 342a355e07454463b19829ac92ffd115a097faff0e0John McCall SourceRange BodyRange; 343a355e07454463b19829ac92ffd115a097faff0e0John McCall if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange(); 3444365bba95be15342575b4f030c6583a770a5da3dAnders Carlsson 345a355e07454463b19829ac92ffd115a097faff0e0John McCall // Emit the standard function prologue. 3464c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall StartFunction(GD, ResTy, Fn, Args, BodyRange.getBegin()); 3471851a12605bc6f1ea70d11974a315340ebaab6ebAnders Carlsson 348a355e07454463b19829ac92ffd115a097faff0e0John McCall // Generate the body of the function. 3499fc6a7774643a810c8501dae2323e863fefb623eJohn McCall if (isa<CXXDestructorDecl>(FD)) 3509fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitDestructorBody(Args); 3519fc6a7774643a810c8501dae2323e863fefb623eJohn McCall else if (isa<CXXConstructorDecl>(FD)) 3529fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitConstructorBody(Args); 3539fc6a7774643a810c8501dae2323e863fefb623eJohn McCall else 3549fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitFunctionBody(Args); 355c33e4ba20304e222692e77f2c6ad26a5d8d32f83Anders Carlsson 356a355e07454463b19829ac92ffd115a097faff0e0John McCall // Emit the standard function epilogue. 357a355e07454463b19829ac92ffd115a097faff0e0John McCall FinishFunction(BodyRange.getEnd()); 35839dad53772c42eb36ebec1c81c56ba99d038fb94John McCall 35939dad53772c42eb36ebec1c81c56ba99d038fb94John McCall // If we haven't marked the function nothrow through other means, do 36039dad53772c42eb36ebec1c81c56ba99d038fb94John McCall // a quick pass now to see if we can. 36139dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (!CurFn->doesNotThrow()) 36239dad53772c42eb36ebec1c81c56ba99d038fb94John McCall TryMarkNoThrow(CurFn); 3635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3650946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// ContainsLabel - Return true if the statement contains a label in it. If 3660946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// this statement is not executed normally, it not containing a label means 3670946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// that we can just remove the code. 3680946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattnerbool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) { 3690946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // Null statement, not a label! 3700946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (S == 0) return false; 3711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3720946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a label, we have to emit the code, consider something like: 3730946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // if (0) { ... foo: bar(); } goto foo; 3740946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<LabelStmt>(S)) 3750946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 3761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3770946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a case/default statement, and we haven't seen a switch, we have 3780946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // to emit the code. 3790946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<SwitchCase>(S) && !IgnoreCaseStmts) 3800946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 3811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3820946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a switch statement, we want to ignore cases below it. 3830946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<SwitchStmt>(S)) 3840946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner IgnoreCaseStmts = true; 3851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3860946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // Scan subexpressions for verboten labels. 3870946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner for (Stmt::const_child_iterator I = S->child_begin(), E = S->child_end(); 3880946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner I != E; ++I) 3890946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (ContainsLabel(*I, IgnoreCaseStmts)) 3900946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 3911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3920946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return false; 3930946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner} 3940946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner 39531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 39631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// ConstantFoldsToSimpleInteger - If the sepcified expression does not fold to 39731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// a constant, or if it does but contains a label, return 0. If it constant 39831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// folds to 'true' and does not contain a label, return 1, if it constant folds 39931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// to 'false' and does not contain a label, return -1. 40031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattnerint CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond) { 40136bc14c3a1cf63ee306df5687ac8e85f924f8639Daniel Dunbar // FIXME: Rename and handle conversion of other evaluatable things 40236bc14c3a1cf63ee306df5687ac8e85f924f8639Daniel Dunbar // to bool. 40364712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson Expr::EvalResult Result; 4041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!Cond->Evaluate(Result, getContext()) || !Result.Val.isInt() || 40564712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson Result.HasSideEffects) 406ef5a66d8171eb95e948107f8ee7707b360aaff25Anders Carlsson return 0; // Not foldable, not integer or not fully evaluatable. 4071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 40831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (CodeGenFunction::ContainsLabel(Cond)) 40931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return 0; // Contains a label. 4101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 41164712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson return Result.Val.getInt().getBoolValue() ? 1 : -1; 41231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner} 41331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 41431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 41531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if 41631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// statement) to the specified blocks. Based on the condition, this might try 41731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// to simplify the codegen of the conditional based on the branch. 41831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// 41931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattnervoid CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond, 42031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::BasicBlock *TrueBlock, 42131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::BasicBlock *FalseBlock) { 42231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (const ParenExpr *PE = dyn_cast<ParenExpr>(Cond)) 42331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(PE->getSubExpr(), TrueBlock, FalseBlock); 4241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 42531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) { 42631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Handle X && Y in a condition. 4272de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CondBOp->getOpcode() == BO_LAnd) { 42831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "1 && X", simplify the code. "0 && X" would have constant 42931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // folded if the case was simple enough. 43031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == 1) { 43131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(1 && X) -> br(X). 43231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 43331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 43531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "X && 1", simplify the code to use an uncond branch. 43631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // "X && 0" would have been constant folded to 0. 43731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == 1) { 43831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(X && 1) -> br(X). 43931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 44031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 44231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the LHS as a conditional. If the LHS conditional is false, we 44331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // want to jump to the FalseBlock. 4449615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true"); 44531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock); 44631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBlock(LHSTrue); 4471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 44808e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson // Any temporaries created here are conditional. 44972119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson BeginConditionalBranch(); 45031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 45172119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson EndConditionalBranch(); 45208e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson 45331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return; 4542de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall } else if (CondBOp->getOpcode() == BO_LOr) { 45531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "0 || X", simplify the code. "1 || X" would have constant 45631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // folded if the case was simple enough. 45731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == -1) { 45831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(0 || X) -> br(X). 45931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 46031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 46231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "X || 0", simplify the code to use an uncond branch. 46331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // "X || 1" would have been constant folded to 1. 46431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == -1) { 46531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(X || 0) -> br(X). 46631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 46731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 46931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the LHS as a conditional. If the LHS conditional is true, we 47031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // want to jump to the TrueBlock. 4719615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false"); 47231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse); 47331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBlock(LHSFalse); 4741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 47508e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson // Any temporaries created here are conditional. 47672119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson BeginConditionalBranch(); 47731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 47872119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson EndConditionalBranch(); 47908e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson 48031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return; 48131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 482552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner } 4831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 484552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) { 485552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner // br(!x, t, f) -> br(x, f, t) 4862de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CondUOp->getOpcode() == UO_LNot) 487552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock); 48831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 49009b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) { 49109b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // Handle ?: operator. 49209b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar 49309b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // Just ignore GNU ?: extension. 49409b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar if (CondOp->getLHS()) { 49509b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f)) 49609b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true"); 49709b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false"); 49809b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock); 49909b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBlock(LHSBlock); 50009b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock); 50109b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBlock(RHSBlock); 50209b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock); 50309b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar return; 50409b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar } 50509b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar } 50609b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar 50731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the code with the fully general case. 50831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::Value *CondV = EvaluateExprAsBool(Cond); 50931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner Builder.CreateCondBr(CondV, TrueBlock, FalseBlock); 51031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner} 51131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 512488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar/// ErrorUnsupported - Print out an error that codegen doesn't support the 513dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner/// specified stmt yet. 51490df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbarvoid CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type, 51590df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar bool OmitOnError) { 51690df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar CGM.ErrorUnsupported(S, Type, OmitOnError); 517dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner} 518dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner 5191884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlssonvoid 5201884eb0b5c55edda4893ddec45e7dbad79758782Anders CarlssonCodeGenFunction::EmitNullInitialization(llvm::Value *DestPtr, QualType Ty) { 5210d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson // Ignore empty classes in C++. 5220d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (getContext().getLangOptions().CPlusPlus) { 5230d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (const RecordType *RT = Ty->getAs<RecordType>()) { 5240d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty()) 5250d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson return; 5260d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson } 5270d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson } 5289021718882441dd391a1960084580d3cd19c423aJohn McCall 5299021718882441dd391a1960084580d3cd19c423aJohn McCall // Cast the dest ptr to the appropriate i8 pointer type. 5309021718882441dd391a1960084580d3cd19c423aJohn McCall unsigned DestAS = 5319021718882441dd391a1960084580d3cd19c423aJohn McCall cast<llvm::PointerType>(DestPtr->getType())->getAddressSpace(); 5329021718882441dd391a1960084580d3cd19c423aJohn McCall const llvm::Type *BP = 5339021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::Type::getInt8PtrTy(VMContext, DestAS); 5343d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson if (DestPtr->getType() != BP) 5353d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp"); 5363d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 5373d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson // Get size and alignment info for this aggregate. 5383d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson std::pair<uint64_t, unsigned> TypeInfo = getContext().getTypeInfo(Ty); 5399021718882441dd391a1960084580d3cd19c423aJohn McCall uint64_t Size = TypeInfo.first; 5409021718882441dd391a1960084580d3cd19c423aJohn McCall unsigned Align = TypeInfo.second; 5413d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 54288207c9ca218486b93ae7df14e9764cd0c2c3383Chris Lattner // Don't bother emitting a zero-byte memset. 5439021718882441dd391a1960084580d3cd19c423aJohn McCall if (Size == 0) 5449021718882441dd391a1960084580d3cd19c423aJohn McCall return; 5459021718882441dd391a1960084580d3cd19c423aJohn McCall 5469021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::ConstantInt *SizeVal = llvm::ConstantInt::get(IntPtrTy, Size / 8); 5479021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::ConstantInt *AlignVal = Builder.getInt32(Align / 8); 5489021718882441dd391a1960084580d3cd19c423aJohn McCall 5499021718882441dd391a1960084580d3cd19c423aJohn McCall // If the type contains a pointer to data member we can't memset it to zero. 5509021718882441dd391a1960084580d3cd19c423aJohn McCall // Instead, create a null constant and copy it to the destination. 551f16aa103d3afd42fbca2ab346f191bf745cec092John McCall if (!CGM.getTypes().isZeroInitializable(Ty)) { 5529021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty); 5539021718882441dd391a1960084580d3cd19c423aJohn McCall 5549021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::GlobalVariable *NullVariable = 5559021718882441dd391a1960084580d3cd19c423aJohn McCall new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(), 5569021718882441dd391a1960084580d3cd19c423aJohn McCall /*isConstant=*/true, 5579021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::GlobalVariable::PrivateLinkage, 5589021718882441dd391a1960084580d3cd19c423aJohn McCall NullConstant, llvm::Twine()); 5599021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::Value *SrcPtr = 5609021718882441dd391a1960084580d3cd19c423aJohn McCall Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()); 5619021718882441dd391a1960084580d3cd19c423aJohn McCall 5629021718882441dd391a1960084580d3cd19c423aJohn McCall // FIXME: variable-size types? 5639021718882441dd391a1960084580d3cd19c423aJohn McCall 5649021718882441dd391a1960084580d3cd19c423aJohn McCall // Get and call the appropriate llvm.memcpy overload. 5659021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::Constant *Memcpy = 5669021718882441dd391a1960084580d3cd19c423aJohn McCall CGM.getMemCpyFn(DestPtr->getType(), SrcPtr->getType(), IntPtrTy); 5679021718882441dd391a1960084580d3cd19c423aJohn McCall Builder.CreateCall5(Memcpy, DestPtr, SrcPtr, SizeVal, AlignVal, 5689021718882441dd391a1960084580d3cd19c423aJohn McCall /*volatile*/ Builder.getFalse()); 56988207c9ca218486b93ae7df14e9764cd0c2c3383Chris Lattner return; 5709021718882441dd391a1960084580d3cd19c423aJohn McCall } 5719021718882441dd391a1960084580d3cd19c423aJohn McCall 5729021718882441dd391a1960084580d3cd19c423aJohn McCall // Otherwise, just memset the whole thing to zero. This is legal 5739021718882441dd391a1960084580d3cd19c423aJohn McCall // because in LLVM, all default initializers (other than the ones we just 5749021718882441dd391a1960084580d3cd19c423aJohn McCall // handled above) are guaranteed to have a bit pattern of all zeros. 5751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5763d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson // FIXME: Handle variable sized types. 57777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Builder.CreateCall5(CGM.getMemSetFn(BP, IntPtrTy), DestPtr, 5789021718882441dd391a1960084580d3cd19c423aJohn McCall Builder.getInt8(0), 5799021718882441dd391a1960084580d3cd19c423aJohn McCall SizeVal, AlignVal, /*volatile*/ Builder.getFalse()); 5803d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson} 5813d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 582d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattnerllvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelStmt *L) { 583d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Make sure that there is a block for the indirect goto. 584d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch == 0) 585d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner GetIndirectGotoBlock(); 5863d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 587ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock(); 5883d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 589d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Make sure the indirect branch includes all of the address-taken blocks. 590d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner IndirectBranch->addDestination(BB); 591d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return llvm::BlockAddress::get(CurFn, BB); 5923d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner} 5931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5943d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattnerllvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() { 595d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If we already made the indirect branch for indirect goto, return its block. 596d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) return IndirectBranch->getParent(); 5973d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 598d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner CGBuilderTy TmpBuilder(createBasicBlock("indirectgoto")); 5993d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 600d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(VMContext); 60185e74acfcfb0c835a2e6c1adab314e997917039aChris Lattner 6023d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner // Create the PHI node that indirect gotos will add entries to. 603d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, "indirect.goto.dest"); 6043d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 605d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Create the indirect branch instruction. 606d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal); 607d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return IndirectBranch->getParent(); 6080ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar} 609ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 610d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbarllvm::Value *CodeGenFunction::GetVLASize(const VariableArrayType *VAT) { 611bbed6b964414145b29e7b60b3e538093734ea3f8Eli Friedman llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()]; 6121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 613f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson assert(SizeEntry && "Did not emit size for type"); 614f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson return SizeEntry; 615f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson} 616dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson 617d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbarllvm::Value *CodeGenFunction::EmitVLASize(QualType Ty) { 61860d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson assert(Ty->isVariablyModifiedType() && 61960d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson "Must pass variably modified type to EmitVLASizes!"); 6201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 621d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbar EnsureInsertPoint(); 6221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 62360d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson if (const VariableArrayType *VAT = getContext().getAsVariableArrayType(Ty)) { 624bbed6b964414145b29e7b60b3e538093734ea3f8Eli Friedman llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()]; 6251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 626fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson if (!SizeEntry) { 62796f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson const llvm::Type *SizeTy = ConvertType(getContext().getSizeType()); 6281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 629ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner // Get the element size; 630ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner QualType ElemTy = VAT->getElementType(); 631ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner llvm::Value *ElemSize; 632fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson if (ElemTy->isVariableArrayType()) 633fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson ElemSize = EmitVLASize(ElemTy); 634ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner else 6354a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson ElemSize = llvm::ConstantInt::get(SizeTy, 636199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck getContext().getTypeSizeInChars(ElemTy).getQuantity()); 6371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 638fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson llvm::Value *NumElements = EmitScalarExpr(VAT->getSizeExpr()); 63996f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson NumElements = Builder.CreateIntCast(NumElements, SizeTy, false, "tmp"); 6401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 641fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson SizeEntry = Builder.CreateMul(ElemSize, NumElements); 642fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson } 6431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 64460d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson return SizeEntry; 645dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson } 6461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 647ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner if (const ArrayType *AT = dyn_cast<ArrayType>(Ty)) { 648ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner EmitVLASize(AT->getElementType()); 649ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner return 0; 6501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 6511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 652ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner const PointerType *PT = Ty->getAs<PointerType>(); 653ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner assert(PT && "unknown VM type!"); 654ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner EmitVLASize(PT->getPointeeType()); 65560d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson return 0; 656dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson} 6574fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman 6584fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedmanllvm::Value* CodeGenFunction::EmitVAListRef(const Expr* E) { 659fbe02ffb573ac2aa51351278af1c7970573b6ed5Chris Lattner if (CGM.getContext().getBuiltinVaListType()->isArrayType()) 6604fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman return EmitScalarExpr(E); 6614fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman return EmitLValue(E).getAddress(); 6624fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman} 6636ccc47698d0311ddabf32fa0f6db8e4f09ac96f8Anders Carlsson 664f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall/// Pops cleanup blocks until the given savepoint is reached. 665f1549f66a8216a78112286e3978cea2c29d6334cJohn McCallvoid CodeGenFunction::PopCleanupBlocks(EHScopeStack::stable_iterator Old) { 666f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall assert(Old.isValid()); 667f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 668ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall while (EHStack.stable_begin() != Old) { 669ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.begin()); 670ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 671ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // As long as Old strictly encloses the scope's enclosing normal 672ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // cleanup, we're going to emit another normal cleanup which 673ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // fallthrough can propagate through. 674ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall bool FallThroughIsBranchThrough = 675ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Old.strictlyEncloses(Scope.getEnclosingNormalCleanup()); 676ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 677ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall PopCleanupBlock(FallThroughIsBranchThrough); 678ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 6796ccc47698d0311ddabf32fa0f6db8e4f09ac96f8Anders Carlsson} 680c71c845fe77ee1f891d60232ec320912d88557eeAnders Carlsson 681ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallstatic llvm::BasicBlock *CreateNormalEntry(CodeGenFunction &CGF, 682ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHCleanupScope &Scope) { 683ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Scope.isNormalCleanup()); 684ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *Entry = Scope.getNormalBlock(); 685ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Entry) { 686ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Entry = CGF.createBasicBlock("cleanup"); 687ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.setNormalBlock(Entry); 688f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall } 689ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall return Entry; 690ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall} 691f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 692ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallstatic llvm::BasicBlock *CreateEHEntry(CodeGenFunction &CGF, 693ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHCleanupScope &Scope) { 694ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Scope.isEHCleanup()); 695ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *Entry = Scope.getEHBlock(); 696ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Entry) { 697ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Entry = CGF.createBasicBlock("eh.cleanup"); 698ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.setEHBlock(Entry); 699ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 700ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall return Entry; 701ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall} 702f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 703ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// Transitions the terminator of the given exit-block of a cleanup to 704ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// be a cleanup switch. 705ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallstatic llvm::SwitchInst *TransitionToCleanupSwitch(CodeGenFunction &CGF, 706ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *Block) { 707ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If it's a branch, turn it into a switch whose default 708ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // destination is its original target. 709ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::TerminatorInst *Term = Block->getTerminator(); 710ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Term && "can't transition block without terminator"); 711ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 712ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Term)) { 713ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Br->isUnconditional()); 714ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::LoadInst *Load = 715ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall new llvm::LoadInst(CGF.getNormalCleanupDestSlot(), "cleanup.dest", Term); 716ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SwitchInst *Switch = 717ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SwitchInst::Create(Load, Br->getSuccessor(0), 4, Block); 718ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Br->eraseFromParent(); 719ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall return Switch; 720ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } else { 721ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall return cast<llvm::SwitchInst>(Term); 722ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 723c71c845fe77ee1f891d60232ec320912d88557eeAnders Carlsson} 724c71c845fe77ee1f891d60232ec320912d88557eeAnders Carlsson 725f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall/// Attempts to reduce a cleanup's entry block to a fallthrough. This 726f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall/// is basically llvm::MergeBlockIntoPredecessor, except 727ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// simplified/optimized for the tighter constraints on cleanup blocks. 728ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// 729ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// Returns the new block, whatever it is. 730ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallstatic llvm::BasicBlock *SimplifyCleanupEntry(CodeGenFunction &CGF, 731ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *Entry) { 732f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall llvm::BasicBlock *Pred = Entry->getSinglePredecessor(); 733ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Pred) return Entry; 7341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 735f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Pred->getTerminator()); 736ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Br || Br->isConditional()) return Entry; 737f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall assert(Br->getSuccessor(0) == Entry); 7381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 739f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // If we were previously inserting at the end of the cleanup entry 740f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // block, we'll need to continue inserting at the end of the 741f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // predecessor. 742f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall bool WasInsertBlock = CGF.Builder.GetInsertBlock() == Entry; 743f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall assert(!WasInsertBlock || CGF.Builder.GetInsertPoint() == Entry->end()); 7441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 745f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // Kill the branch. 746f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall Br->eraseFromParent(); 7471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 748f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // Merge the blocks. 749f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall Pred->getInstList().splice(Pred->end(), Entry->getInstList()); 75099533834ba8f3658559f334e68a518ebb6388ceaMike Stump 751f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // Kill the entry block. 752f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall Entry->eraseFromParent(); 753d88ea5687968640ada2bc5a10211cbeb68a671ecMike Stump 754f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (WasInsertBlock) 755f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall CGF.Builder.SetInsertPoint(Pred); 756f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 757ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall return Pred; 758f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall} 759f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 7601f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCallstatic void EmitCleanup(CodeGenFunction &CGF, 7611f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall EHScopeStack::Cleanup *Fn, 7621f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall bool ForEH) { 763da65ea86482bc116906edfb9ba1d7124f76cc867John McCall if (ForEH) CGF.EHStack.pushTerminate(); 764da65ea86482bc116906edfb9ba1d7124f76cc867John McCall Fn->Emit(CGF, ForEH); 765da65ea86482bc116906edfb9ba1d7124f76cc867John McCall if (ForEH) CGF.EHStack.popTerminate(); 766da65ea86482bc116906edfb9ba1d7124f76cc867John McCall assert(CGF.HaveInsertPoint() && "cleanup ended with no insertion point?"); 767da65ea86482bc116906edfb9ba1d7124f76cc867John McCall} 768da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 7691f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall/// Pops a cleanup block. If the block includes a normal cleanup, the 7701f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall/// current insertion point is threaded through the cleanup, as are 7711f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall/// any branch fixups on the cleanup. 772ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallvoid CodeGenFunction::PopCleanupBlock(bool FallthroughIsBranchThrough) { 7731f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall assert(!EHStack.empty() && "cleanup stack is empty!"); 7741f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall assert(isa<EHCleanupScope>(*EHStack.begin()) && "top not a cleanup!"); 7751f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.begin()); 7761f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall assert(Scope.getFixupDepth() <= EHStack.getNumBranchFixups()); 777838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall assert(Scope.isActive() && "cleanup was still inactive when popped!"); 778da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 779da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // Check whether we need an EH cleanup. This is only true if we've 780da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // generated a lazy EH cleanup block. 781ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall bool RequiresEHCleanup = Scope.hasEHBranches(); 782da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 783da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // Check the three conditions which might require a normal cleanup: 784da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 785da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // - whether there are branch fix-ups through this cleanup 786da65ea86482bc116906edfb9ba1d7124f76cc867John McCall unsigned FixupDepth = Scope.getFixupDepth(); 7871f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall bool HasFixups = EHStack.getNumBranchFixups() != FixupDepth; 788da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 789ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // - whether there are branch-throughs or branch-afters 790ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall bool HasExistingBranches = Scope.hasBranches(); 791da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 792da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // - whether there's a fallthrough 7931f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall llvm::BasicBlock *FallthroughSource = Builder.GetInsertBlock(); 794da65ea86482bc116906edfb9ba1d7124f76cc867John McCall bool HasFallthrough = (FallthroughSource != 0); 795da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 796da65ea86482bc116906edfb9ba1d7124f76cc867John McCall bool RequiresNormalCleanup = false; 797da65ea86482bc116906edfb9ba1d7124f76cc867John McCall if (Scope.isNormalCleanup() && 798da65ea86482bc116906edfb9ba1d7124f76cc867John McCall (HasFixups || HasExistingBranches || HasFallthrough)) { 799da65ea86482bc116906edfb9ba1d7124f76cc867John McCall RequiresNormalCleanup = true; 800da65ea86482bc116906edfb9ba1d7124f76cc867John McCall } 801da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 802da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // If we don't need the cleanup at all, we're done. 803da65ea86482bc116906edfb9ba1d7124f76cc867John McCall if (!RequiresNormalCleanup && !RequiresEHCleanup) { 804ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHStack.popCleanup(); // safe because there are no fixups 8051f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall assert(EHStack.getNumBranchFixups() == 0 || 8061f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall EHStack.hasNormalCleanups()); 807da65ea86482bc116906edfb9ba1d7124f76cc867John McCall return; 808da65ea86482bc116906edfb9ba1d7124f76cc867John McCall } 809da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 810da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // Copy the cleanup emission data out. Note that SmallVector 811da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // guarantees maximal alignment for its buffer regardless of its 812da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // type parameter. 813da65ea86482bc116906edfb9ba1d7124f76cc867John McCall llvm::SmallVector<char, 8*sizeof(void*)> CleanupBuffer; 814da65ea86482bc116906edfb9ba1d7124f76cc867John McCall CleanupBuffer.reserve(Scope.getCleanupSize()); 815da65ea86482bc116906edfb9ba1d7124f76cc867John McCall memcpy(CleanupBuffer.data(), 816da65ea86482bc116906edfb9ba1d7124f76cc867John McCall Scope.getCleanupBuffer(), Scope.getCleanupSize()); 817da65ea86482bc116906edfb9ba1d7124f76cc867John McCall CleanupBuffer.set_size(Scope.getCleanupSize()); 8181f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall EHScopeStack::Cleanup *Fn = 8191f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall reinterpret_cast<EHScopeStack::Cleanup*>(CleanupBuffer.data()); 820da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 821ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // We want to emit the EH cleanup after the normal cleanup, but go 822ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // ahead and do the setup for the EH cleanup while the scope is still 823ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // alive. 824ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *EHEntry = 0; 825ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SmallVector<llvm::Instruction*, 2> EHInstsToAppend; 826ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (RequiresEHCleanup) { 827ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHEntry = CreateEHEntry(*this, Scope); 828ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 829ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Figure out the branch-through dest if necessary. 830ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *EHBranchThroughDest = 0; 831ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (Scope.hasEHBranchThroughs()) { 832ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Scope.getEnclosingEHCleanup() != EHStack.stable_end()); 833ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHScope &S = *EHStack.find(Scope.getEnclosingEHCleanup()); 834ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHBranchThroughDest = CreateEHEntry(*this, cast<EHCleanupScope>(S)); 835ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 836ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 837ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If we have exactly one branch-after and no branch-throughs, we 838ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // can dispatch it without a switch. 8397cd4b060f1e59f6d29126383ceee614e4772f859John McCall if (!Scope.hasEHBranchThroughs() && 840ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.getNumEHBranchAfters() == 1) { 841ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(!EHBranchThroughDest); 842ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 843ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // TODO: remove the spurious eh.cleanup.dest stores if this edge 844ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // never went through any switches. 845ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *BranchAfterDest = Scope.getEHBranchAfterBlock(0); 846ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHInstsToAppend.push_back(llvm::BranchInst::Create(BranchAfterDest)); 847ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 848ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Otherwise, if we have any branch-afters, we need a switch. 849ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } else if (Scope.getNumEHBranchAfters()) { 850ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // The default of the switch belongs to the branch-throughs if 851ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // they exist. 852ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *Default = 853ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall (EHBranchThroughDest ? EHBranchThroughDest : getUnreachableBlock()); 854ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 855ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall const unsigned SwitchCapacity = Scope.getNumEHBranchAfters(); 856ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 857ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::LoadInst *Load = 858ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall new llvm::LoadInst(getEHCleanupDestSlot(), "cleanup.dest"); 859ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SwitchInst *Switch = 860ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SwitchInst::Create(Load, Default, SwitchCapacity); 861ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 862ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHInstsToAppend.push_back(Load); 863ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHInstsToAppend.push_back(Switch); 864ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 865ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (unsigned I = 0, E = Scope.getNumEHBranchAfters(); I != E; ++I) 866ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Switch->addCase(Scope.getEHBranchAfterIndex(I), 867ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.getEHBranchAfterBlock(I)); 868ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 869ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Otherwise, we have only branch-throughs; jump to the next EH 870ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // cleanup. 871ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } else { 872ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(EHBranchThroughDest); 873ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHInstsToAppend.push_back(llvm::BranchInst::Create(EHBranchThroughDest)); 874ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 875ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 876ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 877ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!RequiresNormalCleanup) { 878ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHStack.popCleanup(); 879ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } else { 880ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // As a kindof crazy internal case, branch-through fall-throughs 881ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // leave the insertion point set to the end of the last cleanup. 882ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall bool HasPrebranchedFallthrough = 883ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall (HasFallthrough && FallthroughSource->getTerminator()); 884ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(!HasPrebranchedFallthrough || 885ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall FallthroughSource->getTerminator()->getSuccessor(0) 886ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall == Scope.getNormalBlock()); 887da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 888da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // If we have a fallthrough and no other need for the cleanup, 889da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // emit it directly. 890ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (HasFallthrough && !HasPrebranchedFallthrough && 891ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall !HasFixups && !HasExistingBranches) { 892ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 893ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Fixups can cause us to optimistically create a normal block, 894ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // only to later have no real uses for it. Just delete it in 895ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // this case. 896ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // TODO: we can potentially simplify all the uses after this. 897ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (Scope.getNormalBlock()) { 898ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.getNormalBlock()->replaceAllUsesWith(getUnreachableBlock()); 899ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall delete Scope.getNormalBlock(); 900ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 901ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 902ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHStack.popCleanup(); 903ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 9041f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall EmitCleanup(*this, Fn, /*ForEH*/ false); 905da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 906da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // Otherwise, the best approach is to thread everything through 907da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // the cleanup block and then try to clean up after ourselves. 908da65ea86482bc116906edfb9ba1d7124f76cc867John McCall } else { 909da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // Force the entry block to exist. 910ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *NormalEntry = CreateNormalEntry(*this, Scope); 911da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 912ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If there's a fallthrough, we need to store the cleanup 913ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // destination index. For fall-throughs this is always zero. 914ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (HasFallthrough && !HasPrebranchedFallthrough) 915ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Builder.CreateStore(Builder.getInt32(0), getNormalCleanupDestSlot()); 916ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 917ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Emit the entry block. This implicitly branches to it if we 918ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // have fallthrough. All the fixups and existing branches should 919ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // already be branched to it. 9201f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall EmitBlock(NormalEntry); 921da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 922ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall bool HasEnclosingCleanups = 923ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall (Scope.getEnclosingNormalCleanup() != EHStack.stable_end()); 924ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 925ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Compute the branch-through dest if we need it: 926ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // - if there are branch-throughs threaded through the scope 927ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // - if fall-through is a branch-through 928ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // - if there are fixups that will be optimistically forwarded 929ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // to the enclosing cleanup 930ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *BranchThroughDest = 0; 931ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (Scope.hasBranchThroughs() || 932ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall (HasFallthrough && FallthroughIsBranchThrough) || 933ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall (HasFixups && HasEnclosingCleanups)) { 934ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(HasEnclosingCleanups); 935ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHScope &S = *EHStack.find(Scope.getEnclosingNormalCleanup()); 936ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BranchThroughDest = CreateNormalEntry(*this, cast<EHCleanupScope>(S)); 937da65ea86482bc116906edfb9ba1d7124f76cc867John McCall } 938da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 939ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *FallthroughDest = 0; 940ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SmallVector<llvm::Instruction*, 2> InstsToAppend; 941ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 942ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If there's exactly one branch-after and no other threads, 943ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // we can route it without a switch. 944ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Scope.hasBranchThroughs() && !HasFixups && !HasFallthrough && 945ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.getNumBranchAfters() == 1) { 946ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(!BranchThroughDest); 947ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 948ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // TODO: clean up the possibly dead stores to the cleanup dest slot. 949ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *BranchAfter = Scope.getBranchAfterBlock(0); 950ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall InstsToAppend.push_back(llvm::BranchInst::Create(BranchAfter)); 951ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 952ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Build a switch-out if we need it: 953ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // - if there are branch-afters threaded through the scope 954ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // - if fall-through is a branch-after 955ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // - if there are fixups that have nowhere left to go and 956ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // so must be immediately resolved 957ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } else if (Scope.getNumBranchAfters() || 958ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall (HasFallthrough && !FallthroughIsBranchThrough) || 959ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall (HasFixups && !HasEnclosingCleanups)) { 960ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 961ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *Default = 962ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall (BranchThroughDest ? BranchThroughDest : getUnreachableBlock()); 963ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 964ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // TODO: base this on the number of branch-afters and fixups 965ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall const unsigned SwitchCapacity = 10; 966ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 967ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::LoadInst *Load = 968ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall new llvm::LoadInst(getNormalCleanupDestSlot(), "cleanup.dest"); 969ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SwitchInst *Switch = 970ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SwitchInst::Create(Load, Default, SwitchCapacity); 971ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 972ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall InstsToAppend.push_back(Load); 973ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall InstsToAppend.push_back(Switch); 974ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 975ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Branch-after fallthrough. 976ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (HasFallthrough && !FallthroughIsBranchThrough) { 977ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall FallthroughDest = createBasicBlock("cleanup.cont"); 978ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Switch->addCase(Builder.getInt32(0), FallthroughDest); 979ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 980ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 981ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (unsigned I = 0, E = Scope.getNumBranchAfters(); I != E; ++I) { 982ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Switch->addCase(Scope.getBranchAfterIndex(I), 983ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.getBranchAfterBlock(I)); 984ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 985ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 986ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (HasFixups && !HasEnclosingCleanups) 987ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall ResolveAllBranchFixups(Switch); 988ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } else { 989ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // We should always have a branch-through destination in this case. 990ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(BranchThroughDest); 991ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall InstsToAppend.push_back(llvm::BranchInst::Create(BranchThroughDest)); 992ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 993da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 994ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // We're finally ready to pop the cleanup. 995ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHStack.popCleanup(); 996ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(EHStack.hasNormalCleanups() == HasEnclosingCleanups); 997da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 998ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitCleanup(*this, Fn, /*ForEH*/ false); 999ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1000ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Append the prepared cleanup prologue from above. 1001ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *NormalExit = Builder.GetInsertBlock(); 1002ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (unsigned I = 0, E = InstsToAppend.size(); I != E; ++I) 1003ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall NormalExit->getInstList().push_back(InstsToAppend[I]); 1004ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1005ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Optimistically hope that any fixups will continue falling through. 1006ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (unsigned I = FixupDepth, E = EHStack.getNumBranchFixups(); 1007ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall I < E; ++I) { 1008ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BranchFixup &Fixup = CGF.EHStack.getBranchFixup(I); 1009ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Fixup.Destination) continue; 1010ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Fixup.OptimisticBranchBlock) { 1011ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall new llvm::StoreInst(Builder.getInt32(Fixup.DestinationIndex), 1012ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall getNormalCleanupDestSlot(), 1013ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.InitialBranch); 1014ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.InitialBranch->setSuccessor(0, NormalEntry); 1015ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 1016ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.OptimisticBranchBlock = NormalExit; 1017ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 1018ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1019ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (FallthroughDest) 1020ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitBlock(FallthroughDest); 1021ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall else if (!HasFallthrough) 1022ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Builder.ClearInsertionPoint(); 1023ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1024ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Check whether we can merge NormalEntry into a single predecessor. 1025ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // This might invalidate (non-IR) pointers to NormalEntry. 1026ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *NewNormalEntry = 1027ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall SimplifyCleanupEntry(*this, NormalEntry); 1028ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1029ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If it did invalidate those pointers, and NormalEntry was the same 1030ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // as NormalExit, go back and patch up the fixups. 1031ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (NewNormalEntry != NormalEntry && NormalEntry == NormalExit) 1032ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (unsigned I = FixupDepth, E = EHStack.getNumBranchFixups(); 1033ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall I < E; ++I) 1034ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall CGF.EHStack.getBranchFixup(I).OptimisticBranchBlock = NewNormalEntry; 1035da65ea86482bc116906edfb9ba1d7124f76cc867John McCall } 1036da65ea86482bc116906edfb9ba1d7124f76cc867John McCall } 1037da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 1038ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(EHStack.hasNormalCleanups() || EHStack.getNumBranchFixups() == 0); 1039ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1040da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // Emit the EH cleanup if required. 1041da65ea86482bc116906edfb9ba1d7124f76cc867John McCall if (RequiresEHCleanup) { 10421f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); 1043ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 10441f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall EmitBlock(EHEntry); 1045ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitCleanup(*this, Fn, /*ForEH*/ true); 1046ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1047ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Append the prepared cleanup prologue from above. 1048ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *EHExit = Builder.GetInsertBlock(); 1049ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (unsigned I = 0, E = EHInstsToAppend.size(); I != E; ++I) 1050ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHExit->getInstList().push_back(EHInstsToAppend[I]); 1051ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 10521f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall Builder.restoreIP(SavedIP); 1053ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1054ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall SimplifyCleanupEntry(*this, EHEntry); 1055da65ea86482bc116906edfb9ba1d7124f76cc867John McCall } 1056da65ea86482bc116906edfb9ba1d7124f76cc867John McCall} 1057da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 1058ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// Terminate the current block by emitting a branch which might leave 1059ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// the current cleanup-protected scope. The target scope may not yet 1060ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// be known, in which case this will require a fixup. 1061ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// 1062ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// As a side-effect, this method clears the insertion point. 1063f1549f66a8216a78112286e3978cea2c29d6334cJohn McCallvoid CodeGenFunction::EmitBranchThroughCleanup(JumpDest Dest) { 1064413e67778d593215d2f2161a4e712c8568f1ddd0John McCall assert(Dest.getScopeDepth().encloses(EHStack.getInnermostNormalCleanup()) 1065413e67778d593215d2f2161a4e712c8568f1ddd0John McCall && "stale jump destination"); 1066413e67778d593215d2f2161a4e712c8568f1ddd0John McCall 106746831a93e1805ddaebd68f37cdb5496a86b44cf0Anders Carlsson if (!HaveInsertPoint()) 106846831a93e1805ddaebd68f37cdb5496a86b44cf0Anders Carlsson return; 10691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1070f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // Create the branch. 1071ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BranchInst *BI = Builder.CreateBr(Dest.getBlock()); 10721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1073838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall // Calculate the innermost active normal cleanup. 1074838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall EHScopeStack::stable_iterator 1075838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall TopCleanup = EHStack.getInnermostActiveNormalCleanup(); 1076838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall 1077838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall // If we're not in an active normal cleanup scope, or if the 1078838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall // destination scope is within the innermost active normal cleanup 1079838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall // scope, we don't need to worry about fixups. 1080838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall if (TopCleanup == EHStack.stable_end() || 1081838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall TopCleanup.encloses(Dest.getScopeDepth())) { // works for invalid 1082f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall Builder.ClearInsertionPoint(); 108387eaf17cc88516277e4389dfa15df93ecfdce559Anders Carlsson return; 1084f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall } 10851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1086f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // If we can't resolve the destination cleanup scope, just add this 1087ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // to the current cleanup scope as a branch fixup. 1088ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Dest.getScopeDepth().isValid()) { 1089ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BranchFixup &Fixup = EHStack.addBranchFixup(); 1090ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.Destination = Dest.getBlock(); 1091ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.DestinationIndex = Dest.getDestIndex(); 1092ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.InitialBranch = BI; 1093ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.OptimisticBranchBlock = 0; 1094ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1095f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall Builder.ClearInsertionPoint(); 109687eaf17cc88516277e4389dfa15df93ecfdce559Anders Carlsson return; 109787eaf17cc88516277e4389dfa15df93ecfdce559Anders Carlsson } 10981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1099ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Otherwise, thread through all the normal cleanups in scope. 1100ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1101ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Store the index at the start. 1102ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::ConstantInt *Index = Builder.getInt32(Dest.getDestIndex()); 1103ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall new llvm::StoreInst(Index, getNormalCleanupDestSlot(), BI); 1104ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1105ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Adjust BI to point to the first cleanup block. 1106ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall { 1107ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHCleanupScope &Scope = 1108838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall cast<EHCleanupScope>(*EHStack.find(TopCleanup)); 1109ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BI->setSuccessor(0, CreateNormalEntry(*this, Scope)); 1110ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 1111ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1112ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Add this destination to all the scopes involved. 1113838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall EHScopeStack::stable_iterator I = TopCleanup; 1114ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHScopeStack::stable_iterator E = Dest.getScopeDepth(); 1115ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (E.strictlyEncloses(I)) { 1116ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall while (true) { 1117ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.find(I)); 1118ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Scope.isNormalCleanup()); 1119ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall I = Scope.getEnclosingNormalCleanup(); 1120ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1121ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If this is the last cleanup we're propagating through, tell it 1122ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // that there's a resolved jump moving through it. 1123ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!E.strictlyEncloses(I)) { 1124ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.addBranchAfter(Index, Dest.getBlock()); 1125ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall break; 1126da65ea86482bc116906edfb9ba1d7124f76cc867John McCall } 1127ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1128ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Otherwise, tell the scope that there's a jump propoagating 1129ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // through it. If this isn't new information, all the rest of 1130ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // the work has been done before. 1131ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Scope.addBranchThrough(Dest.getBlock())) 1132ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall break; 1133f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall } 113487eaf17cc88516277e4389dfa15df93ecfdce559Anders Carlsson } 1135f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 1136f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall Builder.ClearInsertionPoint(); 1137f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall} 11381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1139ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallvoid CodeGenFunction::EmitBranchThroughEHCleanup(UnwindDest Dest) { 1140ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // We should never get invalid scope depths for an UnwindDest; that 1141ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // implies that the destination wasn't set up correctly. 1142ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Dest.getScopeDepth().isValid() && "invalid scope depth on EH dest?"); 1143ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1144f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (!HaveInsertPoint()) 1145f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall return; 11461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1147f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // Create the branch. 1148ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BranchInst *BI = Builder.CreateBr(Dest.getBlock()); 1149f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 1150838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall // Calculate the innermost active cleanup. 1151838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall EHScopeStack::stable_iterator 1152838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall InnermostCleanup = EHStack.getInnermostActiveEHCleanup(); 1153838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall 1154ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If the destination is in the same EH cleanup scope as us, we 1155ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // don't need to thread through anything. 1156838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall if (InnermostCleanup.encloses(Dest.getScopeDepth())) { 1157f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall Builder.ClearInsertionPoint(); 115887eaf17cc88516277e4389dfa15df93ecfdce559Anders Carlsson return; 115987eaf17cc88516277e4389dfa15df93ecfdce559Anders Carlsson } 1160838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall assert(InnermostCleanup != EHStack.stable_end()); 11611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1162ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Store the index at the start. 1163ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::ConstantInt *Index = Builder.getInt32(Dest.getDestIndex()); 1164ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall new llvm::StoreInst(Index, getEHCleanupDestSlot(), BI); 1165ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1166ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Adjust BI to point to the first cleanup block. 1167ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall { 1168ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHCleanupScope &Scope = 1169838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall cast<EHCleanupScope>(*EHStack.find(InnermostCleanup)); 1170ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BI->setSuccessor(0, CreateEHEntry(*this, Scope)); 1171ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 1172ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1173ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Add this destination to all the scopes involved. 1174ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (EHScopeStack::stable_iterator 1175838d796d020f6a8cd2b2d1e2a0a85c83bbf29543John McCall I = InnermostCleanup, E = Dest.getScopeDepth(); ; ) { 1176ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(E.strictlyEncloses(I)); 1177ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.find(I)); 1178ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Scope.isEHCleanup()); 1179ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall I = Scope.getEnclosingEHCleanup(); 1180ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1181ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If this is the last cleanup we're propagating through, add this 1182ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // as a branch-after. 1183ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (I == E) { 1184ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.addEHBranchAfter(Index, Dest.getBlock()); 1185ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall break; 1186f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall } 1187ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1188ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Otherwise, add it as a branch-through. If this isn't new 1189ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // information, all the rest of the work has been done before. 1190ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Scope.addEHBranchThrough(Dest.getBlock())) 1191ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall break; 1192f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall } 1193f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 1194f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall Builder.ClearInsertionPoint(); 119587eaf17cc88516277e4389dfa15df93ecfdce559Anders Carlsson} 1196ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1197ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// All the branch fixups on the EH stack have propagated out past the 1198ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// outermost normal cleanup; resolve them all by adding cases to the 1199ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// given switch instruction. 1200ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallvoid CodeGenFunction::ResolveAllBranchFixups(llvm::SwitchInst *Switch) { 1201ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SmallPtrSet<llvm::BasicBlock*, 4> CasesAdded; 1202ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1203ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (unsigned I = 0, E = EHStack.getNumBranchFixups(); I != E; ++I) { 1204ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Skip this fixup if its destination isn't set or if we've 1205ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // already treated it. 1206ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BranchFixup &Fixup = EHStack.getBranchFixup(I); 1207ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (Fixup.Destination == 0) continue; 1208ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!CasesAdded.insert(Fixup.Destination)) continue; 1209ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1210ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Switch->addCase(Builder.getInt32(Fixup.DestinationIndex), 1211ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.Destination); 1212ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 1213ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1214ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHStack.clearFixups(); 1215ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall} 1216ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1217ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallvoid CodeGenFunction::ResolveBranchFixups(llvm::BasicBlock *Block) { 1218ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Block && "resolving a null target block"); 1219ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!EHStack.getNumBranchFixups()) return; 1220ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1221ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(EHStack.hasNormalCleanups() && 1222ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall "branch fixups exist with no normal cleanups on stack"); 1223ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1224ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SmallPtrSet<llvm::BasicBlock*, 4> ModifiedOptimisticBlocks; 1225ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall bool ResolvedAny = false; 1226ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1227ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (unsigned I = 0, E = EHStack.getNumBranchFixups(); I != E; ++I) { 1228ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Skip this fixup if its destination doesn't match. 1229ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BranchFixup &Fixup = EHStack.getBranchFixup(I); 1230ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (Fixup.Destination != Block) continue; 1231ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1232ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.Destination = 0; 1233ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall ResolvedAny = true; 1234ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1235ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If it doesn't have an optimistic branch block, LatestBranch is 1236ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // already pointing to the right place. 1237ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *BranchBB = Fixup.OptimisticBranchBlock; 1238ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!BranchBB) 1239ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall continue; 1240ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1241ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Don't process the same optimistic branch block twice. 1242ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!ModifiedOptimisticBlocks.insert(BranchBB)) 1243ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall continue; 1244ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1245ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SwitchInst *Switch = TransitionToCleanupSwitch(*this, BranchBB); 1246ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1247ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Add a case to the switch. 1248ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Switch->addCase(Builder.getInt32(Fixup.DestinationIndex), Block); 1249ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 1250ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1251ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (ResolvedAny) 1252ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHStack.popNullFixups(); 1253ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall} 1254ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1255cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall/// Activate a cleanup that was created in an inactivated state. 1256cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCallvoid CodeGenFunction::ActivateCleanup(EHScopeStack::stable_iterator C) { 1257cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall assert(C != EHStack.stable_end() && "activating bottom of stack?"); 1258cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.find(C)); 1259cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall assert(!Scope.isActive() && "double activation"); 1260cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall 1261cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall // Calculate whether the cleanup was used: 1262cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall bool Used = false; 1263cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall 1264cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall // - as a normal cleanup 1265cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall if (Scope.isNormalCleanup()) { 1266cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall bool NormalUsed = false; 1267cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall if (Scope.getNormalBlock()) { 1268cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall NormalUsed = true; 1269cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall } else { 1270cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall // Check whether any enclosed cleanups were needed. 1271cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall for (EHScopeStack::stable_iterator 1272cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall I = EHStack.getInnermostNormalCleanup(); I != C; ) { 1273cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall assert(C.strictlyEncloses(I)); 1274cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall EHCleanupScope &S = cast<EHCleanupScope>(*EHStack.find(I)); 1275cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall if (S.getNormalBlock()) { 1276cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall NormalUsed = true; 1277cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall break; 1278cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall } 1279cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall I = S.getEnclosingNormalCleanup(); 1280cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall } 1281cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall } 1282cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall 1283cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall if (NormalUsed) 1284cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall Used = true; 1285cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall else 1286cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall Scope.setActivatedBeforeNormalUse(true); 1287cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall } 1288cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall 1289cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall // - as an EH cleanup 1290cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall if (Scope.isEHCleanup()) { 1291cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall bool EHUsed = false; 1292cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall if (Scope.getEHBlock()) { 1293cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall EHUsed = true; 1294cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall } else { 1295cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall // Check whether any enclosed cleanups were needed. 1296cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall for (EHScopeStack::stable_iterator 1297cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall I = EHStack.getInnermostEHCleanup(); I != C; ) { 1298cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall assert(C.strictlyEncloses(I)); 1299cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall EHCleanupScope &S = cast<EHCleanupScope>(*EHStack.find(I)); 1300cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall if (S.getEHBlock()) { 1301cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall EHUsed = true; 1302cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall break; 1303cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall } 1304cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall I = S.getEnclosingEHCleanup(); 1305cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall } 1306cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall } 1307cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall 1308cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall if (EHUsed) 1309cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall Used = true; 1310cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall else 1311cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall Scope.setActivatedBeforeEHUse(true); 1312cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall } 1313cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall 1314cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall llvm::AllocaInst *Var = EHCleanupScope::activeSentinel(); 1315cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall if (Used) { 1316cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall Var = CreateTempAlloca(Builder.getInt1Ty()); 1317cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall InitTempAlloca(Var, Builder.getFalse()); 1318cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall } 1319cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall Scope.setActiveVar(Var); 1320cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall} 1321cd2d2b7814e0104ed41a8da159a06a8ca77b70d8John McCall 1322ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallllvm::Value *CodeGenFunction::getNormalCleanupDestSlot() { 1323ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!NormalCleanupDest) 1324ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall NormalCleanupDest = 1325ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall CreateTempAlloca(Builder.getInt32Ty(), "cleanup.dest.slot"); 1326ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall return NormalCleanupDest; 1327ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall} 1328ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1329ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallllvm::Value *CodeGenFunction::getEHCleanupDestSlot() { 1330ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!EHCleanupDest) 1331ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHCleanupDest = 1332ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall CreateTempAlloca(Builder.getInt32Ty(), "eh.cleanup.dest.slot"); 1333ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall return EHCleanupDest; 1334ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall} 13358d308384a220c7dc81755c47cdcbdd87dac25d5bDevang Patel 13368d308384a220c7dc81755c47cdcbdd87dac25d5bDevang Patelvoid CodeGenFunction::EmitDeclRefExprDbgValue(const DeclRefExpr *E, 133725c2c8fb9309050612009a6571e2660e75531348Devang Patel llvm::ConstantInt *Init) { 133825c2c8fb9309050612009a6571e2660e75531348Devang Patel assert (Init && "Invalid DeclRefExpr initializer!"); 133925c2c8fb9309050612009a6571e2660e75531348Devang Patel if (CGDebugInfo *Dbg = getDebugInfo()) 134025c2c8fb9309050612009a6571e2660e75531348Devang Patel Dbg->EmitGlobalVariable(E->getDecl(), Init, Builder); 13418d308384a220c7dc81755c47cdcbdd87dac25d5bDevang Patel} 1342