CodeGenFunction.cpp revision 7cd4b060f1e59f6d29126383ceee614e4772f859
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" 163f2af1002249c8acc9ce17f1fc50324864feb8e1Eli Friedman#include "CGDebugInfo.h" 17f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall#include "CGException.h" 185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Basic/TargetInfo.h" 1931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner#include "clang/AST/APValue.h" 20de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 21c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/Decl.h" 222b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson#include "clang/AST/DeclCXX.h" 236a1e0eb557d47e85185e09bdf8721f53f4bf9c9cMike Stump#include "clang/AST/StmtCXX.h" 247255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner#include "clang/Frontend/CodeGenOptions.h" 254e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump#include "llvm/Target/TargetData.h" 267255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner#include "llvm/Intrinsics.h" 275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace CodeGen; 295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 301eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpCodeGenFunction::CodeGenFunction(CodeGenModule &cgm) 31a4f668f3b7e03629066a01b04e415cb2b4655dafMike Stump : BlockFunction(cgm, *this, Builder), CGM(cgm), 32a4f668f3b7e03629066a01b04e415cb2b4655dafMike Stump Target(CGM.getContext().Target), 33aac8705c046f01a264a4f82832895a5d9e695633Owen Anderson Builder(cgm.getModule().getContext()), 34ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall NormalCleanupDest(0), EHCleanupDest(0), NextCleanupDestIndex(1), 35f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall ExceptionSlot(0), DebugInfo(0), IndirectBranch(0), 36ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall SwitchInsn(0), CaseRangeBlock(0), 37f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall DidCallStackSave(false), UnreachableBlock(0), 382504941793b549323f9d29c62507cf21d865fadeJohn McCall CXXThisDecl(0), CXXThisValue(0), CXXVTTDecl(0), CXXVTTValue(0), 39f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall ConditionalBranchLevel(0), TerminateLandingPad(0), TerminateHandler(0), 4083252dcfe61aaebcb6bc117e71dc12968729513fChris Lattner TrapBB(0) { 4177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner 4277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner // Get some frequently used types. 434e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump LLVMPointerWidth = Target.getPointerWidth(0); 4477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::LLVMContext &LLVMContext = CGM.getLLVMContext(); 4577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner IntPtrTy = llvm::IntegerType::get(LLVMContext, LLVMPointerWidth); 4677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Int32Ty = llvm::Type::getInt32Ty(LLVMContext); 4777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Int64Ty = llvm::Type::getInt64Ty(LLVMContext); 4877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner 49d88ea5687968640ada2bc5a10211cbeb68a671ecMike Stump Exceptions = getContext().getLangOptions().Exceptions; 509c276ae0f24d4cee8f7954069d4b8eae45d0447dMike Stump CatchUndefined = getContext().getLangOptions().CatchUndefined; 5135415f5132f70ad5097a3514ab84251e10db3664Douglas Gregor CGM.getMangleContext().startNewFunction(); 524111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner} 535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerASTContext &CodeGenFunction::getContext() const { 555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return CGM.getContext(); 565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 590096acf421c4609ce7f43e8b05f8c5ca866d4611Daniel Dunbarllvm::Value *CodeGenFunction::GetAddrOfLocalVar(const VarDecl *VD) { 600096acf421c4609ce7f43e8b05f8c5ca866d4611Daniel Dunbar llvm::Value *Res = LocalDeclMap[VD]; 610096acf421c4609ce7f43e8b05f8c5ca866d4611Daniel Dunbar assert(Res && "Invalid argument to GetAddrOfLocalVar(), no decl!"); 620096acf421c4609ce7f43e8b05f8c5ca866d4611Daniel Dunbar return Res; 63813733577d33ec56479667b49e1bff42dc6bba90Lauro Ramos Venancio} 645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 650096acf421c4609ce7f43e8b05f8c5ca866d4611Daniel Dunbarllvm::Constant * 660096acf421c4609ce7f43e8b05f8c5ca866d4611Daniel DunbarCodeGenFunction::GetAddrOfStaticLocalVar(const VarDecl *BVD) { 670096acf421c4609ce7f43e8b05f8c5ca866d4611Daniel Dunbar return cast<llvm::Constant>(GetAddrOfLocalVar(BVD)); 68dde0a94120915fa925d1ffcdb997c7b44dc9fa21Anders Carlsson} 69dde0a94120915fa925d1ffcdb997c7b44dc9fa21Anders Carlsson 708b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbarconst llvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) { 718b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar return CGM.getTypes().ConvertTypeForMem(T); 728b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar} 738b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar 745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst llvm::Type *CodeGenFunction::ConvertType(QualType T) { 755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return CGM.getTypes().ConvertType(T); 765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 784111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattnerbool CodeGenFunction::hasAggregateLLVMType(QualType T) { 79e9d34dc7afe06c9adaacad7a678a0cbbf749ea75Anders Carlsson return T->isRecordType() || T->isArrayType() || T->isAnyComplexType() || 80e9d34dc7afe06c9adaacad7a678a0cbbf749ea75Anders Carlsson T->isMemberFunctionPointerType(); 814111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner} 82391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 831c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbarvoid CodeGenFunction::EmitReturnBlock() { 841c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // For cleanliness, we try to avoid emitting the return block for 851c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // simple cases. 861c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); 871c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 881c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar if (CurBB) { 891c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar assert(!CurBB->getTerminator() && "Unexpected terminated block."); 901c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 9196e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar // We have a valid insert point, reuse it if it is empty or there are no 9296e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar // explicit jumps to the return block. 93ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) { 94ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall ReturnBlock.getBlock()->replaceAllUsesWith(CurBB); 95ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall delete ReturnBlock.getBlock(); 9696e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar } else 97ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitBlock(ReturnBlock.getBlock()); 981c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar return; 991c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 1001c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 1011c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // Otherwise, if the return block is the target of a single direct 1021c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // branch then we can just put the code in that block instead. This 1031c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // cleans up functions which started with a unified return block. 104ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (ReturnBlock.getBlock()->hasOneUse()) { 1051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump llvm::BranchInst *BI = 106ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->use_begin()); 107f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (BI && BI->isUnconditional() && 108ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BI->getSuccessor(0) == ReturnBlock.getBlock()) { 1091c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // Reset insertion point and delete the branch. 1101c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar Builder.SetInsertPoint(BI->getParent()); 1111c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar BI->eraseFromParent(); 112ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall delete ReturnBlock.getBlock(); 1131c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar return; 1141c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 1151c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 1161c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 117f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // FIXME: We are at an unreachable point, there is no reason to emit the block 118f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // unless it has uses. However, we still need a place to put the debug 119f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // region.end for now. 1201c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 121ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitBlock(ReturnBlock.getBlock()); 122f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall} 123f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 124f1549f66a8216a78112286e3978cea2c29d6334cJohn McCallstatic void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) { 125f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (!BB) return; 126f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (!BB->use_empty()) 127f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall return CGF.CurFn->getBasicBlockList().push_back(BB); 128f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall delete BB; 1291c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar} 1301c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 131af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbarvoid CodeGenFunction::FinishFunction(SourceLocation EndLoc) { 132391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner assert(BreakContinueStack.empty() && 133391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner "mismatched push/pop in break/continue stack!"); 1341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Emit function epilog (to return). 1361c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar EmitReturnBlock(); 137f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar 1387255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner EmitFunctionInstrumentation("__cyg_profile_func_exit"); 1397255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 140f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar // Emit debug descriptor for function end. 141e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson if (CGDebugInfo *DI = getDebugInfo()) { 142f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar DI->setLocation(EndLoc); 1435a6fbcfd8c15a2296f94a0473a68ec09d429827fDevang Patel DI->EmitFunctionEnd(Builder); 144f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar } 145f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar 14635b21b884e5c3447a52a74d7ffaba966b07ac81fChris Lattner EmitFunctionEpilog(*CurFnInfo); 147cce3d4f9812182ed4e551b7cf0fc86576be8d9c5Mike Stump EmitEndEHSpec(CurCodeDecl); 1485ca2084cf9b529563209429857f01fdae9dcdfa5Daniel Dunbar 149f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall assert(EHStack.empty() && 150f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall "did not remove all scopes from cleanup stack!"); 151f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 152d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If someone did an indirect goto, emit the indirect goto block at the end of 153d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // the function. 154d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) { 155d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner EmitBlock(IndirectBranch->getParent()); 156d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner Builder.ClearInsertionPoint(); 157d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 158d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner 159391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // Remove the AllocaInsertPt instruction, which is just a convenience for us. 160481769b5dc102b0256b35581e787909ad5edfab5Chris Lattner llvm::Instruction *Ptr = AllocaInsertPt; 161391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner AllocaInsertPt = 0; 162481769b5dc102b0256b35581e787909ad5edfab5Chris Lattner Ptr->eraseFromParent(); 163d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner 164d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If someone took the address of a label but never did an indirect goto, we 165d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // made a zero entry PHI node, which is illegal, zap it now. 166d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) { 167d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress()); 168d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (PN->getNumIncomingValues() == 0) { 169d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType())); 170d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner PN->eraseFromParent(); 171d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 172d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 173f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 174ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitIfUsed(*this, RethrowBlock.getBlock()); 175f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, TerminateLandingPad); 176f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, TerminateHandler); 177f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, UnreachableBlock); 178744016dde06fcffd50931e94a98c850f8b12cd87John McCall 179744016dde06fcffd50931e94a98c850f8b12cd87John McCall if (CGM.getCodeGenOpts().EmitDeclMetadata) 180744016dde06fcffd50931e94a98c850f8b12cd87John McCall EmitDeclMetadata(); 181c8aa5f1f264fb230c38182adab944232bb160c2bChris Lattner} 182c8aa5f1f264fb230c38182adab944232bb160c2bChris Lattner 1837255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// ShouldInstrumentFunction - Return true if the current function should be 1847255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// instrumented with __cyg_profile_func_* calls 1857255a2d997b15beae82e627052fdb1b2474495c2Chris Lattnerbool CodeGenFunction::ShouldInstrumentFunction() { 1867255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner if (!CGM.getCodeGenOpts().InstrumentFunctions) 1877255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return false; 1887255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner if (CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>()) 1897255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return false; 1907255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return true; 1917255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner} 1927255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 1937255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// EmitFunctionInstrumentation - Emit LLVM code to call the specified 1947255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// instrumentation function with the current function and the call site, if 1957255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// function instrumentation is enabled. 1967255a2d997b15beae82e627052fdb1b2474495c2Chris Lattnervoid CodeGenFunction::EmitFunctionInstrumentation(const char *Fn) { 1977255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner if (!ShouldInstrumentFunction()) 1987255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return; 1997255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 2008dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner const llvm::PointerType *PointerTy; 2017255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner const llvm::FunctionType *FunctionTy; 2027255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner std::vector<const llvm::Type*> ProfileFuncArgs; 2037255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 2048dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner // void __cyg_profile_func_{enter,exit} (void *this_fn, void *call_site); 2058dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner PointerTy = llvm::Type::getInt8PtrTy(VMContext); 2068dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner ProfileFuncArgs.push_back(PointerTy); 2078dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner ProfileFuncArgs.push_back(PointerTy); 2087255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner FunctionTy = llvm::FunctionType::get( 2097255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner llvm::Type::getVoidTy(VMContext), 2107255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner ProfileFuncArgs, false); 2117255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 2127255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner llvm::Constant *F = CGM.CreateRuntimeFunction(FunctionTy, Fn); 2137255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner llvm::CallInst *CallSite = Builder.CreateCall( 2147255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner CGM.getIntrinsic(llvm::Intrinsic::returnaddress, 0, 0), 21577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::ConstantInt::get(Int32Ty, 0), 2167255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner "callsite"); 2177255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 2188dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner Builder.CreateCall2(F, 2198dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner llvm::ConstantExpr::getBitCast(CurFn, PointerTy), 2208dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner CallSite); 2217255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner} 2227255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 2230ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlssonvoid CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy, 2247c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar llvm::Function *Fn, 2252284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar const FunctionArgList &Args, 2262284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar SourceLocation StartLoc) { 2270ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson const Decl *D = GD.getDecl(); 2280ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson 2294cc1a4703363ff940b6273aeef9d96a87edeb04bAnders Carlsson DidCallStackSave = false; 230b5437d238752dc297e42410e98d38d5250fe0463Chris Lattner CurCodeDecl = CurFuncDecl = D; 2317c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FnRetTy = RetTy; 232bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar CurFn = Fn; 2335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(CurFn->isDeclaration() && "Function already has body?"); 234ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner 235a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen // Pass inline keyword to optimizer if it appears explicitly on any 236a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen // declaration. 237a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) 238a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen for (FunctionDecl::redecl_iterator RI = FD->redecls_begin(), 239a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen RE = FD->redecls_end(); RI != RE; ++RI) 240a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen if (RI->isInlineSpecified()) { 241a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen Fn->addFnAttr(llvm::Attribute::InlineHint); 242a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen break; 243a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen } 244a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen 24555e874299f2ad827646a4ca9ea38c402aaeb38c9Daniel Dunbar llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn); 2465ca2084cf9b529563209429857f01fdae9dcdfa5Daniel Dunbar 2475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Create a marker to make it easy to insert allocas into the entryblock 24855352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner // later. Don't create this with the builder, because we don't want it 24955352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner // folded. 25077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Value *Undef = llvm::UndefValue::get(Int32Ty); 25177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "", EntryBB); 252f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner if (Builder.isNamePreserving()) 253f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner AllocaInsertPt->setName("allocapt"); 2541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 255f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall ReturnBlock = getJumpDestInCurrentScope("return"); 2561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 25755352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner Builder.SetInsertPoint(EntryBB); 2581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 259ce056bcaa1c97b89a4b2de2112c62d060863be2bDouglas Gregor QualType FnType = getContext().getFunctionType(RetTy, 0, 0, false, 0, 260ce056bcaa1c97b89a4b2de2112c62d060863be2bDouglas Gregor false, false, 0, 0, 261264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola /*FIXME?*/ 262264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo()); 26391cc815ffd13d4a78ae1b5bd617e19dd555de4f4Mike Stump 264af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta // Emit subprogram debug descriptor. 265e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson if (CGDebugInfo *DI = getDebugInfo()) { 2662284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar DI->setLocation(StartLoc); 2679c6c3a0e3ae09626d2d4b04e4ffa42c3d7cab32bDevang Patel DI->EmitFunctionStart(GD, FnType, CurFn, Builder); 268af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta } 269af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta 2707255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner EmitFunctionInstrumentation("__cyg_profile_func_enter"); 2717255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 27288b5396b0897f28d22ae3debf4a0d97b33b6c362Daniel Dunbar // FIXME: Leaked. 27304a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // CC info is ignored, hopefully? 27404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall CurFnInfo = &CGM.getTypes().getFunctionInfo(FnRetTy, Args, 275264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo()); 276b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman 277b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman if (RetTy->isVoidType()) { 278b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman // Void type; nothing to return. 279b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman ReturnValue = 0; 280b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect && 281b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman hasAggregateLLVMType(CurFnInfo->getReturnType())) { 282b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman // Indirect aggregate return; emit returned value directly into sret slot. 283647a1ec397fa13af176d07d9f5d071560a94c7a9Daniel Dunbar // This reduces code size, and affects correctness in C++. 284b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman ReturnValue = CurFn->arg_begin(); 285b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } else { 286647a1ec397fa13af176d07d9f5d071560a94c7a9Daniel Dunbar ReturnValue = CreateIRTemp(RetTy, "retval"); 287b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } 288b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman 289cce3d4f9812182ed4e551b7cf0fc86576be8d9c5Mike Stump EmitStartEHSpec(CurCodeDecl); 29088b5396b0897f28d22ae3debf4a0d97b33b6c362Daniel Dunbar EmitFunctionProlog(*CurFnInfo, CurFn, Args); 2911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2922504941793b549323f9d29c62507cf21d865fadeJohn McCall if (CXXThisDecl) 2932504941793b549323f9d29c62507cf21d865fadeJohn McCall CXXThisValue = Builder.CreateLoad(LocalDeclMap[CXXThisDecl], "this"); 2942504941793b549323f9d29c62507cf21d865fadeJohn McCall if (CXXVTTDecl) 2952504941793b549323f9d29c62507cf21d865fadeJohn McCall CXXVTTValue = Builder.CreateLoad(LocalDeclMap[CXXVTTDecl], "vtt"); 2962504941793b549323f9d29c62507cf21d865fadeJohn McCall 297751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson // If any of the arguments have a variably modified type, make sure to 298751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson // emit the type size. 299751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); 300751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson i != e; ++i) { 301751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson QualType Ty = i->second; 302751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson 303751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson if (Ty->isVariablyModifiedType()) 304751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson EmitVLASize(Ty); 305751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson } 3067c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar} 307eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman 3089fc6a7774643a810c8501dae2323e863fefb623eJohn McCallvoid CodeGenFunction::EmitFunctionBody(FunctionArgList &Args) { 3099fc6a7774643a810c8501dae2323e863fefb623eJohn McCall const FunctionDecl *FD = cast<FunctionDecl>(CurGD.getDecl()); 31006a9f3680d22529a2fcf20c52d71cf221d99d910Douglas Gregor assert(FD->getBody()); 31106a9f3680d22529a2fcf20c52d71cf221d99d910Douglas Gregor EmitStmt(FD->getBody()); 312a355e07454463b19829ac92ffd115a097faff0e0John McCall} 313a355e07454463b19829ac92ffd115a097faff0e0John McCall 314c997d4278d329e18891aac9698fb991b2d4622ebAnders Carlssonvoid CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn) { 3150ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 3160ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson 317e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson // Check if we should generate debug info for this function. 3181feade8e520be483293dbf55eb57a51720899589Mike Stump if (CGM.getDebugInfo() && !FD->hasAttr<NoDebugAttr>()) 319e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson DebugInfo = CGM.getDebugInfo(); 3201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3217c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FunctionArgList Args; 3221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3236a1e0eb557d47e85185e09bdf8721f53f4bf9c9cMike Stump CurGD = GD; 3242b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 3252b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson if (MD->isInstance()) { 3262b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson // Create the implicit 'this' decl. 3272b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson // FIXME: I'm not entirely sure I like using a fake decl just for code 3282b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson // generation. Maybe we can come up with a better way? 3292504941793b549323f9d29c62507cf21d865fadeJohn McCall CXXThisDecl = ImplicitParamDecl::Create(getContext(), 0, 3302504941793b549323f9d29c62507cf21d865fadeJohn McCall FD->getLocation(), 3311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump &getContext().Idents.get("this"), 3322b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson MD->getThisType(getContext())); 3332b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson Args.push_back(std::make_pair(CXXThisDecl, CXXThisDecl->getType())); 334f6c56e2323c3f973253805a2f35629f3253ebed4Anders Carlsson 335f6c56e2323c3f973253805a2f35629f3253ebed4Anders Carlsson // Check if we need a VTT parameter as well. 336af4403545a50a60d208e6fcae057308d576a92e0Anders Carlsson if (CodeGenVTables::needsVTTParameter(GD)) { 337f6c56e2323c3f973253805a2f35629f3253ebed4Anders Carlsson // FIXME: The comment about using a fake decl above applies here too. 338f6c56e2323c3f973253805a2f35629f3253ebed4Anders Carlsson QualType T = getContext().getPointerType(getContext().VoidPtrTy); 339f6c56e2323c3f973253805a2f35629f3253ebed4Anders Carlsson CXXVTTDecl = 3402504941793b549323f9d29c62507cf21d865fadeJohn McCall ImplicitParamDecl::Create(getContext(), 0, FD->getLocation(), 341f6c56e2323c3f973253805a2f35629f3253ebed4Anders Carlsson &getContext().Idents.get("vtt"), T); 342f6c56e2323c3f973253805a2f35629f3253ebed4Anders Carlsson Args.push_back(std::make_pair(CXXVTTDecl, CXXVTTDecl->getType())); 343f6c56e2323c3f973253805a2f35629f3253ebed4Anders Carlsson } 3442b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson } 3452b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson } 3461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 347eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman if (FD->getNumParams()) { 348183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const FunctionProtoType* FProto = FD->getType()->getAs<FunctionProtoType>(); 349eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman assert(FProto && "Function def must have prototype!"); 3507c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar 3517c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) 3521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Args.push_back(std::make_pair(FD->getParamDecl(i), 3537c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FProto->getArgType(i))); 3545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 355af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar 356a355e07454463b19829ac92ffd115a097faff0e0John McCall SourceRange BodyRange; 357a355e07454463b19829ac92ffd115a097faff0e0John McCall if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange(); 3584365bba95be15342575b4f030c6583a770a5da3dAnders Carlsson 359a355e07454463b19829ac92ffd115a097faff0e0John McCall // Emit the standard function prologue. 360a355e07454463b19829ac92ffd115a097faff0e0John McCall StartFunction(GD, FD->getResultType(), Fn, Args, BodyRange.getBegin()); 3611851a12605bc6f1ea70d11974a315340ebaab6ebAnders Carlsson 362a355e07454463b19829ac92ffd115a097faff0e0John McCall // Generate the body of the function. 3639fc6a7774643a810c8501dae2323e863fefb623eJohn McCall if (isa<CXXDestructorDecl>(FD)) 3649fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitDestructorBody(Args); 3659fc6a7774643a810c8501dae2323e863fefb623eJohn McCall else if (isa<CXXConstructorDecl>(FD)) 3669fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitConstructorBody(Args); 3679fc6a7774643a810c8501dae2323e863fefb623eJohn McCall else 3689fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitFunctionBody(Args); 369c33e4ba20304e222692e77f2c6ad26a5d8d32f83Anders Carlsson 370a355e07454463b19829ac92ffd115a097faff0e0John McCall // Emit the standard function epilogue. 371a355e07454463b19829ac92ffd115a097faff0e0John McCall FinishFunction(BodyRange.getEnd()); 3725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3740946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// ContainsLabel - Return true if the statement contains a label in it. If 3750946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// this statement is not executed normally, it not containing a label means 3760946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// that we can just remove the code. 3770946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattnerbool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) { 3780946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // Null statement, not a label! 3790946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (S == 0) return false; 3801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3810946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a label, we have to emit the code, consider something like: 3820946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // if (0) { ... foo: bar(); } goto foo; 3830946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<LabelStmt>(S)) 3840946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 3851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3860946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a case/default statement, and we haven't seen a switch, we have 3870946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // to emit the code. 3880946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<SwitchCase>(S) && !IgnoreCaseStmts) 3890946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 3901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3910946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a switch statement, we want to ignore cases below it. 3920946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<SwitchStmt>(S)) 3930946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner IgnoreCaseStmts = true; 3941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3950946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // Scan subexpressions for verboten labels. 3960946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner for (Stmt::const_child_iterator I = S->child_begin(), E = S->child_end(); 3970946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner I != E; ++I) 3980946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (ContainsLabel(*I, IgnoreCaseStmts)) 3990946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 4001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4010946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return false; 4020946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner} 4030946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner 40431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 40531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// ConstantFoldsToSimpleInteger - If the sepcified expression does not fold to 40631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// a constant, or if it does but contains a label, return 0. If it constant 40731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// folds to 'true' and does not contain a label, return 1, if it constant folds 40831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// to 'false' and does not contain a label, return -1. 40931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattnerint CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond) { 41036bc14c3a1cf63ee306df5687ac8e85f924f8639Daniel Dunbar // FIXME: Rename and handle conversion of other evaluatable things 41136bc14c3a1cf63ee306df5687ac8e85f924f8639Daniel Dunbar // to bool. 41264712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson Expr::EvalResult Result; 4131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!Cond->Evaluate(Result, getContext()) || !Result.Val.isInt() || 41464712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson Result.HasSideEffects) 415ef5a66d8171eb95e948107f8ee7707b360aaff25Anders Carlsson return 0; // Not foldable, not integer or not fully evaluatable. 4161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 41731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (CodeGenFunction::ContainsLabel(Cond)) 41831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return 0; // Contains a label. 4191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 42064712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson return Result.Val.getInt().getBoolValue() ? 1 : -1; 42131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner} 42231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 42331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 42431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if 42531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// statement) to the specified blocks. Based on the condition, this might try 42631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// to simplify the codegen of the conditional based on the branch. 42731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// 42831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattnervoid CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond, 42931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::BasicBlock *TrueBlock, 43031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::BasicBlock *FalseBlock) { 43131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (const ParenExpr *PE = dyn_cast<ParenExpr>(Cond)) 43231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(PE->getSubExpr(), TrueBlock, FalseBlock); 4331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 43431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) { 43531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Handle X && Y in a condition. 43631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (CondBOp->getOpcode() == BinaryOperator::LAnd) { 43731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "1 && X", simplify the code. "0 && X" would have constant 43831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // folded if the case was simple enough. 43931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == 1) { 44031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(1 && X) -> br(X). 44131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 44231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 44431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "X && 1", simplify the code to use an uncond branch. 44531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // "X && 0" would have been constant folded to 0. 44631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == 1) { 44731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(X && 1) -> br(X). 44831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 44931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the LHS as a conditional. If the LHS conditional is false, we 45231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // want to jump to the FalseBlock. 4539615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true"); 45431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock); 45531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBlock(LHSTrue); 4561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45708e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson // Any temporaries created here are conditional. 45872119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson BeginConditionalBranch(); 45931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 46072119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson EndConditionalBranch(); 46108e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson 46231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return; 46331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } else if (CondBOp->getOpcode() == BinaryOperator::LOr) { 46431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "0 || X", simplify the code. "1 || X" would have constant 46531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // folded if the case was simple enough. 46631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == -1) { 46731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(0 || X) -> br(X). 46831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 46931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 47131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "X || 0", simplify the code to use an uncond branch. 47231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // "X || 1" would have been constant folded to 1. 47331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == -1) { 47431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(X || 0) -> br(X). 47531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 47631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 47831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the LHS as a conditional. If the LHS conditional is true, we 47931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // want to jump to the TrueBlock. 4809615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false"); 48131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse); 48231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBlock(LHSFalse); 4831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 48408e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson // Any temporaries created here are conditional. 48572119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson BeginConditionalBranch(); 48631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 48772119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson EndConditionalBranch(); 48808e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson 48931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return; 49031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 491552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner } 4921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 493552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) { 494552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner // br(!x, t, f) -> br(x, f, t) 495552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner if (CondUOp->getOpcode() == UnaryOperator::LNot) 496552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock); 49731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 49909b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) { 50009b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // Handle ?: operator. 50109b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar 50209b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // Just ignore GNU ?: extension. 50309b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar if (CondOp->getLHS()) { 50409b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f)) 50509b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true"); 50609b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false"); 50709b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock); 50809b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBlock(LHSBlock); 50909b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock); 51009b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBlock(RHSBlock); 51109b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock); 51209b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar return; 51309b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar } 51409b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar } 51509b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar 51631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the code with the fully general case. 51731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::Value *CondV = EvaluateExprAsBool(Cond); 51831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner Builder.CreateCondBr(CondV, TrueBlock, FalseBlock); 51931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner} 52031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 521488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar/// ErrorUnsupported - Print out an error that codegen doesn't support the 522dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner/// specified stmt yet. 52390df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbarvoid CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type, 52490df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar bool OmitOnError) { 52590df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar CGM.ErrorUnsupported(S, Type, OmitOnError); 526dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner} 527dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner 5281884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlssonvoid 5291884eb0b5c55edda4893ddec45e7dbad79758782Anders CarlssonCodeGenFunction::EmitNullInitialization(llvm::Value *DestPtr, QualType Ty) { 5301884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson // If the type contains a pointer to data member we can't memset it to zero. 5311884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson // Instead, create a null constant and copy it to the destination. 5321884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson if (CGM.getTypes().ContainsPointerToDataMember(Ty)) { 5331884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty); 5341884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson 5351884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson llvm::GlobalVariable *NullVariable = 5361884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(), 5371884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson /*isConstant=*/true, 5381884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson llvm::GlobalVariable::PrivateLinkage, 5391884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson NullConstant, llvm::Twine()); 5401884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson EmitAggregateCopy(DestPtr, NullVariable, Ty, /*isVolatile=*/false); 5411884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson return; 5421884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson } 5431884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson 5441884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson 5450d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson // Ignore empty classes in C++. 5460d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (getContext().getLangOptions().CPlusPlus) { 5470d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (const RecordType *RT = Ty->getAs<RecordType>()) { 5480d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty()) 5490d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson return; 5500d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson } 5510d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson } 5520d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson 5531884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson // Otherwise, just memset the whole thing to zero. This is legal 5541884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson // because in LLVM, all default initializers (other than the ones we just 5551884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlsson // handled above) are guaranteed to have a bit pattern of all zeros. 55636afd38fb749ab34c8341a1dc70366bca904eaa3Chris Lattner const llvm::Type *BP = llvm::Type::getInt8PtrTy(VMContext); 5573d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson if (DestPtr->getType() != BP) 5583d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp"); 5593d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 5603d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson // Get size and alignment info for this aggregate. 5613d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson std::pair<uint64_t, unsigned> TypeInfo = getContext().getTypeInfo(Ty); 5623d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 56388207c9ca218486b93ae7df14e9764cd0c2c3383Chris Lattner // Don't bother emitting a zero-byte memset. 56488207c9ca218486b93ae7df14e9764cd0c2c3383Chris Lattner if (TypeInfo.first == 0) 56588207c9ca218486b93ae7df14e9764cd0c2c3383Chris Lattner return; 5661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5673d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson // FIXME: Handle variable sized types. 56877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Builder.CreateCall5(CGM.getMemSetFn(BP, IntPtrTy), DestPtr, 5690032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::Constant::getNullValue(llvm::Type::getInt8Ty(VMContext)), 5703d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson // TypeInfo.first describes size in bits. 57177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::ConstantInt::get(IntPtrTy, TypeInfo.first/8), 57277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::ConstantInt::get(Int32Ty, TypeInfo.second/8), 5733ecd785aff34381f3704d9cb28fe3ef85af759deMon P Wang llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), 5743ecd785aff34381f3704d9cb28fe3ef85af759deMon P Wang 0)); 5753d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson} 5763d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 577d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattnerllvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelStmt *L) { 578d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Make sure that there is a block for the indirect goto. 579d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch == 0) 580d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner GetIndirectGotoBlock(); 5813d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 582ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock(); 5833d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 584d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Make sure the indirect branch includes all of the address-taken blocks. 585d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner IndirectBranch->addDestination(BB); 586d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return llvm::BlockAddress::get(CurFn, BB); 5873d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner} 5881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5893d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattnerllvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() { 590d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If we already made the indirect branch for indirect goto, return its block. 591d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) return IndirectBranch->getParent(); 5923d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 593d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner CGBuilderTy TmpBuilder(createBasicBlock("indirectgoto")); 5943d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 595d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(VMContext); 59685e74acfcfb0c835a2e6c1adab314e997917039aChris Lattner 5973d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner // Create the PHI node that indirect gotos will add entries to. 598d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, "indirect.goto.dest"); 5993d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 600d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Create the indirect branch instruction. 601d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal); 602d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return IndirectBranch->getParent(); 6030ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar} 604ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 605d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbarllvm::Value *CodeGenFunction::GetVLASize(const VariableArrayType *VAT) { 606bbed6b964414145b29e7b60b3e538093734ea3f8Eli Friedman llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()]; 6071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 608f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson assert(SizeEntry && "Did not emit size for type"); 609f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson return SizeEntry; 610f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson} 611dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson 612d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbarllvm::Value *CodeGenFunction::EmitVLASize(QualType Ty) { 61360d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson assert(Ty->isVariablyModifiedType() && 61460d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson "Must pass variably modified type to EmitVLASizes!"); 6151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 616d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbar EnsureInsertPoint(); 6171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 61860d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson if (const VariableArrayType *VAT = getContext().getAsVariableArrayType(Ty)) { 619bbed6b964414145b29e7b60b3e538093734ea3f8Eli Friedman llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()]; 6201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 621fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson if (!SizeEntry) { 62296f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson const llvm::Type *SizeTy = ConvertType(getContext().getSizeType()); 6231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 624ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner // Get the element size; 625ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner QualType ElemTy = VAT->getElementType(); 626ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner llvm::Value *ElemSize; 627fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson if (ElemTy->isVariableArrayType()) 628fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson ElemSize = EmitVLASize(ElemTy); 629ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner else 6304a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson ElemSize = llvm::ConstantInt::get(SizeTy, 631199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck getContext().getTypeSizeInChars(ElemTy).getQuantity()); 6321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 633fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson llvm::Value *NumElements = EmitScalarExpr(VAT->getSizeExpr()); 63496f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson NumElements = Builder.CreateIntCast(NumElements, SizeTy, false, "tmp"); 6351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 636fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson SizeEntry = Builder.CreateMul(ElemSize, NumElements); 637fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson } 6381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 63960d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson return SizeEntry; 640dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson } 6411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 642ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner if (const ArrayType *AT = dyn_cast<ArrayType>(Ty)) { 643ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner EmitVLASize(AT->getElementType()); 644ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner return 0; 6451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 6461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 647ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner const PointerType *PT = Ty->getAs<PointerType>(); 648ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner assert(PT && "unknown VM type!"); 649ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner EmitVLASize(PT->getPointeeType()); 65060d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson return 0; 651dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson} 6524fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman 6534fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedmanllvm::Value* CodeGenFunction::EmitVAListRef(const Expr* E) { 654fbe02ffb573ac2aa51351278af1c7970573b6ed5Chris Lattner if (CGM.getContext().getBuiltinVaListType()->isArrayType()) 6554fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman return EmitScalarExpr(E); 6564fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman return EmitLValue(E).getAddress(); 6574fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman} 6586ccc47698d0311ddabf32fa0f6db8e4f09ac96f8Anders Carlsson 659f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall/// Pops cleanup blocks until the given savepoint is reached. 660f1549f66a8216a78112286e3978cea2c29d6334cJohn McCallvoid CodeGenFunction::PopCleanupBlocks(EHScopeStack::stable_iterator Old) { 661f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall assert(Old.isValid()); 662f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 663ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall while (EHStack.stable_begin() != Old) { 664ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.begin()); 665ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 666ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // As long as Old strictly encloses the scope's enclosing normal 667ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // cleanup, we're going to emit another normal cleanup which 668ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // fallthrough can propagate through. 669ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall bool FallThroughIsBranchThrough = 670ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Old.strictlyEncloses(Scope.getEnclosingNormalCleanup()); 671ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 672ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall PopCleanupBlock(FallThroughIsBranchThrough); 673ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 6746ccc47698d0311ddabf32fa0f6db8e4f09ac96f8Anders Carlsson} 675c71c845fe77ee1f891d60232ec320912d88557eeAnders Carlsson 676ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallstatic llvm::BasicBlock *CreateNormalEntry(CodeGenFunction &CGF, 677ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHCleanupScope &Scope) { 678ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Scope.isNormalCleanup()); 679ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *Entry = Scope.getNormalBlock(); 680ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Entry) { 681ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Entry = CGF.createBasicBlock("cleanup"); 682ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.setNormalBlock(Entry); 683f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall } 684ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall return Entry; 685ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall} 686f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 687ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallstatic llvm::BasicBlock *CreateEHEntry(CodeGenFunction &CGF, 688ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHCleanupScope &Scope) { 689ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Scope.isEHCleanup()); 690ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *Entry = Scope.getEHBlock(); 691ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Entry) { 692ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Entry = CGF.createBasicBlock("eh.cleanup"); 693ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.setEHBlock(Entry); 694ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 695ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall return Entry; 696ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall} 697f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 698ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// Transitions the terminator of the given exit-block of a cleanup to 699ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// be a cleanup switch. 700ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallstatic llvm::SwitchInst *TransitionToCleanupSwitch(CodeGenFunction &CGF, 701ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *Block) { 702ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If it's a branch, turn it into a switch whose default 703ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // destination is its original target. 704ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::TerminatorInst *Term = Block->getTerminator(); 705ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Term && "can't transition block without terminator"); 706ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 707ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Term)) { 708ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Br->isUnconditional()); 709ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::LoadInst *Load = 710ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall new llvm::LoadInst(CGF.getNormalCleanupDestSlot(), "cleanup.dest", Term); 711ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SwitchInst *Switch = 712ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SwitchInst::Create(Load, Br->getSuccessor(0), 4, Block); 713ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Br->eraseFromParent(); 714ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall return Switch; 715ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } else { 716ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall return cast<llvm::SwitchInst>(Term); 717ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 718c71c845fe77ee1f891d60232ec320912d88557eeAnders Carlsson} 719c71c845fe77ee1f891d60232ec320912d88557eeAnders Carlsson 720f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall/// Attempts to reduce a cleanup's entry block to a fallthrough. This 721f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall/// is basically llvm::MergeBlockIntoPredecessor, except 722ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// simplified/optimized for the tighter constraints on cleanup blocks. 723ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// 724ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// Returns the new block, whatever it is. 725ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallstatic llvm::BasicBlock *SimplifyCleanupEntry(CodeGenFunction &CGF, 726ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *Entry) { 727f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall llvm::BasicBlock *Pred = Entry->getSinglePredecessor(); 728ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Pred) return Entry; 7291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 730f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Pred->getTerminator()); 731ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Br || Br->isConditional()) return Entry; 732f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall assert(Br->getSuccessor(0) == Entry); 7331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 734f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // If we were previously inserting at the end of the cleanup entry 735f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // block, we'll need to continue inserting at the end of the 736f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // predecessor. 737f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall bool WasInsertBlock = CGF.Builder.GetInsertBlock() == Entry; 738f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall assert(!WasInsertBlock || CGF.Builder.GetInsertPoint() == Entry->end()); 7391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 740f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // Kill the branch. 741f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall Br->eraseFromParent(); 7421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 743f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // Merge the blocks. 744f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall Pred->getInstList().splice(Pred->end(), Entry->getInstList()); 74599533834ba8f3658559f334e68a518ebb6388ceaMike Stump 746f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // Kill the entry block. 747f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall Entry->eraseFromParent(); 748d88ea5687968640ada2bc5a10211cbeb68a671ecMike Stump 749f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (WasInsertBlock) 750f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall CGF.Builder.SetInsertPoint(Pred); 751f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 752ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall return Pred; 753f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall} 754f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 7551f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCallstatic void EmitCleanup(CodeGenFunction &CGF, 7561f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall EHScopeStack::Cleanup *Fn, 7571f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall bool ForEH) { 758da65ea86482bc116906edfb9ba1d7124f76cc867John McCall if (ForEH) CGF.EHStack.pushTerminate(); 759da65ea86482bc116906edfb9ba1d7124f76cc867John McCall Fn->Emit(CGF, ForEH); 760da65ea86482bc116906edfb9ba1d7124f76cc867John McCall if (ForEH) CGF.EHStack.popTerminate(); 761da65ea86482bc116906edfb9ba1d7124f76cc867John McCall assert(CGF.HaveInsertPoint() && "cleanup ended with no insertion point?"); 762da65ea86482bc116906edfb9ba1d7124f76cc867John McCall} 763da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 7641f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall/// Pops a cleanup block. If the block includes a normal cleanup, the 7651f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall/// current insertion point is threaded through the cleanup, as are 7661f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall/// any branch fixups on the cleanup. 767ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallvoid CodeGenFunction::PopCleanupBlock(bool FallthroughIsBranchThrough) { 7681f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall assert(!EHStack.empty() && "cleanup stack is empty!"); 7691f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall assert(isa<EHCleanupScope>(*EHStack.begin()) && "top not a cleanup!"); 7701f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.begin()); 7711f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall assert(Scope.getFixupDepth() <= EHStack.getNumBranchFixups()); 772da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 773da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // Check whether we need an EH cleanup. This is only true if we've 774da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // generated a lazy EH cleanup block. 775ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall bool RequiresEHCleanup = Scope.hasEHBranches(); 776da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 777da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // Check the three conditions which might require a normal cleanup: 778da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 779da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // - whether there are branch fix-ups through this cleanup 780da65ea86482bc116906edfb9ba1d7124f76cc867John McCall unsigned FixupDepth = Scope.getFixupDepth(); 7811f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall bool HasFixups = EHStack.getNumBranchFixups() != FixupDepth; 782da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 783ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // - whether there are branch-throughs or branch-afters 784ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall bool HasExistingBranches = Scope.hasBranches(); 785da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 786da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // - whether there's a fallthrough 7871f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall llvm::BasicBlock *FallthroughSource = Builder.GetInsertBlock(); 788da65ea86482bc116906edfb9ba1d7124f76cc867John McCall bool HasFallthrough = (FallthroughSource != 0); 789da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 790da65ea86482bc116906edfb9ba1d7124f76cc867John McCall bool RequiresNormalCleanup = false; 791da65ea86482bc116906edfb9ba1d7124f76cc867John McCall if (Scope.isNormalCleanup() && 792da65ea86482bc116906edfb9ba1d7124f76cc867John McCall (HasFixups || HasExistingBranches || HasFallthrough)) { 793da65ea86482bc116906edfb9ba1d7124f76cc867John McCall RequiresNormalCleanup = true; 794da65ea86482bc116906edfb9ba1d7124f76cc867John McCall } 795da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 796da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // If we don't need the cleanup at all, we're done. 797da65ea86482bc116906edfb9ba1d7124f76cc867John McCall if (!RequiresNormalCleanup && !RequiresEHCleanup) { 798ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHStack.popCleanup(); // safe because there are no fixups 7991f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall assert(EHStack.getNumBranchFixups() == 0 || 8001f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall EHStack.hasNormalCleanups()); 801da65ea86482bc116906edfb9ba1d7124f76cc867John McCall return; 802da65ea86482bc116906edfb9ba1d7124f76cc867John McCall } 803da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 804da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // Copy the cleanup emission data out. Note that SmallVector 805da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // guarantees maximal alignment for its buffer regardless of its 806da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // type parameter. 807da65ea86482bc116906edfb9ba1d7124f76cc867John McCall llvm::SmallVector<char, 8*sizeof(void*)> CleanupBuffer; 808da65ea86482bc116906edfb9ba1d7124f76cc867John McCall CleanupBuffer.reserve(Scope.getCleanupSize()); 809da65ea86482bc116906edfb9ba1d7124f76cc867John McCall memcpy(CleanupBuffer.data(), 810da65ea86482bc116906edfb9ba1d7124f76cc867John McCall Scope.getCleanupBuffer(), Scope.getCleanupSize()); 811da65ea86482bc116906edfb9ba1d7124f76cc867John McCall CleanupBuffer.set_size(Scope.getCleanupSize()); 8121f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall EHScopeStack::Cleanup *Fn = 8131f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall reinterpret_cast<EHScopeStack::Cleanup*>(CleanupBuffer.data()); 814da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 815ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // We want to emit the EH cleanup after the normal cleanup, but go 816ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // ahead and do the setup for the EH cleanup while the scope is still 817ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // alive. 818ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *EHEntry = 0; 819ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SmallVector<llvm::Instruction*, 2> EHInstsToAppend; 820ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (RequiresEHCleanup) { 821ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHEntry = CreateEHEntry(*this, Scope); 822ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 823ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Figure out the branch-through dest if necessary. 824ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *EHBranchThroughDest = 0; 825ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (Scope.hasEHBranchThroughs()) { 826ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Scope.getEnclosingEHCleanup() != EHStack.stable_end()); 827ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHScope &S = *EHStack.find(Scope.getEnclosingEHCleanup()); 828ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHBranchThroughDest = CreateEHEntry(*this, cast<EHCleanupScope>(S)); 829ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 830ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 831ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If we have exactly one branch-after and no branch-throughs, we 832ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // can dispatch it without a switch. 8337cd4b060f1e59f6d29126383ceee614e4772f859John McCall if (!Scope.hasEHBranchThroughs() && 834ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.getNumEHBranchAfters() == 1) { 835ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(!EHBranchThroughDest); 836ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 837ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // TODO: remove the spurious eh.cleanup.dest stores if this edge 838ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // never went through any switches. 839ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *BranchAfterDest = Scope.getEHBranchAfterBlock(0); 840ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHInstsToAppend.push_back(llvm::BranchInst::Create(BranchAfterDest)); 841ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 842ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Otherwise, if we have any branch-afters, we need a switch. 843ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } else if (Scope.getNumEHBranchAfters()) { 844ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // The default of the switch belongs to the branch-throughs if 845ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // they exist. 846ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *Default = 847ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall (EHBranchThroughDest ? EHBranchThroughDest : getUnreachableBlock()); 848ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 849ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall const unsigned SwitchCapacity = Scope.getNumEHBranchAfters(); 850ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 851ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::LoadInst *Load = 852ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall new llvm::LoadInst(getEHCleanupDestSlot(), "cleanup.dest"); 853ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SwitchInst *Switch = 854ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SwitchInst::Create(Load, Default, SwitchCapacity); 855ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 856ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHInstsToAppend.push_back(Load); 857ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHInstsToAppend.push_back(Switch); 858ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 859ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (unsigned I = 0, E = Scope.getNumEHBranchAfters(); I != E; ++I) 860ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Switch->addCase(Scope.getEHBranchAfterIndex(I), 861ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.getEHBranchAfterBlock(I)); 862ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 863ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Otherwise, we have only branch-throughs; jump to the next EH 864ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // cleanup. 865ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } else { 866ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(EHBranchThroughDest); 867ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHInstsToAppend.push_back(llvm::BranchInst::Create(EHBranchThroughDest)); 868ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 869ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 870ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 871ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!RequiresNormalCleanup) { 872ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHStack.popCleanup(); 873ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } else { 874ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // As a kindof crazy internal case, branch-through fall-throughs 875ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // leave the insertion point set to the end of the last cleanup. 876ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall bool HasPrebranchedFallthrough = 877ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall (HasFallthrough && FallthroughSource->getTerminator()); 878ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(!HasPrebranchedFallthrough || 879ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall FallthroughSource->getTerminator()->getSuccessor(0) 880ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall == Scope.getNormalBlock()); 881da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 882da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // If we have a fallthrough and no other need for the cleanup, 883da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // emit it directly. 884ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (HasFallthrough && !HasPrebranchedFallthrough && 885ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall !HasFixups && !HasExistingBranches) { 886ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 887ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Fixups can cause us to optimistically create a normal block, 888ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // only to later have no real uses for it. Just delete it in 889ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // this case. 890ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // TODO: we can potentially simplify all the uses after this. 891ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (Scope.getNormalBlock()) { 892ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.getNormalBlock()->replaceAllUsesWith(getUnreachableBlock()); 893ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall delete Scope.getNormalBlock(); 894ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 895ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 896ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHStack.popCleanup(); 897ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 8981f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall EmitCleanup(*this, Fn, /*ForEH*/ false); 899da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 900da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // Otherwise, the best approach is to thread everything through 901da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // the cleanup block and then try to clean up after ourselves. 902da65ea86482bc116906edfb9ba1d7124f76cc867John McCall } else { 903da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // Force the entry block to exist. 904ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *NormalEntry = CreateNormalEntry(*this, Scope); 905da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 906ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If there's a fallthrough, we need to store the cleanup 907ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // destination index. For fall-throughs this is always zero. 908ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (HasFallthrough && !HasPrebranchedFallthrough) 909ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Builder.CreateStore(Builder.getInt32(0), getNormalCleanupDestSlot()); 910ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 911ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Emit the entry block. This implicitly branches to it if we 912ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // have fallthrough. All the fixups and existing branches should 913ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // already be branched to it. 9141f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall EmitBlock(NormalEntry); 915da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 916ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall bool HasEnclosingCleanups = 917ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall (Scope.getEnclosingNormalCleanup() != EHStack.stable_end()); 918ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 919ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Compute the branch-through dest if we need it: 920ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // - if there are branch-throughs threaded through the scope 921ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // - if fall-through is a branch-through 922ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // - if there are fixups that will be optimistically forwarded 923ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // to the enclosing cleanup 924ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *BranchThroughDest = 0; 925ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (Scope.hasBranchThroughs() || 926ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall (HasFallthrough && FallthroughIsBranchThrough) || 927ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall (HasFixups && HasEnclosingCleanups)) { 928ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(HasEnclosingCleanups); 929ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHScope &S = *EHStack.find(Scope.getEnclosingNormalCleanup()); 930ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BranchThroughDest = CreateNormalEntry(*this, cast<EHCleanupScope>(S)); 931da65ea86482bc116906edfb9ba1d7124f76cc867John McCall } 932da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 933ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *FallthroughDest = 0; 934ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SmallVector<llvm::Instruction*, 2> InstsToAppend; 935ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 936ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If there's exactly one branch-after and no other threads, 937ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // we can route it without a switch. 938ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Scope.hasBranchThroughs() && !HasFixups && !HasFallthrough && 939ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.getNumBranchAfters() == 1) { 940ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(!BranchThroughDest); 941ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 942ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // TODO: clean up the possibly dead stores to the cleanup dest slot. 943ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *BranchAfter = Scope.getBranchAfterBlock(0); 944ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall InstsToAppend.push_back(llvm::BranchInst::Create(BranchAfter)); 945ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 946ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Build a switch-out if we need it: 947ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // - if there are branch-afters threaded through the scope 948ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // - if fall-through is a branch-after 949ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // - if there are fixups that have nowhere left to go and 950ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // so must be immediately resolved 951ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } else if (Scope.getNumBranchAfters() || 952ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall (HasFallthrough && !FallthroughIsBranchThrough) || 953ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall (HasFixups && !HasEnclosingCleanups)) { 954ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 955ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *Default = 956ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall (BranchThroughDest ? BranchThroughDest : getUnreachableBlock()); 957ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 958ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // TODO: base this on the number of branch-afters and fixups 959ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall const unsigned SwitchCapacity = 10; 960ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 961ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::LoadInst *Load = 962ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall new llvm::LoadInst(getNormalCleanupDestSlot(), "cleanup.dest"); 963ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SwitchInst *Switch = 964ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SwitchInst::Create(Load, Default, SwitchCapacity); 965ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 966ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall InstsToAppend.push_back(Load); 967ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall InstsToAppend.push_back(Switch); 968ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 969ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Branch-after fallthrough. 970ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (HasFallthrough && !FallthroughIsBranchThrough) { 971ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall FallthroughDest = createBasicBlock("cleanup.cont"); 972ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Switch->addCase(Builder.getInt32(0), FallthroughDest); 973ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 974ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 975ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (unsigned I = 0, E = Scope.getNumBranchAfters(); I != E; ++I) { 976ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Switch->addCase(Scope.getBranchAfterIndex(I), 977ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.getBranchAfterBlock(I)); 978ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 979ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 980ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (HasFixups && !HasEnclosingCleanups) 981ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall ResolveAllBranchFixups(Switch); 982ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } else { 983ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // We should always have a branch-through destination in this case. 984ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(BranchThroughDest); 985ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall InstsToAppend.push_back(llvm::BranchInst::Create(BranchThroughDest)); 986ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 987da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 988ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // We're finally ready to pop the cleanup. 989ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHStack.popCleanup(); 990ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(EHStack.hasNormalCleanups() == HasEnclosingCleanups); 991da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 992ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitCleanup(*this, Fn, /*ForEH*/ false); 993ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 994ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Append the prepared cleanup prologue from above. 995ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *NormalExit = Builder.GetInsertBlock(); 996ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (unsigned I = 0, E = InstsToAppend.size(); I != E; ++I) 997ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall NormalExit->getInstList().push_back(InstsToAppend[I]); 998ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 999ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Optimistically hope that any fixups will continue falling through. 1000ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (unsigned I = FixupDepth, E = EHStack.getNumBranchFixups(); 1001ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall I < E; ++I) { 1002ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BranchFixup &Fixup = CGF.EHStack.getBranchFixup(I); 1003ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Fixup.Destination) continue; 1004ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Fixup.OptimisticBranchBlock) { 1005ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall new llvm::StoreInst(Builder.getInt32(Fixup.DestinationIndex), 1006ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall getNormalCleanupDestSlot(), 1007ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.InitialBranch); 1008ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.InitialBranch->setSuccessor(0, NormalEntry); 1009ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 1010ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.OptimisticBranchBlock = NormalExit; 1011ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 1012ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1013ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (FallthroughDest) 1014ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitBlock(FallthroughDest); 1015ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall else if (!HasFallthrough) 1016ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Builder.ClearInsertionPoint(); 1017ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1018ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Check whether we can merge NormalEntry into a single predecessor. 1019ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // This might invalidate (non-IR) pointers to NormalEntry. 1020ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *NewNormalEntry = 1021ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall SimplifyCleanupEntry(*this, NormalEntry); 1022ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1023ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If it did invalidate those pointers, and NormalEntry was the same 1024ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // as NormalExit, go back and patch up the fixups. 1025ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (NewNormalEntry != NormalEntry && NormalEntry == NormalExit) 1026ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (unsigned I = FixupDepth, E = EHStack.getNumBranchFixups(); 1027ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall I < E; ++I) 1028ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall CGF.EHStack.getBranchFixup(I).OptimisticBranchBlock = NewNormalEntry; 1029da65ea86482bc116906edfb9ba1d7124f76cc867John McCall } 1030da65ea86482bc116906edfb9ba1d7124f76cc867John McCall } 1031da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 1032ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(EHStack.hasNormalCleanups() || EHStack.getNumBranchFixups() == 0); 1033ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1034da65ea86482bc116906edfb9ba1d7124f76cc867John McCall // Emit the EH cleanup if required. 1035da65ea86482bc116906edfb9ba1d7124f76cc867John McCall if (RequiresEHCleanup) { 10361f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP(); 1037ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 10381f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall EmitBlock(EHEntry); 1039ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitCleanup(*this, Fn, /*ForEH*/ true); 1040ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1041ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Append the prepared cleanup prologue from above. 1042ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *EHExit = Builder.GetInsertBlock(); 1043ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (unsigned I = 0, E = EHInstsToAppend.size(); I != E; ++I) 1044ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHExit->getInstList().push_back(EHInstsToAppend[I]); 1045ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 10461f0fca54676cfa8616e7f3cd7a26788ab937e3cdJohn McCall Builder.restoreIP(SavedIP); 1047ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1048ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall SimplifyCleanupEntry(*this, EHEntry); 1049da65ea86482bc116906edfb9ba1d7124f76cc867John McCall } 1050da65ea86482bc116906edfb9ba1d7124f76cc867John McCall} 1051da65ea86482bc116906edfb9ba1d7124f76cc867John McCall 1052ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// Terminate the current block by emitting a branch which might leave 1053ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// the current cleanup-protected scope. The target scope may not yet 1054ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// be known, in which case this will require a fixup. 1055ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// 1056ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// As a side-effect, this method clears the insertion point. 1057f1549f66a8216a78112286e3978cea2c29d6334cJohn McCallvoid CodeGenFunction::EmitBranchThroughCleanup(JumpDest Dest) { 105846831a93e1805ddaebd68f37cdb5496a86b44cf0Anders Carlsson if (!HaveInsertPoint()) 105946831a93e1805ddaebd68f37cdb5496a86b44cf0Anders Carlsson return; 10601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1061f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // Create the branch. 1062ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BranchInst *BI = Builder.CreateBr(Dest.getBlock()); 10631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1064ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If we're not in a cleanup scope, or if the destination scope is 1065ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // the current normal-cleanup scope, we don't need to worry about 1066f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // fixups. 1067ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!EHStack.hasNormalCleanups() || 1068ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Dest.getScopeDepth() == EHStack.getInnermostNormalCleanup()) { 1069f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall Builder.ClearInsertionPoint(); 107087eaf17cc88516277e4389dfa15df93ecfdce559Anders Carlsson return; 1071f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall } 10721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1073f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // If we can't resolve the destination cleanup scope, just add this 1074ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // to the current cleanup scope as a branch fixup. 1075ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Dest.getScopeDepth().isValid()) { 1076ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BranchFixup &Fixup = EHStack.addBranchFixup(); 1077ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.Destination = Dest.getBlock(); 1078ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.DestinationIndex = Dest.getDestIndex(); 1079ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.InitialBranch = BI; 1080ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.OptimisticBranchBlock = 0; 1081ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1082f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall Builder.ClearInsertionPoint(); 108387eaf17cc88516277e4389dfa15df93ecfdce559Anders Carlsson return; 108487eaf17cc88516277e4389dfa15df93ecfdce559Anders Carlsson } 10851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1086ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Otherwise, thread through all the normal cleanups in scope. 1087ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1088ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Store the index at the start. 1089ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::ConstantInt *Index = Builder.getInt32(Dest.getDestIndex()); 1090ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall new llvm::StoreInst(Index, getNormalCleanupDestSlot(), BI); 1091ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1092ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Adjust BI to point to the first cleanup block. 1093ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall { 1094ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHCleanupScope &Scope = 1095ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall cast<EHCleanupScope>(*EHStack.find(EHStack.getInnermostNormalCleanup())); 1096ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BI->setSuccessor(0, CreateNormalEntry(*this, Scope)); 1097ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 1098ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1099ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Add this destination to all the scopes involved. 1100ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHScopeStack::stable_iterator I = EHStack.getInnermostNormalCleanup(); 1101ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHScopeStack::stable_iterator E = Dest.getScopeDepth(); 1102ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (E.strictlyEncloses(I)) { 1103ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall while (true) { 1104ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.find(I)); 1105ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Scope.isNormalCleanup()); 1106ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall I = Scope.getEnclosingNormalCleanup(); 1107ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1108ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If this is the last cleanup we're propagating through, tell it 1109ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // that there's a resolved jump moving through it. 1110ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!E.strictlyEncloses(I)) { 1111ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.addBranchAfter(Index, Dest.getBlock()); 1112ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall break; 1113da65ea86482bc116906edfb9ba1d7124f76cc867John McCall } 1114ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1115ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Otherwise, tell the scope that there's a jump propoagating 1116ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // through it. If this isn't new information, all the rest of 1117ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // the work has been done before. 1118ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Scope.addBranchThrough(Dest.getBlock())) 1119ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall break; 1120f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall } 112187eaf17cc88516277e4389dfa15df93ecfdce559Anders Carlsson } 1122f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 1123f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall Builder.ClearInsertionPoint(); 1124f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall} 11251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1126ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallvoid CodeGenFunction::EmitBranchThroughEHCleanup(UnwindDest Dest) { 1127ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // We should never get invalid scope depths for an UnwindDest; that 1128ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // implies that the destination wasn't set up correctly. 1129ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Dest.getScopeDepth().isValid() && "invalid scope depth on EH dest?"); 1130ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1131f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (!HaveInsertPoint()) 1132f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall return; 11331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1134f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall // Create the branch. 1135ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BranchInst *BI = Builder.CreateBr(Dest.getBlock()); 1136f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 1137ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If the destination is in the same EH cleanup scope as us, we 1138ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // don't need to thread through anything. 1139ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (Dest.getScopeDepth() == EHStack.getInnermostEHCleanup()) { 1140f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall Builder.ClearInsertionPoint(); 114187eaf17cc88516277e4389dfa15df93ecfdce559Anders Carlsson return; 114287eaf17cc88516277e4389dfa15df93ecfdce559Anders Carlsson } 1143ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(EHStack.hasEHCleanups()); 11441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1145ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Store the index at the start. 1146ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::ConstantInt *Index = Builder.getInt32(Dest.getDestIndex()); 1147ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall new llvm::StoreInst(Index, getEHCleanupDestSlot(), BI); 1148ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1149ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Adjust BI to point to the first cleanup block. 1150ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall { 1151ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHCleanupScope &Scope = 1152ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall cast<EHCleanupScope>(*EHStack.find(EHStack.getInnermostEHCleanup())); 1153ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BI->setSuccessor(0, CreateEHEntry(*this, Scope)); 1154ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 1155ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1156ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Add this destination to all the scopes involved. 1157ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (EHScopeStack::stable_iterator 1158ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall I = EHStack.getInnermostEHCleanup(), 1159ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall E = Dest.getScopeDepth(); ; ) { 1160ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(E.strictlyEncloses(I)); 1161ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.find(I)); 1162ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Scope.isEHCleanup()); 1163ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall I = Scope.getEnclosingEHCleanup(); 1164ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1165ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If this is the last cleanup we're propagating through, add this 1166ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // as a branch-after. 1167ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (I == E) { 1168ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Scope.addEHBranchAfter(Index, Dest.getBlock()); 1169ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall break; 1170f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall } 1171ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1172ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Otherwise, add it as a branch-through. If this isn't new 1173ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // information, all the rest of the work has been done before. 1174ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!Scope.addEHBranchThrough(Dest.getBlock())) 1175ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall break; 1176f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall } 1177f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 1178f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall Builder.ClearInsertionPoint(); 117987eaf17cc88516277e4389dfa15df93ecfdce559Anders Carlsson} 1180ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1181ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// All the branch fixups on the EH stack have propagated out past the 1182ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// outermost normal cleanup; resolve them all by adding cases to the 1183ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall/// given switch instruction. 1184ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallvoid CodeGenFunction::ResolveAllBranchFixups(llvm::SwitchInst *Switch) { 1185ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SmallPtrSet<llvm::BasicBlock*, 4> CasesAdded; 1186ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1187ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (unsigned I = 0, E = EHStack.getNumBranchFixups(); I != E; ++I) { 1188ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Skip this fixup if its destination isn't set or if we've 1189ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // already treated it. 1190ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BranchFixup &Fixup = EHStack.getBranchFixup(I); 1191ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (Fixup.Destination == 0) continue; 1192ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!CasesAdded.insert(Fixup.Destination)) continue; 1193ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1194ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Switch->addCase(Builder.getInt32(Fixup.DestinationIndex), 1195ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.Destination); 1196ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 1197ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1198ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHStack.clearFixups(); 1199ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall} 1200ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1201ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallvoid CodeGenFunction::ResolveBranchFixups(llvm::BasicBlock *Block) { 1202ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(Block && "resolving a null target block"); 1203ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!EHStack.getNumBranchFixups()) return; 1204ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1205ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall assert(EHStack.hasNormalCleanups() && 1206ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall "branch fixups exist with no normal cleanups on stack"); 1207ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1208ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SmallPtrSet<llvm::BasicBlock*, 4> ModifiedOptimisticBlocks; 1209ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall bool ResolvedAny = false; 1210ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1211ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall for (unsigned I = 0, E = EHStack.getNumBranchFixups(); I != E; ++I) { 1212ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Skip this fixup if its destination doesn't match. 1213ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BranchFixup &Fixup = EHStack.getBranchFixup(I); 1214ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (Fixup.Destination != Block) continue; 1215ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1216ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Fixup.Destination = 0; 1217ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall ResolvedAny = true; 1218ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1219ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // If it doesn't have an optimistic branch block, LatestBranch is 1220ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // already pointing to the right place. 1221ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *BranchBB = Fixup.OptimisticBranchBlock; 1222ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!BranchBB) 1223ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall continue; 1224ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1225ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Don't process the same optimistic branch block twice. 1226ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!ModifiedOptimisticBlocks.insert(BranchBB)) 1227ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall continue; 1228ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1229ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::SwitchInst *Switch = TransitionToCleanupSwitch(*this, BranchBB); 1230ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1231ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall // Add a case to the switch. 1232ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall Switch->addCase(Builder.getInt32(Fixup.DestinationIndex), Block); 1233ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall } 1234ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1235ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (ResolvedAny) 1236ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHStack.popNullFixups(); 1237ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall} 1238ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1239ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallllvm::Value *CodeGenFunction::getNormalCleanupDestSlot() { 1240ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!NormalCleanupDest) 1241ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall NormalCleanupDest = 1242ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall CreateTempAlloca(Builder.getInt32Ty(), "cleanup.dest.slot"); 1243ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall return NormalCleanupDest; 1244ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall} 1245ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall 1246ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCallllvm::Value *CodeGenFunction::getEHCleanupDestSlot() { 1247ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (!EHCleanupDest) 1248ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EHCleanupDest = 1249ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall CreateTempAlloca(Builder.getInt32Ty(), "eh.cleanup.dest.slot"); 1250ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall return EHCleanupDest; 1251ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall} 1252