CodeGenFunction.cpp revision f315fa81eef1977b3457fd7a7d4639e060fe7278
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 242f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne if (getContext().getLangOptions().OpenCL) { 243f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne // Add metadata for a kernel function. 244f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) 245f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne if (FD->hasAttr<OpenCLKernelAttr>()) { 246f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne llvm::LLVMContext &Context = getLLVMContext(); 247f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne llvm::NamedMDNode *OpenCLMetadata = 248f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne CGM.getModule().getOrInsertNamedMetadata("opencl.kernels"); 249f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne 250f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne llvm::Value *Op = Fn; 251f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne OpenCLMetadata->addOperand(llvm::MDNode::get(Context, &Op, 1)); 252f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne } 253f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne } 254f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne 25555e874299f2ad827646a4ca9ea38c402aaeb38c9Daniel Dunbar llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn); 2565ca2084cf9b529563209429857f01fdae9dcdfa5Daniel Dunbar 2575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Create a marker to make it easy to insert allocas into the entryblock 25855352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner // later. Don't create this with the builder, because we don't want it 25955352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner // folded. 26077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Value *Undef = llvm::UndefValue::get(Int32Ty); 26177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "", EntryBB); 262f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner if (Builder.isNamePreserving()) 263f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner AllocaInsertPt->setName("allocapt"); 2641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 265f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall ReturnBlock = getJumpDestInCurrentScope("return"); 2661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 26755352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner Builder.SetInsertPoint(EntryBB); 2681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 269af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta // Emit subprogram debug descriptor. 270e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson if (CGDebugInfo *DI = getDebugInfo()) { 271e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall // FIXME: what is going on here and why does it ignore all these 272e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall // interesting type properties? 273e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall QualType FnType = 274e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall getContext().getFunctionType(RetTy, 0, 0, 275e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo()); 276e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 2772284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar DI->setLocation(StartLoc); 2789c6c3a0e3ae09626d2d4b04e4ffa42c3d7cab32bDevang Patel DI->EmitFunctionStart(GD, FnType, CurFn, Builder); 279af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta } 280af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta 281a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar if (ShouldInstrumentFunction()) 282a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar EmitFunctionInstrumentation("__cyg_profile_func_enter"); 2837255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 284be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky if (CGM.getCodeGenOpts().InstrumentForProfiling) 285be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky EmitMCountInstrumentation(); 286be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky 28788b5396b0897f28d22ae3debf4a0d97b33b6c362Daniel Dunbar // FIXME: Leaked. 28804a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // CC info is ignored, hopefully? 28904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall CurFnInfo = &CGM.getTypes().getFunctionInfo(FnRetTy, Args, 290264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo()); 291b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman 292b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman if (RetTy->isVoidType()) { 293b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman // Void type; nothing to return. 294b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman ReturnValue = 0; 295b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect && 296b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman hasAggregateLLVMType(CurFnInfo->getReturnType())) { 297b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman // Indirect aggregate return; emit returned value directly into sret slot. 298647a1ec397fa13af176d07d9f5d071560a94c7a9Daniel Dunbar // This reduces code size, and affects correctness in C++. 299b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman ReturnValue = CurFn->arg_begin(); 300b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } else { 301647a1ec397fa13af176d07d9f5d071560a94c7a9Daniel Dunbar ReturnValue = CreateIRTemp(RetTy, "retval"); 302b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } 303b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman 304cce3d4f9812182ed4e551b7cf0fc86576be8d9c5Mike Stump EmitStartEHSpec(CurCodeDecl); 30588b5396b0897f28d22ae3debf4a0d97b33b6c362Daniel Dunbar EmitFunctionProlog(*CurFnInfo, CurFn, Args); 3061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3074c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) 3084c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().EmitInstanceFunctionProlog(*this); 3092504941793b549323f9d29c62507cf21d865fadeJohn McCall 310751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson // If any of the arguments have a variably modified type, make sure to 311751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson // emit the type size. 312751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); 313751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson i != e; ++i) { 314751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson QualType Ty = i->second; 315751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson 316751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson if (Ty->isVariablyModifiedType()) 317751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson EmitVLASize(Ty); 318751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson } 3197c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar} 320eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman 3219fc6a7774643a810c8501dae2323e863fefb623eJohn McCallvoid CodeGenFunction::EmitFunctionBody(FunctionArgList &Args) { 3229fc6a7774643a810c8501dae2323e863fefb623eJohn McCall const FunctionDecl *FD = cast<FunctionDecl>(CurGD.getDecl()); 32306a9f3680d22529a2fcf20c52d71cf221d99d910Douglas Gregor assert(FD->getBody()); 32406a9f3680d22529a2fcf20c52d71cf221d99d910Douglas Gregor EmitStmt(FD->getBody()); 325a355e07454463b19829ac92ffd115a097faff0e0John McCall} 326a355e07454463b19829ac92ffd115a097faff0e0John McCall 32739dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// Tries to mark the given function nounwind based on the 32839dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// non-existence of any throwing calls within it. We believe this is 32939dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// lightweight enough to do at -O0. 33039dad53772c42eb36ebec1c81c56ba99d038fb94John McCallstatic void TryMarkNoThrow(llvm::Function *F) { 331b3a29f132794f67108bccc9c7cc3795365e8a965John McCall // LLVM treats 'nounwind' on a function as part of the type, so we 332b3a29f132794f67108bccc9c7cc3795365e8a965John McCall // can't do this on functions that can be overwritten. 333b3a29f132794f67108bccc9c7cc3795365e8a965John McCall if (F->mayBeOverridden()) return; 334b3a29f132794f67108bccc9c7cc3795365e8a965John McCall 33539dad53772c42eb36ebec1c81c56ba99d038fb94John McCall for (llvm::Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI) 33639dad53772c42eb36ebec1c81c56ba99d038fb94John McCall for (llvm::BasicBlock::iterator 33739dad53772c42eb36ebec1c81c56ba99d038fb94John McCall BI = FI->begin(), BE = FI->end(); BI != BE; ++BI) 33839dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(&*BI)) 33939dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (!Call->doesNotThrow()) 34039dad53772c42eb36ebec1c81c56ba99d038fb94John McCall return; 34139dad53772c42eb36ebec1c81c56ba99d038fb94John McCall F->setDoesNotThrow(true); 34239dad53772c42eb36ebec1c81c56ba99d038fb94John McCall} 34339dad53772c42eb36ebec1c81c56ba99d038fb94John McCall 344c997d4278d329e18891aac9698fb991b2d4622ebAnders Carlssonvoid CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn) { 3450ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 3460ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson 347e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson // Check if we should generate debug info for this function. 3481feade8e520be483293dbf55eb57a51720899589Mike Stump if (CGM.getDebugInfo() && !FD->hasAttr<NoDebugAttr>()) 349e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson DebugInfo = CGM.getDebugInfo(); 3501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3517c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FunctionArgList Args; 3524c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall QualType ResTy = FD->getResultType(); 3531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3546a1e0eb557d47e85185e09bdf8721f53f4bf9c9cMike Stump CurGD = GD; 3554c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall if (isa<CXXMethodDecl>(FD) && cast<CXXMethodDecl>(FD)->isInstance()) 3564c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResTy, Args); 3571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 358eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman if (FD->getNumParams()) { 359183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const FunctionProtoType* FProto = FD->getType()->getAs<FunctionProtoType>(); 360eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman assert(FProto && "Function def must have prototype!"); 3617c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar 3627c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) 3631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Args.push_back(std::make_pair(FD->getParamDecl(i), 3647c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FProto->getArgType(i))); 3655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 366af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar 367a355e07454463b19829ac92ffd115a097faff0e0John McCall SourceRange BodyRange; 368a355e07454463b19829ac92ffd115a097faff0e0John McCall if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange(); 3694365bba95be15342575b4f030c6583a770a5da3dAnders Carlsson 370a355e07454463b19829ac92ffd115a097faff0e0John McCall // Emit the standard function prologue. 3714c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall StartFunction(GD, ResTy, Fn, Args, BodyRange.getBegin()); 3721851a12605bc6f1ea70d11974a315340ebaab6ebAnders Carlsson 373a355e07454463b19829ac92ffd115a097faff0e0John McCall // Generate the body of the function. 3749fc6a7774643a810c8501dae2323e863fefb623eJohn McCall if (isa<CXXDestructorDecl>(FD)) 3759fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitDestructorBody(Args); 3769fc6a7774643a810c8501dae2323e863fefb623eJohn McCall else if (isa<CXXConstructorDecl>(FD)) 3779fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitConstructorBody(Args); 3789fc6a7774643a810c8501dae2323e863fefb623eJohn McCall else 3799fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitFunctionBody(Args); 380c33e4ba20304e222692e77f2c6ad26a5d8d32f83Anders Carlsson 381a355e07454463b19829ac92ffd115a097faff0e0John McCall // Emit the standard function epilogue. 382a355e07454463b19829ac92ffd115a097faff0e0John McCall FinishFunction(BodyRange.getEnd()); 38339dad53772c42eb36ebec1c81c56ba99d038fb94John McCall 38439dad53772c42eb36ebec1c81c56ba99d038fb94John McCall // If we haven't marked the function nothrow through other means, do 38539dad53772c42eb36ebec1c81c56ba99d038fb94John McCall // a quick pass now to see if we can. 38639dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (!CurFn->doesNotThrow()) 38739dad53772c42eb36ebec1c81c56ba99d038fb94John McCall TryMarkNoThrow(CurFn); 3885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3900946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// ContainsLabel - Return true if the statement contains a label in it. If 3910946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// this statement is not executed normally, it not containing a label means 3920946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// that we can just remove the code. 3930946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattnerbool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) { 3940946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // Null statement, not a label! 3950946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (S == 0) return false; 3961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3970946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a label, we have to emit the code, consider something like: 3980946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // if (0) { ... foo: bar(); } goto foo; 3990946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<LabelStmt>(S)) 4000946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 4011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4020946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a case/default statement, and we haven't seen a switch, we have 4030946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // to emit the code. 4040946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<SwitchCase>(S) && !IgnoreCaseStmts) 4050946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 4061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4070946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a switch statement, we want to ignore cases below it. 4080946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<SwitchStmt>(S)) 4090946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner IgnoreCaseStmts = true; 4101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4110946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // Scan subexpressions for verboten labels. 4127502c1d3ce8bb97bcc4f7bebef507040bd93b26fJohn McCall for (Stmt::const_child_range I = S->children(); I; ++I) 4130946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (ContainsLabel(*I, IgnoreCaseStmts)) 4140946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 4151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4160946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return false; 4170946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner} 4180946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner 41931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 42031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// ConstantFoldsToSimpleInteger - If the sepcified expression does not fold to 42131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// a constant, or if it does but contains a label, return 0. If it constant 42231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// folds to 'true' and does not contain a label, return 1, if it constant folds 42331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// to 'false' and does not contain a label, return -1. 42431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattnerint CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond) { 42536bc14c3a1cf63ee306df5687ac8e85f924f8639Daniel Dunbar // FIXME: Rename and handle conversion of other evaluatable things 42636bc14c3a1cf63ee306df5687ac8e85f924f8639Daniel Dunbar // to bool. 42764712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson Expr::EvalResult Result; 4281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!Cond->Evaluate(Result, getContext()) || !Result.Val.isInt() || 42964712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson Result.HasSideEffects) 430ef5a66d8171eb95e948107f8ee7707b360aaff25Anders Carlsson return 0; // Not foldable, not integer or not fully evaluatable. 4311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 43231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (CodeGenFunction::ContainsLabel(Cond)) 43331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return 0; // Contains a label. 4341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 43564712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson return Result.Val.getInt().getBoolValue() ? 1 : -1; 43631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner} 43731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 43831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 43931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if 44031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// statement) to the specified blocks. Based on the condition, this might try 44131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// to simplify the codegen of the conditional based on the branch. 44231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// 44331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattnervoid CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond, 44431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::BasicBlock *TrueBlock, 44531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::BasicBlock *FalseBlock) { 44631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (const ParenExpr *PE = dyn_cast<ParenExpr>(Cond)) 44731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(PE->getSubExpr(), TrueBlock, FalseBlock); 4481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 44931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) { 45031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Handle X && Y in a condition. 4512de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CondBOp->getOpcode() == BO_LAnd) { 45231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "1 && X", simplify the code. "0 && X" would have constant 45331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // folded if the case was simple enough. 45431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == 1) { 45531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(1 && X) -> br(X). 45631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 45731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "X && 1", simplify the code to use an uncond branch. 46031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // "X && 0" would have been constant folded to 0. 46131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == 1) { 46231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(X && 1) -> br(X). 46331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 46431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 46631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the LHS as a conditional. If the LHS conditional is false, we 46731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // want to jump to the FalseBlock. 4689615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true"); 469150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 470150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall ConditionalEvaluation eval(*this); 47131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock); 47231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBlock(LHSTrue); 4731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 47408e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson // Any temporaries created here are conditional. 475150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(*this); 47631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 477150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(*this); 47808e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson 47931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return; 4802de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall } else if (CondBOp->getOpcode() == BO_LOr) { 48131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "0 || X", simplify the code. "1 || X" would have constant 48231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // folded if the case was simple enough. 48331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == -1) { 48431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(0 || X) -> br(X). 48531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 48631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 48831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "X || 0", simplify the code to use an uncond branch. 48931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // "X || 1" would have been constant folded to 1. 49031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == -1) { 49131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(X || 0) -> br(X). 49231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 49331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 49531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the LHS as a conditional. If the LHS conditional is true, we 49631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // want to jump to the TrueBlock. 4979615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false"); 498150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 499150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall ConditionalEvaluation eval(*this); 50031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse); 50131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBlock(LHSFalse); 5021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 50308e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson // Any temporaries created here are conditional. 504150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(*this); 50531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 506150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(*this); 50708e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson 50831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return; 50931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 510552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner } 5111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 512552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) { 513552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner // br(!x, t, f) -> br(x, f, t) 5142de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CondUOp->getOpcode() == UO_LNot) 515552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock); 51631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 5171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 51809b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) { 51909b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // Handle ?: operator. 52009b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar 52109b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // Just ignore GNU ?: extension. 52209b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar if (CondOp->getLHS()) { 52309b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f)) 52409b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true"); 52509b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false"); 526150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 527150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall ConditionalEvaluation cond(*this); 52809b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock); 529150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 530150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall cond.begin(*this); 53109b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBlock(LHSBlock); 53209b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock); 533150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall cond.end(*this); 534150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 535150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall cond.begin(*this); 53609b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBlock(RHSBlock); 53709b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock); 538150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall cond.end(*this); 539150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 54009b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar return; 54109b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar } 54209b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar } 54309b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar 54431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the code with the fully general case. 54531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::Value *CondV = EvaluateExprAsBool(Cond); 54631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner Builder.CreateCondBr(CondV, TrueBlock, FalseBlock); 54731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner} 54831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 549488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar/// ErrorUnsupported - Print out an error that codegen doesn't support the 550dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner/// specified stmt yet. 55190df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbarvoid CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type, 55290df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar bool OmitOnError) { 55390df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar CGM.ErrorUnsupported(S, Type, OmitOnError); 554dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner} 555dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner 5567143325db76d6c3dabce82500f8cc7c93a941970John McCall/// emitNonZeroVLAInit - Emit the "zero" initialization of a 5577143325db76d6c3dabce82500f8cc7c93a941970John McCall/// variable-length array whose elements have a non-zero bit-pattern. 5587143325db76d6c3dabce82500f8cc7c93a941970John McCall/// 5597143325db76d6c3dabce82500f8cc7c93a941970John McCall/// \param src - a char* pointing to the bit-pattern for a single 5607143325db76d6c3dabce82500f8cc7c93a941970John McCall/// base element of the array 5617143325db76d6c3dabce82500f8cc7c93a941970John McCall/// \param sizeInChars - the total size of the VLA, in chars 5627143325db76d6c3dabce82500f8cc7c93a941970John McCall/// \param align - the total alignment of the VLA 5637143325db76d6c3dabce82500f8cc7c93a941970John McCallstatic void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType, 5647143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *dest, llvm::Value *src, 5657143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *sizeInChars) { 5667143325db76d6c3dabce82500f8cc7c93a941970John McCall std::pair<CharUnits,CharUnits> baseSizeAndAlign 5677143325db76d6c3dabce82500f8cc7c93a941970John McCall = CGF.getContext().getTypeInfoInChars(baseType); 5687143325db76d6c3dabce82500f8cc7c93a941970John McCall 5697143325db76d6c3dabce82500f8cc7c93a941970John McCall CGBuilderTy &Builder = CGF.Builder; 5707143325db76d6c3dabce82500f8cc7c93a941970John McCall 5717143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *baseSizeInChars 5727143325db76d6c3dabce82500f8cc7c93a941970John McCall = llvm::ConstantInt::get(CGF.IntPtrTy, baseSizeAndAlign.first.getQuantity()); 5737143325db76d6c3dabce82500f8cc7c93a941970John McCall 5747143325db76d6c3dabce82500f8cc7c93a941970John McCall const llvm::Type *i8p = Builder.getInt8PtrTy(); 5757143325db76d6c3dabce82500f8cc7c93a941970John McCall 5767143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *begin = Builder.CreateBitCast(dest, i8p, "vla.begin"); 5777143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *end = Builder.CreateInBoundsGEP(dest, sizeInChars, "vla.end"); 5787143325db76d6c3dabce82500f8cc7c93a941970John McCall 5797143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock(); 5807143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *loopBB = CGF.createBasicBlock("vla-init.loop"); 5817143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *contBB = CGF.createBasicBlock("vla-init.cont"); 5827143325db76d6c3dabce82500f8cc7c93a941970John McCall 5837143325db76d6c3dabce82500f8cc7c93a941970John McCall // Make a loop over the VLA. C99 guarantees that the VLA element 5847143325db76d6c3dabce82500f8cc7c93a941970John McCall // count must be nonzero. 5857143325db76d6c3dabce82500f8cc7c93a941970John McCall CGF.EmitBlock(loopBB); 5867143325db76d6c3dabce82500f8cc7c93a941970John McCall 5877143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::PHINode *cur = Builder.CreatePHI(i8p, "vla.cur"); 5887143325db76d6c3dabce82500f8cc7c93a941970John McCall cur->reserveOperandSpace(2); 5897143325db76d6c3dabce82500f8cc7c93a941970John McCall cur->addIncoming(begin, originBB); 5907143325db76d6c3dabce82500f8cc7c93a941970John McCall 5917143325db76d6c3dabce82500f8cc7c93a941970John McCall // memcpy the individual element bit-pattern. 5927143325db76d6c3dabce82500f8cc7c93a941970John McCall Builder.CreateMemCpy(cur, src, baseSizeInChars, 5937143325db76d6c3dabce82500f8cc7c93a941970John McCall baseSizeAndAlign.second.getQuantity(), 5947143325db76d6c3dabce82500f8cc7c93a941970John McCall /*volatile*/ false); 5957143325db76d6c3dabce82500f8cc7c93a941970John McCall 5967143325db76d6c3dabce82500f8cc7c93a941970John McCall // Go to the next element. 5977143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *next = Builder.CreateConstInBoundsGEP1_32(cur, 1, "vla.next"); 5987143325db76d6c3dabce82500f8cc7c93a941970John McCall 5997143325db76d6c3dabce82500f8cc7c93a941970John McCall // Leave if that's the end of the VLA. 6007143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *done = Builder.CreateICmpEQ(next, end, "vla-init.isdone"); 6017143325db76d6c3dabce82500f8cc7c93a941970John McCall Builder.CreateCondBr(done, contBB, loopBB); 6027143325db76d6c3dabce82500f8cc7c93a941970John McCall cur->addIncoming(next, loopBB); 6037143325db76d6c3dabce82500f8cc7c93a941970John McCall 6047143325db76d6c3dabce82500f8cc7c93a941970John McCall CGF.EmitBlock(contBB); 6057143325db76d6c3dabce82500f8cc7c93a941970John McCall} 6067143325db76d6c3dabce82500f8cc7c93a941970John McCall 6071884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlssonvoid 6081884eb0b5c55edda4893ddec45e7dbad79758782Anders CarlssonCodeGenFunction::EmitNullInitialization(llvm::Value *DestPtr, QualType Ty) { 6090d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson // Ignore empty classes in C++. 6100d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (getContext().getLangOptions().CPlusPlus) { 6110d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (const RecordType *RT = Ty->getAs<RecordType>()) { 6120d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty()) 6130d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson return; 6140d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson } 6150d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson } 6169021718882441dd391a1960084580d3cd19c423aJohn McCall 6179021718882441dd391a1960084580d3cd19c423aJohn McCall // Cast the dest ptr to the appropriate i8 pointer type. 6189021718882441dd391a1960084580d3cd19c423aJohn McCall unsigned DestAS = 6199021718882441dd391a1960084580d3cd19c423aJohn McCall cast<llvm::PointerType>(DestPtr->getType())->getAddressSpace(); 6209f0c7cc36d29cf591c33962931f5862847145f3eBenjamin Kramer const llvm::Type *BP = Builder.getInt8PtrTy(DestAS); 6213d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson if (DestPtr->getType() != BP) 6223d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp"); 6233d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 6243d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson // Get size and alignment info for this aggregate. 6253d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson std::pair<uint64_t, unsigned> TypeInfo = getContext().getTypeInfo(Ty); 6269f0c7cc36d29cf591c33962931f5862847145f3eBenjamin Kramer uint64_t Size = TypeInfo.first / 8; 6279f0c7cc36d29cf591c33962931f5862847145f3eBenjamin Kramer unsigned Align = TypeInfo.second / 8; 6283d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 6295576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall llvm::Value *SizeVal; 6307143325db76d6c3dabce82500f8cc7c93a941970John McCall const VariableArrayType *vla; 6319021718882441dd391a1960084580d3cd19c423aJohn McCall 6325576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall // Don't bother emitting a zero-byte memset. 6335576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall if (Size == 0) { 6345576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall // But note that getTypeInfo returns 0 for a VLA. 6355576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall if (const VariableArrayType *vlaType = 6365576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall dyn_cast_or_null<VariableArrayType>( 6375576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall getContext().getAsArrayType(Ty))) { 6385576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall SizeVal = GetVLASize(vlaType); 6397143325db76d6c3dabce82500f8cc7c93a941970John McCall vla = vlaType; 6405576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } else { 6415576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall return; 6425576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } 6435576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } else { 6445576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall SizeVal = llvm::ConstantInt::get(IntPtrTy, Size); 6457143325db76d6c3dabce82500f8cc7c93a941970John McCall vla = 0; 6465576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } 6479021718882441dd391a1960084580d3cd19c423aJohn McCall 6489021718882441dd391a1960084580d3cd19c423aJohn McCall // If the type contains a pointer to data member we can't memset it to zero. 6499021718882441dd391a1960084580d3cd19c423aJohn McCall // Instead, create a null constant and copy it to the destination. 6507143325db76d6c3dabce82500f8cc7c93a941970John McCall // TODO: there are other patterns besides zero that we can usefully memset, 6517143325db76d6c3dabce82500f8cc7c93a941970John McCall // like -1, which happens to be the pattern used by member-pointers. 652f16aa103d3afd42fbca2ab346f191bf745cec092John McCall if (!CGM.getTypes().isZeroInitializable(Ty)) { 6537143325db76d6c3dabce82500f8cc7c93a941970John McCall // For a VLA, emit a single element, then splat that over the VLA. 6547143325db76d6c3dabce82500f8cc7c93a941970John McCall if (vla) Ty = getContext().getBaseElementType(vla); 6555576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall 6569021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty); 6579021718882441dd391a1960084580d3cd19c423aJohn McCall 6589021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::GlobalVariable *NullVariable = 6599021718882441dd391a1960084580d3cd19c423aJohn McCall new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(), 6609021718882441dd391a1960084580d3cd19c423aJohn McCall /*isConstant=*/true, 6619021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::GlobalVariable::PrivateLinkage, 6629021718882441dd391a1960084580d3cd19c423aJohn McCall NullConstant, llvm::Twine()); 6639021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::Value *SrcPtr = 6649021718882441dd391a1960084580d3cd19c423aJohn McCall Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()); 6659021718882441dd391a1960084580d3cd19c423aJohn McCall 6667143325db76d6c3dabce82500f8cc7c93a941970John McCall if (vla) return emitNonZeroVLAInit(*this, Ty, DestPtr, SrcPtr, SizeVal); 6677143325db76d6c3dabce82500f8cc7c93a941970John McCall 6689021718882441dd391a1960084580d3cd19c423aJohn McCall // Get and call the appropriate llvm.memcpy overload. 6699f0c7cc36d29cf591c33962931f5862847145f3eBenjamin Kramer Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, Align, false); 67088207c9ca218486b93ae7df14e9764cd0c2c3383Chris Lattner return; 6719021718882441dd391a1960084580d3cd19c423aJohn McCall } 6729021718882441dd391a1960084580d3cd19c423aJohn McCall 6739021718882441dd391a1960084580d3cd19c423aJohn McCall // Otherwise, just memset the whole thing to zero. This is legal 6749021718882441dd391a1960084580d3cd19c423aJohn McCall // because in LLVM, all default initializers (other than the ones we just 6759021718882441dd391a1960084580d3cd19c423aJohn McCall // handled above) are guaranteed to have a bit pattern of all zeros. 6769f0c7cc36d29cf591c33962931f5862847145f3eBenjamin Kramer Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal, Align, false); 6773d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson} 6783d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 679d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattnerllvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelStmt *L) { 680d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Make sure that there is a block for the indirect goto. 681d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch == 0) 682d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner GetIndirectGotoBlock(); 6833d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 684ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock(); 6853d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 686d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Make sure the indirect branch includes all of the address-taken blocks. 687d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner IndirectBranch->addDestination(BB); 688d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return llvm::BlockAddress::get(CurFn, BB); 6893d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner} 6901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6913d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattnerllvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() { 692d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If we already made the indirect branch for indirect goto, return its block. 693d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) return IndirectBranch->getParent(); 6943d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 695d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner CGBuilderTy TmpBuilder(createBasicBlock("indirectgoto")); 6963d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 6973d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner // Create the PHI node that indirect gotos will add entries to. 698d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, "indirect.goto.dest"); 6993d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 700d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Create the indirect branch instruction. 701d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal); 702d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return IndirectBranch->getParent(); 7030ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar} 704ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 705d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbarllvm::Value *CodeGenFunction::GetVLASize(const VariableArrayType *VAT) { 706bbed6b964414145b29e7b60b3e538093734ea3f8Eli Friedman llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()]; 7071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 708f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson assert(SizeEntry && "Did not emit size for type"); 709f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson return SizeEntry; 710f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson} 711dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson 712d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbarllvm::Value *CodeGenFunction::EmitVLASize(QualType Ty) { 71360d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson assert(Ty->isVariablyModifiedType() && 71460d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson "Must pass variably modified type to EmitVLASizes!"); 7151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 716d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbar EnsureInsertPoint(); 7171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 71860d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson if (const VariableArrayType *VAT = getContext().getAsVariableArrayType(Ty)) { 719745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian // unknown size indication requires no size computation. 720745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian if (!VAT->getSizeExpr()) 721745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian return 0; 722bbed6b964414145b29e7b60b3e538093734ea3f8Eli Friedman llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()]; 7231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 724fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson if (!SizeEntry) { 72596f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson const llvm::Type *SizeTy = ConvertType(getContext().getSizeType()); 7261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 727ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner // Get the element size; 728ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner QualType ElemTy = VAT->getElementType(); 729ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner llvm::Value *ElemSize; 730fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson if (ElemTy->isVariableArrayType()) 731fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson ElemSize = EmitVLASize(ElemTy); 732ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner else 7334a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson ElemSize = llvm::ConstantInt::get(SizeTy, 734199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck getContext().getTypeSizeInChars(ElemTy).getQuantity()); 7351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 736fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson llvm::Value *NumElements = EmitScalarExpr(VAT->getSizeExpr()); 73796f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson NumElements = Builder.CreateIntCast(NumElements, SizeTy, false, "tmp"); 7381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 739fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson SizeEntry = Builder.CreateMul(ElemSize, NumElements); 740fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson } 7411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 74260d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson return SizeEntry; 743dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson } 7441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 745ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner if (const ArrayType *AT = dyn_cast<ArrayType>(Ty)) { 746ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner EmitVLASize(AT->getElementType()); 747ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner return 0; 7481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 7491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 750075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara if (const ParenType *PT = dyn_cast<ParenType>(Ty)) { 751075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara EmitVLASize(PT->getInnerType()); 752075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return 0; 753075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara } 754075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 755ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner const PointerType *PT = Ty->getAs<PointerType>(); 756ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner assert(PT && "unknown VM type!"); 757ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner EmitVLASize(PT->getPointeeType()); 75860d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson return 0; 759dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson} 7604fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman 7614fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedmanllvm::Value* CodeGenFunction::EmitVAListRef(const Expr* E) { 762bc07a55b68342a230aafd8875cc7a26450dd3f64Dan Gohman if (getContext().getBuiltinVaListType()->isArrayType()) 7634fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman return EmitScalarExpr(E); 7644fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman return EmitLValue(E).getAddress(); 7654fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman} 7666ccc47698d0311ddabf32fa0f6db8e4f09ac96f8Anders Carlsson 7678d308384a220c7dc81755c47cdcbdd87dac25d5bDevang Patelvoid CodeGenFunction::EmitDeclRefExprDbgValue(const DeclRefExpr *E, 768189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall llvm::Constant *Init) { 76925c2c8fb9309050612009a6571e2660e75531348Devang Patel assert (Init && "Invalid DeclRefExpr initializer!"); 77025c2c8fb9309050612009a6571e2660e75531348Devang Patel if (CGDebugInfo *Dbg = getDebugInfo()) 771d2829b76a87a70791184b3cac89900d2cda46ce4Devang Patel Dbg->EmitGlobalVariable(E->getDecl(), Init); 7728d308384a220c7dc81755c47cdcbdd87dac25d5bDevang Patel} 773