CodeGenFunction.cpp revision 7502c1d3ce8bb97bcc4f7bebef507040bd93b26f
15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- CodeGenFunction.cpp - Emit LLVM Code from ASTs for a Function ----===// 25f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 35f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// The LLVM Compiler Infrastructure 45f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 75f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 85f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 95f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// This coordinates the per-function state used while generating code. 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "CodeGenFunction.h" 155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "CodeGenModule.h" 164c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall#include "CGCXXABI.h" 173f2af1002249c8acc9ce17f1fc50324864feb8e1Eli Friedman#include "CGDebugInfo.h" 18f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall#include "CGException.h" 195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Basic/TargetInfo.h" 2031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner#include "clang/AST/APValue.h" 21de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 22c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/Decl.h" 232b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson#include "clang/AST/DeclCXX.h" 246a1e0eb557d47e85185e09bdf8721f53f4bf9c9cMike Stump#include "clang/AST/StmtCXX.h" 257255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner#include "clang/Frontend/CodeGenOptions.h" 264e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump#include "llvm/Target/TargetData.h" 277255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner#include "llvm/Intrinsics.h" 285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace CodeGen; 305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 311eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpCodeGenFunction::CodeGenFunction(CodeGenModule &cgm) 32d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall : CGM(cgm), Target(CGM.getContext().Target), 33aac8705c046f01a264a4f82832895a5d9e695633Owen Anderson Builder(cgm.getModule().getContext()), 34d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall BlockInfo(0), BlockPointer(0), 35ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall NormalCleanupDest(0), EHCleanupDest(0), NextCleanupDestIndex(1), 36f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall ExceptionSlot(0), DebugInfo(0), IndirectBranch(0), 37ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall SwitchInsn(0), CaseRangeBlock(0), 38f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall DidCallStackSave(false), UnreachableBlock(0), 392504941793b549323f9d29c62507cf21d865fadeJohn McCall CXXThisDecl(0), CXXThisValue(0), CXXVTTDecl(0), CXXVTTValue(0), 40150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall OutermostConditional(0), TerminateLandingPad(0), TerminateHandler(0), 4183252dcfe61aaebcb6bc117e71dc12968729513fChris Lattner TrapBB(0) { 4277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner 4377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner // Get some frequently used types. 444e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump LLVMPointerWidth = Target.getPointerWidth(0); 4577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::LLVMContext &LLVMContext = CGM.getLLVMContext(); 4677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner IntPtrTy = llvm::IntegerType::get(LLVMContext, LLVMPointerWidth); 4777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Int32Ty = llvm::Type::getInt32Ty(LLVMContext); 4877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Int64Ty = llvm::Type::getInt64Ty(LLVMContext); 49d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall Int8PtrTy = cgm.Int8PtrTy; 5077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner 51d88ea5687968640ada2bc5a10211cbeb68a671ecMike Stump Exceptions = getContext().getLangOptions().Exceptions; 529c276ae0f24d4cee8f7954069d4b8eae45d0447dMike Stump CatchUndefined = getContext().getLangOptions().CatchUndefined; 534c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().getMangleContext().startNewFunction(); 544111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner} 555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerASTContext &CodeGenFunction::getContext() const { 575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return CGM.getContext(); 585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 618b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbarconst llvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) { 628b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar return CGM.getTypes().ConvertTypeForMem(T); 638b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar} 648b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar 655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst llvm::Type *CodeGenFunction::ConvertType(QualType T) { 665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return CGM.getTypes().ConvertType(T); 675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 694111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattnerbool CodeGenFunction::hasAggregateLLVMType(QualType T) { 70e9d34dc7afe06c9adaacad7a678a0cbbf749ea75Anders Carlsson return T->isRecordType() || T->isArrayType() || T->isAnyComplexType() || 71d608cdb7c044365cf4e8764ade1e11e99c176078John McCall T->isObjCObjectType(); 724111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner} 73391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 741c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbarvoid CodeGenFunction::EmitReturnBlock() { 751c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // For cleanliness, we try to avoid emitting the return block for 761c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // simple cases. 771c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); 781c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 791c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar if (CurBB) { 801c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar assert(!CurBB->getTerminator() && "Unexpected terminated block."); 811c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 8296e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar // We have a valid insert point, reuse it if it is empty or there are no 8396e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar // explicit jumps to the return block. 84ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) { 85ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall ReturnBlock.getBlock()->replaceAllUsesWith(CurBB); 86ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall delete ReturnBlock.getBlock(); 8796e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar } else 88ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitBlock(ReturnBlock.getBlock()); 891c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar return; 901c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 911c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 921c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // Otherwise, if the return block is the target of a single direct 931c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // branch then we can just put the code in that block instead. This 941c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // cleans up functions which started with a unified return block. 95ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (ReturnBlock.getBlock()->hasOneUse()) { 961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump llvm::BranchInst *BI = 97ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->use_begin()); 98f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (BI && BI->isUnconditional() && 99ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BI->getSuccessor(0) == ReturnBlock.getBlock()) { 1001c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // Reset insertion point and delete the branch. 1011c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar Builder.SetInsertPoint(BI->getParent()); 1021c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar BI->eraseFromParent(); 103ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall delete ReturnBlock.getBlock(); 1041c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar return; 1051c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 1061c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 1071c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 108f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // FIXME: We are at an unreachable point, there is no reason to emit the block 109f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // unless it has uses. However, we still need a place to put the debug 110f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // region.end for now. 1111c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 112ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitBlock(ReturnBlock.getBlock()); 113f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall} 114f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 115f1549f66a8216a78112286e3978cea2c29d6334cJohn McCallstatic void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) { 116f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (!BB) return; 117f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (!BB->use_empty()) 118f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall return CGF.CurFn->getBasicBlockList().push_back(BB); 119f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall delete BB; 1201c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar} 1211c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 122af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbarvoid CodeGenFunction::FinishFunction(SourceLocation EndLoc) { 123391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner assert(BreakContinueStack.empty() && 124391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner "mismatched push/pop in break/continue stack!"); 1251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Emit function epilog (to return). 1271c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar EmitReturnBlock(); 128f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar 129a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar if (ShouldInstrumentFunction()) 130a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar EmitFunctionInstrumentation("__cyg_profile_func_exit"); 1317255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 132f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar // Emit debug descriptor for function end. 133e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson if (CGDebugInfo *DI = getDebugInfo()) { 134f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar DI->setLocation(EndLoc); 1355a6fbcfd8c15a2296f94a0473a68ec09d429827fDevang Patel DI->EmitFunctionEnd(Builder); 136f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar } 137f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar 13835b21b884e5c3447a52a74d7ffaba966b07ac81fChris Lattner EmitFunctionEpilog(*CurFnInfo); 139cce3d4f9812182ed4e551b7cf0fc86576be8d9c5Mike Stump EmitEndEHSpec(CurCodeDecl); 1405ca2084cf9b529563209429857f01fdae9dcdfa5Daniel Dunbar 141f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall assert(EHStack.empty() && 142f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall "did not remove all scopes from cleanup stack!"); 143f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 144d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If someone did an indirect goto, emit the indirect goto block at the end of 145d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // the function. 146d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) { 147d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner EmitBlock(IndirectBranch->getParent()); 148d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner Builder.ClearInsertionPoint(); 149d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 150d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner 151391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // Remove the AllocaInsertPt instruction, which is just a convenience for us. 152481769b5dc102b0256b35581e787909ad5edfab5Chris Lattner llvm::Instruction *Ptr = AllocaInsertPt; 153391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner AllocaInsertPt = 0; 154481769b5dc102b0256b35581e787909ad5edfab5Chris Lattner Ptr->eraseFromParent(); 155d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner 156d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If someone took the address of a label but never did an indirect goto, we 157d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // made a zero entry PHI node, which is illegal, zap it now. 158d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) { 159d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress()); 160d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (PN->getNumIncomingValues() == 0) { 161d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType())); 162d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner PN->eraseFromParent(); 163d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 164d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 165f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 166ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitIfUsed(*this, RethrowBlock.getBlock()); 167f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, TerminateLandingPad); 168f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, TerminateHandler); 169f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, UnreachableBlock); 170744016dde06fcffd50931e94a98c850f8b12cd87John McCall 171744016dde06fcffd50931e94a98c850f8b12cd87John McCall if (CGM.getCodeGenOpts().EmitDeclMetadata) 172744016dde06fcffd50931e94a98c850f8b12cd87John McCall EmitDeclMetadata(); 173c8aa5f1f264fb230c38182adab944232bb160c2bChris Lattner} 174c8aa5f1f264fb230c38182adab944232bb160c2bChris Lattner 1757255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// ShouldInstrumentFunction - Return true if the current function should be 1767255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// instrumented with __cyg_profile_func_* calls 1777255a2d997b15beae82e627052fdb1b2474495c2Chris Lattnerbool CodeGenFunction::ShouldInstrumentFunction() { 1787255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner if (!CGM.getCodeGenOpts().InstrumentFunctions) 1797255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return false; 1807255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner if (CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>()) 1817255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return false; 1827255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return true; 1837255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner} 1847255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 1857255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// EmitFunctionInstrumentation - Emit LLVM code to call the specified 1867255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// instrumentation function with the current function and the call site, if 1877255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// function instrumentation is enabled. 1887255a2d997b15beae82e627052fdb1b2474495c2Chris Lattnervoid CodeGenFunction::EmitFunctionInstrumentation(const char *Fn) { 1898dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner const llvm::PointerType *PointerTy; 1907255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner const llvm::FunctionType *FunctionTy; 1917255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner std::vector<const llvm::Type*> ProfileFuncArgs; 1927255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 1938dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner // void __cyg_profile_func_{enter,exit} (void *this_fn, void *call_site); 194d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall PointerTy = Int8PtrTy; 1958dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner ProfileFuncArgs.push_back(PointerTy); 1968dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner ProfileFuncArgs.push_back(PointerTy); 197d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall FunctionTy = llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()), 198d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall ProfileFuncArgs, false); 1997255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 2007255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner llvm::Constant *F = CGM.CreateRuntimeFunction(FunctionTy, Fn); 2017255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner llvm::CallInst *CallSite = Builder.CreateCall( 2027255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner CGM.getIntrinsic(llvm::Intrinsic::returnaddress, 0, 0), 20377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::ConstantInt::get(Int32Ty, 0), 2047255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner "callsite"); 2057255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 2068dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner Builder.CreateCall2(F, 2078dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner llvm::ConstantExpr::getBitCast(CurFn, PointerTy), 2088dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner CallSite); 2097255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner} 2107255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 211be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divackyvoid CodeGenFunction::EmitMCountInstrumentation() { 212be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky llvm::FunctionType *FTy = 213be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()), false); 214be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky 215be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky llvm::Constant *MCountFn = CGM.CreateRuntimeFunction(FTy, 216be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky Target.getMCountName()); 217be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky Builder.CreateCall(MCountFn); 218be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky} 219be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky 2200ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlssonvoid CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy, 2217c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar llvm::Function *Fn, 2222284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar const FunctionArgList &Args, 2232284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar SourceLocation StartLoc) { 2240ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson const Decl *D = GD.getDecl(); 2250ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson 2264cc1a4703363ff940b6273aeef9d96a87edeb04bAnders Carlsson DidCallStackSave = false; 227b5437d238752dc297e42410e98d38d5250fe0463Chris Lattner CurCodeDecl = CurFuncDecl = D; 2287c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FnRetTy = RetTy; 229bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar CurFn = Fn; 2305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(CurFn->isDeclaration() && "Function already has body?"); 231ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner 232a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen // Pass inline keyword to optimizer if it appears explicitly on any 233a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen // declaration. 234a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) 235a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen for (FunctionDecl::redecl_iterator RI = FD->redecls_begin(), 236a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen RE = FD->redecls_end(); RI != RE; ++RI) 237a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen if (RI->isInlineSpecified()) { 238a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen Fn->addFnAttr(llvm::Attribute::InlineHint); 239a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen break; 240a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen } 241a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen 24255e874299f2ad827646a4ca9ea38c402aaeb38c9Daniel Dunbar llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn); 2435ca2084cf9b529563209429857f01fdae9dcdfa5Daniel Dunbar 2445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Create a marker to make it easy to insert allocas into the entryblock 24555352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner // later. Don't create this with the builder, because we don't want it 24655352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner // folded. 24777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Value *Undef = llvm::UndefValue::get(Int32Ty); 24877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "", EntryBB); 249f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner if (Builder.isNamePreserving()) 250f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner AllocaInsertPt->setName("allocapt"); 2511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 252f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall ReturnBlock = getJumpDestInCurrentScope("return"); 2531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 25455352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner Builder.SetInsertPoint(EntryBB); 2551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 256af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta // Emit subprogram debug descriptor. 257e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson if (CGDebugInfo *DI = getDebugInfo()) { 258e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall // FIXME: what is going on here and why does it ignore all these 259e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall // interesting type properties? 260e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall QualType FnType = 261e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall getContext().getFunctionType(RetTy, 0, 0, 262e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo()); 263e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 2642284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar DI->setLocation(StartLoc); 2659c6c3a0e3ae09626d2d4b04e4ffa42c3d7cab32bDevang Patel DI->EmitFunctionStart(GD, FnType, CurFn, Builder); 266af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta } 267af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta 268a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar if (ShouldInstrumentFunction()) 269a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar EmitFunctionInstrumentation("__cyg_profile_func_enter"); 2707255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 271be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky if (CGM.getCodeGenOpts().InstrumentForProfiling) 272be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky EmitMCountInstrumentation(); 273be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky 27488b5396b0897f28d22ae3debf4a0d97b33b6c362Daniel Dunbar // FIXME: Leaked. 27504a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // CC info is ignored, hopefully? 27604a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall CurFnInfo = &CGM.getTypes().getFunctionInfo(FnRetTy, Args, 277264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo()); 278b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman 279b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman if (RetTy->isVoidType()) { 280b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman // Void type; nothing to return. 281b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman ReturnValue = 0; 282b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect && 283b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman hasAggregateLLVMType(CurFnInfo->getReturnType())) { 284b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman // Indirect aggregate return; emit returned value directly into sret slot. 285647a1ec397fa13af176d07d9f5d071560a94c7a9Daniel Dunbar // This reduces code size, and affects correctness in C++. 286b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman ReturnValue = CurFn->arg_begin(); 287b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } else { 288647a1ec397fa13af176d07d9f5d071560a94c7a9Daniel Dunbar ReturnValue = CreateIRTemp(RetTy, "retval"); 289b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } 290b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman 291cce3d4f9812182ed4e551b7cf0fc86576be8d9c5Mike Stump EmitStartEHSpec(CurCodeDecl); 29288b5396b0897f28d22ae3debf4a0d97b33b6c362Daniel Dunbar EmitFunctionProlog(*CurFnInfo, CurFn, Args); 2931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2944c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) 2954c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().EmitInstanceFunctionProlog(*this); 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 31439dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// Tries to mark the given function nounwind based on the 31539dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// non-existence of any throwing calls within it. We believe this is 31639dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// lightweight enough to do at -O0. 31739dad53772c42eb36ebec1c81c56ba99d038fb94John McCallstatic void TryMarkNoThrow(llvm::Function *F) { 318b3a29f132794f67108bccc9c7cc3795365e8a965John McCall // LLVM treats 'nounwind' on a function as part of the type, so we 319b3a29f132794f67108bccc9c7cc3795365e8a965John McCall // can't do this on functions that can be overwritten. 320b3a29f132794f67108bccc9c7cc3795365e8a965John McCall if (F->mayBeOverridden()) return; 321b3a29f132794f67108bccc9c7cc3795365e8a965John McCall 32239dad53772c42eb36ebec1c81c56ba99d038fb94John McCall for (llvm::Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI) 32339dad53772c42eb36ebec1c81c56ba99d038fb94John McCall for (llvm::BasicBlock::iterator 32439dad53772c42eb36ebec1c81c56ba99d038fb94John McCall BI = FI->begin(), BE = FI->end(); BI != BE; ++BI) 32539dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(&*BI)) 32639dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (!Call->doesNotThrow()) 32739dad53772c42eb36ebec1c81c56ba99d038fb94John McCall return; 32839dad53772c42eb36ebec1c81c56ba99d038fb94John McCall F->setDoesNotThrow(true); 32939dad53772c42eb36ebec1c81c56ba99d038fb94John McCall} 33039dad53772c42eb36ebec1c81c56ba99d038fb94John McCall 331c997d4278d329e18891aac9698fb991b2d4622ebAnders Carlssonvoid CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn) { 3320ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 3330ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson 334e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson // Check if we should generate debug info for this function. 3351feade8e520be483293dbf55eb57a51720899589Mike Stump if (CGM.getDebugInfo() && !FD->hasAttr<NoDebugAttr>()) 336e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson DebugInfo = CGM.getDebugInfo(); 3371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3387c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FunctionArgList Args; 3394c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall QualType ResTy = FD->getResultType(); 3401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3416a1e0eb557d47e85185e09bdf8721f53f4bf9c9cMike Stump CurGD = GD; 3424c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall if (isa<CXXMethodDecl>(FD) && cast<CXXMethodDecl>(FD)->isInstance()) 3434c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResTy, Args); 3441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 345eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman if (FD->getNumParams()) { 346183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const FunctionProtoType* FProto = FD->getType()->getAs<FunctionProtoType>(); 347eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman assert(FProto && "Function def must have prototype!"); 3487c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar 3497c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) 3501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Args.push_back(std::make_pair(FD->getParamDecl(i), 3517c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FProto->getArgType(i))); 3525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 353af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar 354a355e07454463b19829ac92ffd115a097faff0e0John McCall SourceRange BodyRange; 355a355e07454463b19829ac92ffd115a097faff0e0John McCall if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange(); 3564365bba95be15342575b4f030c6583a770a5da3dAnders Carlsson 357a355e07454463b19829ac92ffd115a097faff0e0John McCall // Emit the standard function prologue. 3584c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall StartFunction(GD, ResTy, Fn, Args, BodyRange.getBegin()); 3591851a12605bc6f1ea70d11974a315340ebaab6ebAnders Carlsson 360a355e07454463b19829ac92ffd115a097faff0e0John McCall // Generate the body of the function. 3619fc6a7774643a810c8501dae2323e863fefb623eJohn McCall if (isa<CXXDestructorDecl>(FD)) 3629fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitDestructorBody(Args); 3639fc6a7774643a810c8501dae2323e863fefb623eJohn McCall else if (isa<CXXConstructorDecl>(FD)) 3649fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitConstructorBody(Args); 3659fc6a7774643a810c8501dae2323e863fefb623eJohn McCall else 3669fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitFunctionBody(Args); 367c33e4ba20304e222692e77f2c6ad26a5d8d32f83Anders Carlsson 368a355e07454463b19829ac92ffd115a097faff0e0John McCall // Emit the standard function epilogue. 369a355e07454463b19829ac92ffd115a097faff0e0John McCall FinishFunction(BodyRange.getEnd()); 37039dad53772c42eb36ebec1c81c56ba99d038fb94John McCall 37139dad53772c42eb36ebec1c81c56ba99d038fb94John McCall // If we haven't marked the function nothrow through other means, do 37239dad53772c42eb36ebec1c81c56ba99d038fb94John McCall // a quick pass now to see if we can. 37339dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (!CurFn->doesNotThrow()) 37439dad53772c42eb36ebec1c81c56ba99d038fb94John McCall TryMarkNoThrow(CurFn); 3755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3770946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// ContainsLabel - Return true if the statement contains a label in it. If 3780946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// this statement is not executed normally, it not containing a label means 3790946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// that we can just remove the code. 3800946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattnerbool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) { 3810946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // Null statement, not a label! 3820946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (S == 0) return false; 3831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3840946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a label, we have to emit the code, consider something like: 3850946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // if (0) { ... foo: bar(); } goto foo; 3860946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<LabelStmt>(S)) 3870946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 3881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3890946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a case/default statement, and we haven't seen a switch, we have 3900946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // to emit the code. 3910946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<SwitchCase>(S) && !IgnoreCaseStmts) 3920946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 3931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3940946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a switch statement, we want to ignore cases below it. 3950946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<SwitchStmt>(S)) 3960946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner IgnoreCaseStmts = true; 3971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3980946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // Scan subexpressions for verboten labels. 3997502c1d3ce8bb97bcc4f7bebef507040bd93b26fJohn McCall for (Stmt::const_child_range I = S->children(); I; ++I) 4000946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (ContainsLabel(*I, IgnoreCaseStmts)) 4010946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 4021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4030946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return false; 4040946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner} 4050946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner 40631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 40731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// ConstantFoldsToSimpleInteger - If the sepcified expression does not fold to 40831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// a constant, or if it does but contains a label, return 0. If it constant 40931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// folds to 'true' and does not contain a label, return 1, if it constant folds 41031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// to 'false' and does not contain a label, return -1. 41131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattnerint CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond) { 41236bc14c3a1cf63ee306df5687ac8e85f924f8639Daniel Dunbar // FIXME: Rename and handle conversion of other evaluatable things 41336bc14c3a1cf63ee306df5687ac8e85f924f8639Daniel Dunbar // to bool. 41464712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson Expr::EvalResult Result; 4151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!Cond->Evaluate(Result, getContext()) || !Result.Val.isInt() || 41664712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson Result.HasSideEffects) 417ef5a66d8171eb95e948107f8ee7707b360aaff25Anders Carlsson return 0; // Not foldable, not integer or not fully evaluatable. 4181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 41931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (CodeGenFunction::ContainsLabel(Cond)) 42031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return 0; // Contains a label. 4211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 42264712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson return Result.Val.getInt().getBoolValue() ? 1 : -1; 42331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner} 42431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 42531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 42631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if 42731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// statement) to the specified blocks. Based on the condition, this might try 42831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// to simplify the codegen of the conditional based on the branch. 42931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// 43031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattnervoid CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond, 43131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::BasicBlock *TrueBlock, 43231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::BasicBlock *FalseBlock) { 43331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (const ParenExpr *PE = dyn_cast<ParenExpr>(Cond)) 43431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(PE->getSubExpr(), TrueBlock, FalseBlock); 4351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 43631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) { 43731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Handle X && Y in a condition. 4382de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CondBOp->getOpcode() == BO_LAnd) { 43931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "1 && X", simplify the code. "0 && X" would have constant 44031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // folded if the case was simple enough. 44131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == 1) { 44231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(1 && X) -> br(X). 44331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 44431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 44631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "X && 1", simplify the code to use an uncond branch. 44731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // "X && 0" would have been constant folded to 0. 44831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == 1) { 44931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(X && 1) -> br(X). 45031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 45131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the LHS as a conditional. If the LHS conditional is false, we 45431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // want to jump to the FalseBlock. 4559615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true"); 456150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 457150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall ConditionalEvaluation eval(*this); 45831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock); 45931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBlock(LHSTrue); 4601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 46108e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson // Any temporaries created here are conditional. 462150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(*this); 46331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 464150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(*this); 46508e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson 46631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return; 4672de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall } else if (CondBOp->getOpcode() == BO_LOr) { 46831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "0 || X", simplify the code. "1 || X" would have constant 46931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // folded if the case was simple enough. 47031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == -1) { 47131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(0 || X) -> br(X). 47231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 47331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 47531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "X || 0", simplify the code to use an uncond branch. 47631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // "X || 1" would have been constant folded to 1. 47731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == -1) { 47831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(X || 0) -> br(X). 47931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 48031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 48231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the LHS as a conditional. If the LHS conditional is true, we 48331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // want to jump to the TrueBlock. 4849615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false"); 485150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 486150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall ConditionalEvaluation eval(*this); 48731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse); 48831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBlock(LHSFalse); 4891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 49008e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson // Any temporaries created here are conditional. 491150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(*this); 49231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 493150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(*this); 49408e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson 49531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return; 49631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 497552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner } 4981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 499552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) { 500552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner // br(!x, t, f) -> br(x, f, t) 5012de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CondUOp->getOpcode() == UO_LNot) 502552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock); 50331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 5041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 50509b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) { 50609b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // Handle ?: operator. 50709b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar 50809b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // Just ignore GNU ?: extension. 50909b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar if (CondOp->getLHS()) { 51009b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f)) 51109b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true"); 51209b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false"); 513150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 514150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall ConditionalEvaluation cond(*this); 51509b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock); 516150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 517150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall cond.begin(*this); 51809b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBlock(LHSBlock); 51909b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock); 520150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall cond.end(*this); 521150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 522150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall cond.begin(*this); 52309b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBlock(RHSBlock); 52409b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock); 525150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall cond.end(*this); 526150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 52709b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar return; 52809b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar } 52909b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar } 53009b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar 53131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the code with the fully general case. 53231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::Value *CondV = EvaluateExprAsBool(Cond); 53331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner Builder.CreateCondBr(CondV, TrueBlock, FalseBlock); 53431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner} 53531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 536488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar/// ErrorUnsupported - Print out an error that codegen doesn't support the 537dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner/// specified stmt yet. 53890df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbarvoid CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type, 53990df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar bool OmitOnError) { 54090df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar CGM.ErrorUnsupported(S, Type, OmitOnError); 541dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner} 542dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner 5437143325db76d6c3dabce82500f8cc7c93a941970John McCall/// emitNonZeroVLAInit - Emit the "zero" initialization of a 5447143325db76d6c3dabce82500f8cc7c93a941970John McCall/// variable-length array whose elements have a non-zero bit-pattern. 5457143325db76d6c3dabce82500f8cc7c93a941970John McCall/// 5467143325db76d6c3dabce82500f8cc7c93a941970John McCall/// \param src - a char* pointing to the bit-pattern for a single 5477143325db76d6c3dabce82500f8cc7c93a941970John McCall/// base element of the array 5487143325db76d6c3dabce82500f8cc7c93a941970John McCall/// \param sizeInChars - the total size of the VLA, in chars 5497143325db76d6c3dabce82500f8cc7c93a941970John McCall/// \param align - the total alignment of the VLA 5507143325db76d6c3dabce82500f8cc7c93a941970John McCallstatic void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType, 5517143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *dest, llvm::Value *src, 5527143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *sizeInChars) { 5537143325db76d6c3dabce82500f8cc7c93a941970John McCall std::pair<CharUnits,CharUnits> baseSizeAndAlign 5547143325db76d6c3dabce82500f8cc7c93a941970John McCall = CGF.getContext().getTypeInfoInChars(baseType); 5557143325db76d6c3dabce82500f8cc7c93a941970John McCall 5567143325db76d6c3dabce82500f8cc7c93a941970John McCall CGBuilderTy &Builder = CGF.Builder; 5577143325db76d6c3dabce82500f8cc7c93a941970John McCall 5587143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *baseSizeInChars 5597143325db76d6c3dabce82500f8cc7c93a941970John McCall = llvm::ConstantInt::get(CGF.IntPtrTy, baseSizeAndAlign.first.getQuantity()); 5607143325db76d6c3dabce82500f8cc7c93a941970John McCall 5617143325db76d6c3dabce82500f8cc7c93a941970John McCall const llvm::Type *i8p = Builder.getInt8PtrTy(); 5627143325db76d6c3dabce82500f8cc7c93a941970John McCall 5637143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *begin = Builder.CreateBitCast(dest, i8p, "vla.begin"); 5647143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *end = Builder.CreateInBoundsGEP(dest, sizeInChars, "vla.end"); 5657143325db76d6c3dabce82500f8cc7c93a941970John McCall 5667143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock(); 5677143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *loopBB = CGF.createBasicBlock("vla-init.loop"); 5687143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *contBB = CGF.createBasicBlock("vla-init.cont"); 5697143325db76d6c3dabce82500f8cc7c93a941970John McCall 5707143325db76d6c3dabce82500f8cc7c93a941970John McCall // Make a loop over the VLA. C99 guarantees that the VLA element 5717143325db76d6c3dabce82500f8cc7c93a941970John McCall // count must be nonzero. 5727143325db76d6c3dabce82500f8cc7c93a941970John McCall CGF.EmitBlock(loopBB); 5737143325db76d6c3dabce82500f8cc7c93a941970John McCall 5747143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::PHINode *cur = Builder.CreatePHI(i8p, "vla.cur"); 5757143325db76d6c3dabce82500f8cc7c93a941970John McCall cur->reserveOperandSpace(2); 5767143325db76d6c3dabce82500f8cc7c93a941970John McCall cur->addIncoming(begin, originBB); 5777143325db76d6c3dabce82500f8cc7c93a941970John McCall 5787143325db76d6c3dabce82500f8cc7c93a941970John McCall // memcpy the individual element bit-pattern. 5797143325db76d6c3dabce82500f8cc7c93a941970John McCall Builder.CreateMemCpy(cur, src, baseSizeInChars, 5807143325db76d6c3dabce82500f8cc7c93a941970John McCall baseSizeAndAlign.second.getQuantity(), 5817143325db76d6c3dabce82500f8cc7c93a941970John McCall /*volatile*/ false); 5827143325db76d6c3dabce82500f8cc7c93a941970John McCall 5837143325db76d6c3dabce82500f8cc7c93a941970John McCall // Go to the next element. 5847143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *next = Builder.CreateConstInBoundsGEP1_32(cur, 1, "vla.next"); 5857143325db76d6c3dabce82500f8cc7c93a941970John McCall 5867143325db76d6c3dabce82500f8cc7c93a941970John McCall // Leave if that's the end of the VLA. 5877143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *done = Builder.CreateICmpEQ(next, end, "vla-init.isdone"); 5887143325db76d6c3dabce82500f8cc7c93a941970John McCall Builder.CreateCondBr(done, contBB, loopBB); 5897143325db76d6c3dabce82500f8cc7c93a941970John McCall cur->addIncoming(next, loopBB); 5907143325db76d6c3dabce82500f8cc7c93a941970John McCall 5917143325db76d6c3dabce82500f8cc7c93a941970John McCall CGF.EmitBlock(contBB); 5927143325db76d6c3dabce82500f8cc7c93a941970John McCall} 5937143325db76d6c3dabce82500f8cc7c93a941970John McCall 5941884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlssonvoid 5951884eb0b5c55edda4893ddec45e7dbad79758782Anders CarlssonCodeGenFunction::EmitNullInitialization(llvm::Value *DestPtr, QualType Ty) { 5960d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson // Ignore empty classes in C++. 5970d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (getContext().getLangOptions().CPlusPlus) { 5980d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (const RecordType *RT = Ty->getAs<RecordType>()) { 5990d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty()) 6000d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson return; 6010d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson } 6020d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson } 6039021718882441dd391a1960084580d3cd19c423aJohn McCall 6049021718882441dd391a1960084580d3cd19c423aJohn McCall // Cast the dest ptr to the appropriate i8 pointer type. 6059021718882441dd391a1960084580d3cd19c423aJohn McCall unsigned DestAS = 6069021718882441dd391a1960084580d3cd19c423aJohn McCall cast<llvm::PointerType>(DestPtr->getType())->getAddressSpace(); 6079f0c7cc36d29cf591c33962931f5862847145f3eBenjamin Kramer const llvm::Type *BP = Builder.getInt8PtrTy(DestAS); 6083d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson if (DestPtr->getType() != BP) 6093d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp"); 6103d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 6113d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson // Get size and alignment info for this aggregate. 6123d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson std::pair<uint64_t, unsigned> TypeInfo = getContext().getTypeInfo(Ty); 6139f0c7cc36d29cf591c33962931f5862847145f3eBenjamin Kramer uint64_t Size = TypeInfo.first / 8; 6149f0c7cc36d29cf591c33962931f5862847145f3eBenjamin Kramer unsigned Align = TypeInfo.second / 8; 6153d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 6165576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall llvm::Value *SizeVal; 6177143325db76d6c3dabce82500f8cc7c93a941970John McCall const VariableArrayType *vla; 6189021718882441dd391a1960084580d3cd19c423aJohn McCall 6195576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall // Don't bother emitting a zero-byte memset. 6205576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall if (Size == 0) { 6215576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall // But note that getTypeInfo returns 0 for a VLA. 6225576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall if (const VariableArrayType *vlaType = 6235576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall dyn_cast_or_null<VariableArrayType>( 6245576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall getContext().getAsArrayType(Ty))) { 6255576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall SizeVal = GetVLASize(vlaType); 6267143325db76d6c3dabce82500f8cc7c93a941970John McCall vla = vlaType; 6275576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } else { 6285576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall return; 6295576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } 6305576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } else { 6315576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall SizeVal = llvm::ConstantInt::get(IntPtrTy, Size); 6327143325db76d6c3dabce82500f8cc7c93a941970John McCall vla = 0; 6335576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } 6349021718882441dd391a1960084580d3cd19c423aJohn McCall 6359021718882441dd391a1960084580d3cd19c423aJohn McCall // If the type contains a pointer to data member we can't memset it to zero. 6369021718882441dd391a1960084580d3cd19c423aJohn McCall // Instead, create a null constant and copy it to the destination. 6377143325db76d6c3dabce82500f8cc7c93a941970John McCall // TODO: there are other patterns besides zero that we can usefully memset, 6387143325db76d6c3dabce82500f8cc7c93a941970John McCall // like -1, which happens to be the pattern used by member-pointers. 639f16aa103d3afd42fbca2ab346f191bf745cec092John McCall if (!CGM.getTypes().isZeroInitializable(Ty)) { 6407143325db76d6c3dabce82500f8cc7c93a941970John McCall // For a VLA, emit a single element, then splat that over the VLA. 6417143325db76d6c3dabce82500f8cc7c93a941970John McCall if (vla) Ty = getContext().getBaseElementType(vla); 6425576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall 6439021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty); 6449021718882441dd391a1960084580d3cd19c423aJohn McCall 6459021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::GlobalVariable *NullVariable = 6469021718882441dd391a1960084580d3cd19c423aJohn McCall new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(), 6479021718882441dd391a1960084580d3cd19c423aJohn McCall /*isConstant=*/true, 6489021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::GlobalVariable::PrivateLinkage, 6499021718882441dd391a1960084580d3cd19c423aJohn McCall NullConstant, llvm::Twine()); 6509021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::Value *SrcPtr = 6519021718882441dd391a1960084580d3cd19c423aJohn McCall Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()); 6529021718882441dd391a1960084580d3cd19c423aJohn McCall 6537143325db76d6c3dabce82500f8cc7c93a941970John McCall if (vla) return emitNonZeroVLAInit(*this, Ty, DestPtr, SrcPtr, SizeVal); 6547143325db76d6c3dabce82500f8cc7c93a941970John McCall 6559021718882441dd391a1960084580d3cd19c423aJohn McCall // Get and call the appropriate llvm.memcpy overload. 6569f0c7cc36d29cf591c33962931f5862847145f3eBenjamin Kramer Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, Align, false); 65788207c9ca218486b93ae7df14e9764cd0c2c3383Chris Lattner return; 6589021718882441dd391a1960084580d3cd19c423aJohn McCall } 6599021718882441dd391a1960084580d3cd19c423aJohn McCall 6609021718882441dd391a1960084580d3cd19c423aJohn McCall // Otherwise, just memset the whole thing to zero. This is legal 6619021718882441dd391a1960084580d3cd19c423aJohn McCall // because in LLVM, all default initializers (other than the ones we just 6629021718882441dd391a1960084580d3cd19c423aJohn McCall // handled above) are guaranteed to have a bit pattern of all zeros. 6639f0c7cc36d29cf591c33962931f5862847145f3eBenjamin Kramer Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal, Align, false); 6643d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson} 6653d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 666d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattnerllvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelStmt *L) { 667d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Make sure that there is a block for the indirect goto. 668d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch == 0) 669d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner GetIndirectGotoBlock(); 6703d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 671ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock(); 6723d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 673d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Make sure the indirect branch includes all of the address-taken blocks. 674d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner IndirectBranch->addDestination(BB); 675d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return llvm::BlockAddress::get(CurFn, BB); 6763d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner} 6771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6783d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattnerllvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() { 679d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If we already made the indirect branch for indirect goto, return its block. 680d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) return IndirectBranch->getParent(); 6813d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 682d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner CGBuilderTy TmpBuilder(createBasicBlock("indirectgoto")); 6833d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 6843d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner // Create the PHI node that indirect gotos will add entries to. 685d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, "indirect.goto.dest"); 6863d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 687d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Create the indirect branch instruction. 688d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal); 689d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return IndirectBranch->getParent(); 6900ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar} 691ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 692d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbarllvm::Value *CodeGenFunction::GetVLASize(const VariableArrayType *VAT) { 693bbed6b964414145b29e7b60b3e538093734ea3f8Eli Friedman llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()]; 6941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 695f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson assert(SizeEntry && "Did not emit size for type"); 696f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson return SizeEntry; 697f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson} 698dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson 699d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbarllvm::Value *CodeGenFunction::EmitVLASize(QualType Ty) { 70060d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson assert(Ty->isVariablyModifiedType() && 70160d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson "Must pass variably modified type to EmitVLASizes!"); 7021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 703d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbar EnsureInsertPoint(); 7041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 70560d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson if (const VariableArrayType *VAT = getContext().getAsVariableArrayType(Ty)) { 706745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian // unknown size indication requires no size computation. 707745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian if (!VAT->getSizeExpr()) 708745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian return 0; 709bbed6b964414145b29e7b60b3e538093734ea3f8Eli Friedman llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()]; 7101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 711fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson if (!SizeEntry) { 71296f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson const llvm::Type *SizeTy = ConvertType(getContext().getSizeType()); 7131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 714ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner // Get the element size; 715ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner QualType ElemTy = VAT->getElementType(); 716ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner llvm::Value *ElemSize; 717fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson if (ElemTy->isVariableArrayType()) 718fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson ElemSize = EmitVLASize(ElemTy); 719ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner else 7204a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson ElemSize = llvm::ConstantInt::get(SizeTy, 721199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck getContext().getTypeSizeInChars(ElemTy).getQuantity()); 7221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 723fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson llvm::Value *NumElements = EmitScalarExpr(VAT->getSizeExpr()); 72496f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson NumElements = Builder.CreateIntCast(NumElements, SizeTy, false, "tmp"); 7251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 726fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson SizeEntry = Builder.CreateMul(ElemSize, NumElements); 727fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson } 7281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 72960d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson return SizeEntry; 730dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson } 7311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 732ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner if (const ArrayType *AT = dyn_cast<ArrayType>(Ty)) { 733ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner EmitVLASize(AT->getElementType()); 734ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner return 0; 7351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 7361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 737075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara if (const ParenType *PT = dyn_cast<ParenType>(Ty)) { 738075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara EmitVLASize(PT->getInnerType()); 739075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return 0; 740075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara } 741075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 742ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner const PointerType *PT = Ty->getAs<PointerType>(); 743ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner assert(PT && "unknown VM type!"); 744ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner EmitVLASize(PT->getPointeeType()); 74560d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson return 0; 746dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson} 7474fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman 7484fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedmanllvm::Value* CodeGenFunction::EmitVAListRef(const Expr* E) { 749bc07a55b68342a230aafd8875cc7a26450dd3f64Dan Gohman if (getContext().getBuiltinVaListType()->isArrayType()) 7504fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman return EmitScalarExpr(E); 7514fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman return EmitLValue(E).getAddress(); 7524fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman} 7536ccc47698d0311ddabf32fa0f6db8e4f09ac96f8Anders Carlsson 7548d308384a220c7dc81755c47cdcbdd87dac25d5bDevang Patelvoid CodeGenFunction::EmitDeclRefExprDbgValue(const DeclRefExpr *E, 755189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall llvm::Constant *Init) { 75625c2c8fb9309050612009a6571e2660e75531348Devang Patel assert (Init && "Invalid DeclRefExpr initializer!"); 75725c2c8fb9309050612009a6571e2660e75531348Devang Patel if (CGDebugInfo *Dbg = getDebugInfo()) 758d2829b76a87a70791184b3cac89900d2cda46ce4Devang Patel Dbg->EmitGlobalVariable(E->getDecl(), Init); 7598d308384a220c7dc81755c47cdcbdd87dac25d5bDevang Patel} 760