CodeGenFunction.cpp revision ad8dcf4a9df0e24051dc31bf9e6f3cd138a34298
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) 325936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall : CodeGenTypeCache(cgm), CGM(cgm), 335936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall Target(CGM.getContext().Target), 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 43d88ea5687968640ada2bc5a10211cbeb68a671ecMike Stump Exceptions = getContext().getLangOptions().Exceptions; 449c276ae0f24d4cee8f7954069d4b8eae45d0447dMike Stump CatchUndefined = getContext().getLangOptions().CatchUndefined; 454c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().getMangleContext().startNewFunction(); 464111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner} 475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerASTContext &CodeGenFunction::getContext() const { 495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return CGM.getContext(); 505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 538b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbarconst llvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) { 548b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar return CGM.getTypes().ConvertTypeForMem(T); 558b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar} 568b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar 575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst llvm::Type *CodeGenFunction::ConvertType(QualType T) { 585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return CGM.getTypes().ConvertType(T); 595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 614111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattnerbool CodeGenFunction::hasAggregateLLVMType(QualType T) { 62e9d34dc7afe06c9adaacad7a678a0cbbf749ea75Anders Carlsson return T->isRecordType() || T->isArrayType() || T->isAnyComplexType() || 63d608cdb7c044365cf4e8764ade1e11e99c176078John McCall T->isObjCObjectType(); 644111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner} 65391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 661c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbarvoid CodeGenFunction::EmitReturnBlock() { 671c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // For cleanliness, we try to avoid emitting the return block for 681c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // simple cases. 691c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); 701c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 711c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar if (CurBB) { 721c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar assert(!CurBB->getTerminator() && "Unexpected terminated block."); 731c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 7496e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar // We have a valid insert point, reuse it if it is empty or there are no 7596e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar // explicit jumps to the return block. 76ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) { 77ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall ReturnBlock.getBlock()->replaceAllUsesWith(CurBB); 78ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall delete ReturnBlock.getBlock(); 7996e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar } else 80ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitBlock(ReturnBlock.getBlock()); 811c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar return; 821c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 831c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 841c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // Otherwise, if the return block is the target of a single direct 851c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // branch then we can just put the code in that block instead. This 861c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // cleans up functions which started with a unified return block. 87ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (ReturnBlock.getBlock()->hasOneUse()) { 881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump llvm::BranchInst *BI = 89ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->use_begin()); 90f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (BI && BI->isUnconditional() && 91ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BI->getSuccessor(0) == ReturnBlock.getBlock()) { 921c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // Reset insertion point and delete the branch. 931c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar Builder.SetInsertPoint(BI->getParent()); 941c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar BI->eraseFromParent(); 95ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall delete ReturnBlock.getBlock(); 961c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar return; 971c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 981c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 991c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 100f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // FIXME: We are at an unreachable point, there is no reason to emit the block 101f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // unless it has uses. However, we still need a place to put the debug 102f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // region.end for now. 1031c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 104ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitBlock(ReturnBlock.getBlock()); 105f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall} 106f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 107f1549f66a8216a78112286e3978cea2c29d6334cJohn McCallstatic void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) { 108f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (!BB) return; 109f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (!BB->use_empty()) 110f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall return CGF.CurFn->getBasicBlockList().push_back(BB); 111f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall delete BB; 1121c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar} 1131c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 114af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbarvoid CodeGenFunction::FinishFunction(SourceLocation EndLoc) { 115391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner assert(BreakContinueStack.empty() && 116391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner "mismatched push/pop in break/continue stack!"); 1171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Emit function epilog (to return). 1191c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar EmitReturnBlock(); 120f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar 121a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar if (ShouldInstrumentFunction()) 122a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar EmitFunctionInstrumentation("__cyg_profile_func_exit"); 1237255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 124f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar // Emit debug descriptor for function end. 125e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson if (CGDebugInfo *DI = getDebugInfo()) { 126f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar DI->setLocation(EndLoc); 1275a6fbcfd8c15a2296f94a0473a68ec09d429827fDevang Patel DI->EmitFunctionEnd(Builder); 128f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar } 129f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar 13035b21b884e5c3447a52a74d7ffaba966b07ac81fChris Lattner EmitFunctionEpilog(*CurFnInfo); 131cce3d4f9812182ed4e551b7cf0fc86576be8d9c5Mike Stump EmitEndEHSpec(CurCodeDecl); 1325ca2084cf9b529563209429857f01fdae9dcdfa5Daniel Dunbar 133f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall assert(EHStack.empty() && 134f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall "did not remove all scopes from cleanup stack!"); 135f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 136d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If someone did an indirect goto, emit the indirect goto block at the end of 137d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // the function. 138d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) { 139d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner EmitBlock(IndirectBranch->getParent()); 140d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner Builder.ClearInsertionPoint(); 141d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 142d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner 143391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // Remove the AllocaInsertPt instruction, which is just a convenience for us. 144481769b5dc102b0256b35581e787909ad5edfab5Chris Lattner llvm::Instruction *Ptr = AllocaInsertPt; 145391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner AllocaInsertPt = 0; 146481769b5dc102b0256b35581e787909ad5edfab5Chris Lattner Ptr->eraseFromParent(); 147d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner 148d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If someone took the address of a label but never did an indirect goto, we 149d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // made a zero entry PHI node, which is illegal, zap it now. 150d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) { 151d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress()); 152d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (PN->getNumIncomingValues() == 0) { 153d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType())); 154d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner PN->eraseFromParent(); 155d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 156d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 157f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 158ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitIfUsed(*this, RethrowBlock.getBlock()); 159f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, TerminateLandingPad); 160f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, TerminateHandler); 161f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, UnreachableBlock); 162744016dde06fcffd50931e94a98c850f8b12cd87John McCall 163744016dde06fcffd50931e94a98c850f8b12cd87John McCall if (CGM.getCodeGenOpts().EmitDeclMetadata) 164744016dde06fcffd50931e94a98c850f8b12cd87John McCall EmitDeclMetadata(); 165c8aa5f1f264fb230c38182adab944232bb160c2bChris Lattner} 166c8aa5f1f264fb230c38182adab944232bb160c2bChris Lattner 1677255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// ShouldInstrumentFunction - Return true if the current function should be 1687255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// instrumented with __cyg_profile_func_* calls 1697255a2d997b15beae82e627052fdb1b2474495c2Chris Lattnerbool CodeGenFunction::ShouldInstrumentFunction() { 1707255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner if (!CGM.getCodeGenOpts().InstrumentFunctions) 1717255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return false; 1727255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner if (CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>()) 1737255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return false; 1747255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return true; 1757255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner} 1767255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 1777255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// EmitFunctionInstrumentation - Emit LLVM code to call the specified 1787255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// instrumentation function with the current function and the call site, if 1797255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// function instrumentation is enabled. 1807255a2d997b15beae82e627052fdb1b2474495c2Chris Lattnervoid CodeGenFunction::EmitFunctionInstrumentation(const char *Fn) { 1818dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner const llvm::PointerType *PointerTy; 1827255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner const llvm::FunctionType *FunctionTy; 1837255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner std::vector<const llvm::Type*> ProfileFuncArgs; 1847255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 1858dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner // void __cyg_profile_func_{enter,exit} (void *this_fn, void *call_site); 186d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall PointerTy = Int8PtrTy; 1878dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner ProfileFuncArgs.push_back(PointerTy); 1888dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner ProfileFuncArgs.push_back(PointerTy); 189d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall FunctionTy = llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()), 190d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall ProfileFuncArgs, false); 1917255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 1927255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner llvm::Constant *F = CGM.CreateRuntimeFunction(FunctionTy, Fn); 1937255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner llvm::CallInst *CallSite = Builder.CreateCall( 1947255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner CGM.getIntrinsic(llvm::Intrinsic::returnaddress, 0, 0), 19577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::ConstantInt::get(Int32Ty, 0), 1967255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner "callsite"); 1977255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 1988dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner Builder.CreateCall2(F, 1998dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner llvm::ConstantExpr::getBitCast(CurFn, PointerTy), 2008dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner CallSite); 2017255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner} 2027255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 203be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divackyvoid CodeGenFunction::EmitMCountInstrumentation() { 204be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky llvm::FunctionType *FTy = 205be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()), false); 206be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky 207be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky llvm::Constant *MCountFn = CGM.CreateRuntimeFunction(FTy, 208be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky Target.getMCountName()); 209be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky Builder.CreateCall(MCountFn); 210be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky} 211be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky 2120ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlssonvoid CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy, 2137c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar llvm::Function *Fn, 2142284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar const FunctionArgList &Args, 2152284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar SourceLocation StartLoc) { 2160ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson const Decl *D = GD.getDecl(); 2170ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson 2184cc1a4703363ff940b6273aeef9d96a87edeb04bAnders Carlsson DidCallStackSave = false; 219b5437d238752dc297e42410e98d38d5250fe0463Chris Lattner CurCodeDecl = CurFuncDecl = D; 2207c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FnRetTy = RetTy; 221bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar CurFn = Fn; 2225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(CurFn->isDeclaration() && "Function already has body?"); 223ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner 224a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen // Pass inline keyword to optimizer if it appears explicitly on any 225a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen // declaration. 226a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) 227a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen for (FunctionDecl::redecl_iterator RI = FD->redecls_begin(), 228a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen RE = FD->redecls_end(); RI != RE; ++RI) 229a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen if (RI->isInlineSpecified()) { 230a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen Fn->addFnAttr(llvm::Attribute::InlineHint); 231a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen break; 232a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen } 233a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen 234f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne if (getContext().getLangOptions().OpenCL) { 235f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne // Add metadata for a kernel function. 236f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) 237f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne if (FD->hasAttr<OpenCLKernelAttr>()) { 238f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne llvm::LLVMContext &Context = getLLVMContext(); 239f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne llvm::NamedMDNode *OpenCLMetadata = 240f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne CGM.getModule().getOrInsertNamedMetadata("opencl.kernels"); 241f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne 242f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne llvm::Value *Op = Fn; 243f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne OpenCLMetadata->addOperand(llvm::MDNode::get(Context, &Op, 1)); 244f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne } 245f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne } 246f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne 24755e874299f2ad827646a4ca9ea38c402aaeb38c9Daniel Dunbar llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn); 2485ca2084cf9b529563209429857f01fdae9dcdfa5Daniel Dunbar 2495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Create a marker to make it easy to insert allocas into the entryblock 25055352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner // later. Don't create this with the builder, because we don't want it 25155352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner // folded. 25277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Value *Undef = llvm::UndefValue::get(Int32Ty); 25377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "", EntryBB); 254f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner if (Builder.isNamePreserving()) 255f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner AllocaInsertPt->setName("allocapt"); 2561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 257f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall ReturnBlock = getJumpDestInCurrentScope("return"); 2581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 25955352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner Builder.SetInsertPoint(EntryBB); 2601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 261af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta // Emit subprogram debug descriptor. 262e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson if (CGDebugInfo *DI = getDebugInfo()) { 263e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall // FIXME: what is going on here and why does it ignore all these 264e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall // interesting type properties? 265e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall QualType FnType = 266e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall getContext().getFunctionType(RetTy, 0, 0, 267e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo()); 268e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 2692284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar DI->setLocation(StartLoc); 2709c6c3a0e3ae09626d2d4b04e4ffa42c3d7cab32bDevang Patel DI->EmitFunctionStart(GD, FnType, CurFn, Builder); 271af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta } 272af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta 273a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar if (ShouldInstrumentFunction()) 274a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar EmitFunctionInstrumentation("__cyg_profile_func_enter"); 2757255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 276be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky if (CGM.getCodeGenOpts().InstrumentForProfiling) 277be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky EmitMCountInstrumentation(); 278be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky 27988b5396b0897f28d22ae3debf4a0d97b33b6c362Daniel Dunbar // FIXME: Leaked. 28004a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // CC info is ignored, hopefully? 28104a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall CurFnInfo = &CGM.getTypes().getFunctionInfo(FnRetTy, Args, 282264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo()); 283b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman 284b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman if (RetTy->isVoidType()) { 285b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman // Void type; nothing to return. 286b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman ReturnValue = 0; 287b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect && 288b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman hasAggregateLLVMType(CurFnInfo->getReturnType())) { 289b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman // Indirect aggregate return; emit returned value directly into sret slot. 290647a1ec397fa13af176d07d9f5d071560a94c7a9Daniel Dunbar // This reduces code size, and affects correctness in C++. 291b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman ReturnValue = CurFn->arg_begin(); 292b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } else { 293647a1ec397fa13af176d07d9f5d071560a94c7a9Daniel Dunbar ReturnValue = CreateIRTemp(RetTy, "retval"); 294b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } 295b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman 296cce3d4f9812182ed4e551b7cf0fc86576be8d9c5Mike Stump EmitStartEHSpec(CurCodeDecl); 29788b5396b0897f28d22ae3debf4a0d97b33b6c362Daniel Dunbar EmitFunctionProlog(*CurFnInfo, CurFn, Args); 2981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2994c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) 3004c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().EmitInstanceFunctionProlog(*this); 3012504941793b549323f9d29c62507cf21d865fadeJohn McCall 302751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson // If any of the arguments have a variably modified type, make sure to 303751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson // emit the type size. 304751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); 305751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson i != e; ++i) { 306751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson QualType Ty = i->second; 307751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson 308751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson if (Ty->isVariablyModifiedType()) 309751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson EmitVLASize(Ty); 310751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson } 3117c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar} 312eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman 3139fc6a7774643a810c8501dae2323e863fefb623eJohn McCallvoid CodeGenFunction::EmitFunctionBody(FunctionArgList &Args) { 3149fc6a7774643a810c8501dae2323e863fefb623eJohn McCall const FunctionDecl *FD = cast<FunctionDecl>(CurGD.getDecl()); 31506a9f3680d22529a2fcf20c52d71cf221d99d910Douglas Gregor assert(FD->getBody()); 31606a9f3680d22529a2fcf20c52d71cf221d99d910Douglas Gregor EmitStmt(FD->getBody()); 317a355e07454463b19829ac92ffd115a097faff0e0John McCall} 318a355e07454463b19829ac92ffd115a097faff0e0John McCall 31939dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// Tries to mark the given function nounwind based on the 32039dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// non-existence of any throwing calls within it. We believe this is 32139dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// lightweight enough to do at -O0. 32239dad53772c42eb36ebec1c81c56ba99d038fb94John McCallstatic void TryMarkNoThrow(llvm::Function *F) { 323b3a29f132794f67108bccc9c7cc3795365e8a965John McCall // LLVM treats 'nounwind' on a function as part of the type, so we 324b3a29f132794f67108bccc9c7cc3795365e8a965John McCall // can't do this on functions that can be overwritten. 325b3a29f132794f67108bccc9c7cc3795365e8a965John McCall if (F->mayBeOverridden()) return; 326b3a29f132794f67108bccc9c7cc3795365e8a965John McCall 32739dad53772c42eb36ebec1c81c56ba99d038fb94John McCall for (llvm::Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI) 32839dad53772c42eb36ebec1c81c56ba99d038fb94John McCall for (llvm::BasicBlock::iterator 32939dad53772c42eb36ebec1c81c56ba99d038fb94John McCall BI = FI->begin(), BE = FI->end(); BI != BE; ++BI) 33039dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(&*BI)) 33139dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (!Call->doesNotThrow()) 33239dad53772c42eb36ebec1c81c56ba99d038fb94John McCall return; 33339dad53772c42eb36ebec1c81c56ba99d038fb94John McCall F->setDoesNotThrow(true); 33439dad53772c42eb36ebec1c81c56ba99d038fb94John McCall} 33539dad53772c42eb36ebec1c81c56ba99d038fb94John McCall 336c997d4278d329e18891aac9698fb991b2d4622ebAnders Carlssonvoid CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn) { 3370ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 3380ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson 339e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson // Check if we should generate debug info for this function. 3401feade8e520be483293dbf55eb57a51720899589Mike Stump if (CGM.getDebugInfo() && !FD->hasAttr<NoDebugAttr>()) 341e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson DebugInfo = CGM.getDebugInfo(); 3421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3437c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FunctionArgList Args; 3444c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall QualType ResTy = FD->getResultType(); 3451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3466a1e0eb557d47e85185e09bdf8721f53f4bf9c9cMike Stump CurGD = GD; 3474c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall if (isa<CXXMethodDecl>(FD) && cast<CXXMethodDecl>(FD)->isInstance()) 3484c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResTy, Args); 3491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 350eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman if (FD->getNumParams()) { 351183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const FunctionProtoType* FProto = FD->getType()->getAs<FunctionProtoType>(); 352eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman assert(FProto && "Function def must have prototype!"); 3537c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar 3547c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) 3551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Args.push_back(std::make_pair(FD->getParamDecl(i), 3567c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FProto->getArgType(i))); 3575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 358af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar 359a355e07454463b19829ac92ffd115a097faff0e0John McCall SourceRange BodyRange; 360a355e07454463b19829ac92ffd115a097faff0e0John McCall if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange(); 3614365bba95be15342575b4f030c6583a770a5da3dAnders Carlsson 362a355e07454463b19829ac92ffd115a097faff0e0John McCall // Emit the standard function prologue. 3634c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall StartFunction(GD, ResTy, Fn, Args, BodyRange.getBegin()); 3641851a12605bc6f1ea70d11974a315340ebaab6ebAnders Carlsson 365a355e07454463b19829ac92ffd115a097faff0e0John McCall // Generate the body of the function. 3669fc6a7774643a810c8501dae2323e863fefb623eJohn McCall if (isa<CXXDestructorDecl>(FD)) 3679fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitDestructorBody(Args); 3689fc6a7774643a810c8501dae2323e863fefb623eJohn McCall else if (isa<CXXConstructorDecl>(FD)) 3699fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitConstructorBody(Args); 3709fc6a7774643a810c8501dae2323e863fefb623eJohn McCall else 3719fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitFunctionBody(Args); 372c33e4ba20304e222692e77f2c6ad26a5d8d32f83Anders Carlsson 373a355e07454463b19829ac92ffd115a097faff0e0John McCall // Emit the standard function epilogue. 374a355e07454463b19829ac92ffd115a097faff0e0John McCall FinishFunction(BodyRange.getEnd()); 37539dad53772c42eb36ebec1c81c56ba99d038fb94John McCall 37639dad53772c42eb36ebec1c81c56ba99d038fb94John McCall // If we haven't marked the function nothrow through other means, do 37739dad53772c42eb36ebec1c81c56ba99d038fb94John McCall // a quick pass now to see if we can. 37839dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (!CurFn->doesNotThrow()) 37939dad53772c42eb36ebec1c81c56ba99d038fb94John McCall TryMarkNoThrow(CurFn); 3805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3820946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// ContainsLabel - Return true if the statement contains a label in it. If 3830946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// this statement is not executed normally, it not containing a label means 3840946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// that we can just remove the code. 3850946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattnerbool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) { 3860946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // Null statement, not a label! 3870946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (S == 0) return false; 3881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3890946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a label, we have to emit the code, consider something like: 3900946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // if (0) { ... foo: bar(); } goto foo; 3910946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<LabelStmt>(S)) 3920946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 3931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3940946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a case/default statement, and we haven't seen a switch, we have 3950946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // to emit the code. 3960946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<SwitchCase>(S) && !IgnoreCaseStmts) 3970946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 3981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3990946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a switch statement, we want to ignore cases below it. 4000946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<SwitchStmt>(S)) 4010946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner IgnoreCaseStmts = true; 4021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4030946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // Scan subexpressions for verboten labels. 4047502c1d3ce8bb97bcc4f7bebef507040bd93b26fJohn McCall for (Stmt::const_child_range I = S->children(); I; ++I) 4050946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (ContainsLabel(*I, IgnoreCaseStmts)) 4060946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 4071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4080946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return false; 4090946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner} 4100946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner 41131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 41231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// ConstantFoldsToSimpleInteger - If the sepcified expression does not fold to 41331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// a constant, or if it does but contains a label, return 0. If it constant 41431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// folds to 'true' and does not contain a label, return 1, if it constant folds 41531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// to 'false' and does not contain a label, return -1. 41631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattnerint CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond) { 41736bc14c3a1cf63ee306df5687ac8e85f924f8639Daniel Dunbar // FIXME: Rename and handle conversion of other evaluatable things 41836bc14c3a1cf63ee306df5687ac8e85f924f8639Daniel Dunbar // to bool. 41964712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson Expr::EvalResult Result; 4201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!Cond->Evaluate(Result, getContext()) || !Result.Val.isInt() || 42164712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson Result.HasSideEffects) 422ef5a66d8171eb95e948107f8ee7707b360aaff25Anders Carlsson return 0; // Not foldable, not integer or not fully evaluatable. 4231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 42431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (CodeGenFunction::ContainsLabel(Cond)) 42531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return 0; // Contains a label. 4261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 42764712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson return Result.Val.getInt().getBoolValue() ? 1 : -1; 42831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner} 42931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 43031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 43131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if 43231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// statement) to the specified blocks. Based on the condition, this might try 43331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// to simplify the codegen of the conditional based on the branch. 43431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// 43531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattnervoid CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond, 43631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::BasicBlock *TrueBlock, 43731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::BasicBlock *FalseBlock) { 43831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (const ParenExpr *PE = dyn_cast<ParenExpr>(Cond)) 43931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(PE->getSubExpr(), TrueBlock, FalseBlock); 4401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 44131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) { 44231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Handle X && Y in a condition. 4432de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CondBOp->getOpcode() == BO_LAnd) { 44431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "1 && X", simplify the code. "0 && X" would have constant 44531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // folded if the case was simple enough. 44631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == 1) { 44731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(1 && X) -> br(X). 44831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 44931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "X && 1", simplify the code to use an uncond branch. 45231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // "X && 0" would have been constant folded to 0. 45331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == 1) { 45431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(X && 1) -> br(X). 45531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 45631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 45831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the LHS as a conditional. If the LHS conditional is false, we 45931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // want to jump to the FalseBlock. 4609615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true"); 461150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 462150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall ConditionalEvaluation eval(*this); 46331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock); 46431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBlock(LHSTrue); 4651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 46608e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson // Any temporaries created here are conditional. 467150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(*this); 46831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 469150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(*this); 47008e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson 47131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return; 4722de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall } else if (CondBOp->getOpcode() == BO_LOr) { 47331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "0 || X", simplify the code. "1 || X" would have constant 47431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // folded if the case was simple enough. 47531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getLHS()) == -1) { 47631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(0 || X) -> br(X). 47731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 47831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 48031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "X || 0", simplify the code to use an uncond branch. 48131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // "X || 1" would have been constant folded to 1. 48231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getRHS()) == -1) { 48331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(X || 0) -> br(X). 48431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 48531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 48731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the LHS as a conditional. If the LHS conditional is true, we 48831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // want to jump to the TrueBlock. 4899615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false"); 490150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 491150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall ConditionalEvaluation eval(*this); 49231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse); 49331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBlock(LHSFalse); 4941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 49508e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson // Any temporaries created here are conditional. 496150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(*this); 49731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 498150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(*this); 49908e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson 50031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return; 50131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 502552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner } 5031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 504552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) { 505552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner // br(!x, t, f) -> br(x, f, t) 5062de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CondUOp->getOpcode() == UO_LNot) 507552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock); 50831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 5091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 51009b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) { 51109b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // Handle ?: operator. 51209b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar 51309b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // Just ignore GNU ?: extension. 51409b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar if (CondOp->getLHS()) { 51509b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f)) 51609b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true"); 51709b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false"); 518150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 519150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall ConditionalEvaluation cond(*this); 52009b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock); 521150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 522150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall cond.begin(*this); 52309b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBlock(LHSBlock); 52409b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock); 525150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall cond.end(*this); 526150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 527150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall cond.begin(*this); 52809b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBlock(RHSBlock); 52909b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock); 530150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall cond.end(*this); 531150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 53209b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar return; 53309b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar } 53409b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar } 53509b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar 53631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the code with the fully general case. 53731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::Value *CondV = EvaluateExprAsBool(Cond); 53831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner Builder.CreateCondBr(CondV, TrueBlock, FalseBlock); 53931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner} 54031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 541488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar/// ErrorUnsupported - Print out an error that codegen doesn't support the 542dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner/// specified stmt yet. 54390df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbarvoid CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type, 54490df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar bool OmitOnError) { 54590df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar CGM.ErrorUnsupported(S, Type, OmitOnError); 546dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner} 547dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner 5487143325db76d6c3dabce82500f8cc7c93a941970John McCall/// emitNonZeroVLAInit - Emit the "zero" initialization of a 5497143325db76d6c3dabce82500f8cc7c93a941970John McCall/// variable-length array whose elements have a non-zero bit-pattern. 5507143325db76d6c3dabce82500f8cc7c93a941970John McCall/// 5517143325db76d6c3dabce82500f8cc7c93a941970John McCall/// \param src - a char* pointing to the bit-pattern for a single 5527143325db76d6c3dabce82500f8cc7c93a941970John McCall/// base element of the array 5537143325db76d6c3dabce82500f8cc7c93a941970John McCall/// \param sizeInChars - the total size of the VLA, in chars 5547143325db76d6c3dabce82500f8cc7c93a941970John McCall/// \param align - the total alignment of the VLA 5557143325db76d6c3dabce82500f8cc7c93a941970John McCallstatic void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType, 5567143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *dest, llvm::Value *src, 5577143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *sizeInChars) { 5587143325db76d6c3dabce82500f8cc7c93a941970John McCall std::pair<CharUnits,CharUnits> baseSizeAndAlign 5597143325db76d6c3dabce82500f8cc7c93a941970John McCall = CGF.getContext().getTypeInfoInChars(baseType); 5607143325db76d6c3dabce82500f8cc7c93a941970John McCall 5617143325db76d6c3dabce82500f8cc7c93a941970John McCall CGBuilderTy &Builder = CGF.Builder; 5627143325db76d6c3dabce82500f8cc7c93a941970John McCall 5637143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *baseSizeInChars 5647143325db76d6c3dabce82500f8cc7c93a941970John McCall = llvm::ConstantInt::get(CGF.IntPtrTy, baseSizeAndAlign.first.getQuantity()); 5657143325db76d6c3dabce82500f8cc7c93a941970John McCall 5667143325db76d6c3dabce82500f8cc7c93a941970John McCall const llvm::Type *i8p = Builder.getInt8PtrTy(); 5677143325db76d6c3dabce82500f8cc7c93a941970John McCall 5687143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *begin = Builder.CreateBitCast(dest, i8p, "vla.begin"); 5697143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *end = Builder.CreateInBoundsGEP(dest, sizeInChars, "vla.end"); 5707143325db76d6c3dabce82500f8cc7c93a941970John McCall 5717143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock(); 5727143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *loopBB = CGF.createBasicBlock("vla-init.loop"); 5737143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *contBB = CGF.createBasicBlock("vla-init.cont"); 5747143325db76d6c3dabce82500f8cc7c93a941970John McCall 5757143325db76d6c3dabce82500f8cc7c93a941970John McCall // Make a loop over the VLA. C99 guarantees that the VLA element 5767143325db76d6c3dabce82500f8cc7c93a941970John McCall // count must be nonzero. 5777143325db76d6c3dabce82500f8cc7c93a941970John McCall CGF.EmitBlock(loopBB); 5787143325db76d6c3dabce82500f8cc7c93a941970John McCall 5797143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::PHINode *cur = Builder.CreatePHI(i8p, "vla.cur"); 5807143325db76d6c3dabce82500f8cc7c93a941970John McCall cur->reserveOperandSpace(2); 5817143325db76d6c3dabce82500f8cc7c93a941970John McCall cur->addIncoming(begin, originBB); 5827143325db76d6c3dabce82500f8cc7c93a941970John McCall 5837143325db76d6c3dabce82500f8cc7c93a941970John McCall // memcpy the individual element bit-pattern. 5847143325db76d6c3dabce82500f8cc7c93a941970John McCall Builder.CreateMemCpy(cur, src, baseSizeInChars, 5857143325db76d6c3dabce82500f8cc7c93a941970John McCall baseSizeAndAlign.second.getQuantity(), 5867143325db76d6c3dabce82500f8cc7c93a941970John McCall /*volatile*/ false); 5877143325db76d6c3dabce82500f8cc7c93a941970John McCall 5887143325db76d6c3dabce82500f8cc7c93a941970John McCall // Go to the next element. 5897143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *next = Builder.CreateConstInBoundsGEP1_32(cur, 1, "vla.next"); 5907143325db76d6c3dabce82500f8cc7c93a941970John McCall 5917143325db76d6c3dabce82500f8cc7c93a941970John McCall // Leave if that's the end of the VLA. 5927143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *done = Builder.CreateICmpEQ(next, end, "vla-init.isdone"); 5937143325db76d6c3dabce82500f8cc7c93a941970John McCall Builder.CreateCondBr(done, contBB, loopBB); 5947143325db76d6c3dabce82500f8cc7c93a941970John McCall cur->addIncoming(next, loopBB); 5957143325db76d6c3dabce82500f8cc7c93a941970John McCall 5967143325db76d6c3dabce82500f8cc7c93a941970John McCall CGF.EmitBlock(contBB); 5977143325db76d6c3dabce82500f8cc7c93a941970John McCall} 5987143325db76d6c3dabce82500f8cc7c93a941970John McCall 5991884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlssonvoid 6001884eb0b5c55edda4893ddec45e7dbad79758782Anders CarlssonCodeGenFunction::EmitNullInitialization(llvm::Value *DestPtr, QualType Ty) { 6010d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson // Ignore empty classes in C++. 6020d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (getContext().getLangOptions().CPlusPlus) { 6030d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (const RecordType *RT = Ty->getAs<RecordType>()) { 6040d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty()) 6050d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson return; 6060d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson } 6070d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson } 6089021718882441dd391a1960084580d3cd19c423aJohn McCall 6099021718882441dd391a1960084580d3cd19c423aJohn McCall // Cast the dest ptr to the appropriate i8 pointer type. 6109021718882441dd391a1960084580d3cd19c423aJohn McCall unsigned DestAS = 6119021718882441dd391a1960084580d3cd19c423aJohn McCall cast<llvm::PointerType>(DestPtr->getType())->getAddressSpace(); 6129f0c7cc36d29cf591c33962931f5862847145f3eBenjamin Kramer const llvm::Type *BP = Builder.getInt8PtrTy(DestAS); 6133d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson if (DestPtr->getType() != BP) 6143d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp"); 6153d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 6163d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson // Get size and alignment info for this aggregate. 6173d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson std::pair<uint64_t, unsigned> TypeInfo = getContext().getTypeInfo(Ty); 6189f0c7cc36d29cf591c33962931f5862847145f3eBenjamin Kramer uint64_t Size = TypeInfo.first / 8; 6199f0c7cc36d29cf591c33962931f5862847145f3eBenjamin Kramer unsigned Align = TypeInfo.second / 8; 6203d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 6215576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall llvm::Value *SizeVal; 6227143325db76d6c3dabce82500f8cc7c93a941970John McCall const VariableArrayType *vla; 6239021718882441dd391a1960084580d3cd19c423aJohn McCall 6245576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall // Don't bother emitting a zero-byte memset. 6255576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall if (Size == 0) { 6265576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall // But note that getTypeInfo returns 0 for a VLA. 6275576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall if (const VariableArrayType *vlaType = 6285576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall dyn_cast_or_null<VariableArrayType>( 6295576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall getContext().getAsArrayType(Ty))) { 6305576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall SizeVal = GetVLASize(vlaType); 6317143325db76d6c3dabce82500f8cc7c93a941970John McCall vla = vlaType; 6325576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } else { 6335576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall return; 6345576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } 6355576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } else { 6365576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall SizeVal = llvm::ConstantInt::get(IntPtrTy, Size); 6377143325db76d6c3dabce82500f8cc7c93a941970John McCall vla = 0; 6385576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } 6399021718882441dd391a1960084580d3cd19c423aJohn McCall 6409021718882441dd391a1960084580d3cd19c423aJohn McCall // If the type contains a pointer to data member we can't memset it to zero. 6419021718882441dd391a1960084580d3cd19c423aJohn McCall // Instead, create a null constant and copy it to the destination. 6427143325db76d6c3dabce82500f8cc7c93a941970John McCall // TODO: there are other patterns besides zero that we can usefully memset, 6437143325db76d6c3dabce82500f8cc7c93a941970John McCall // like -1, which happens to be the pattern used by member-pointers. 644f16aa103d3afd42fbca2ab346f191bf745cec092John McCall if (!CGM.getTypes().isZeroInitializable(Ty)) { 6457143325db76d6c3dabce82500f8cc7c93a941970John McCall // For a VLA, emit a single element, then splat that over the VLA. 6467143325db76d6c3dabce82500f8cc7c93a941970John McCall if (vla) Ty = getContext().getBaseElementType(vla); 6475576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall 6489021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty); 6499021718882441dd391a1960084580d3cd19c423aJohn McCall 6509021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::GlobalVariable *NullVariable = 6519021718882441dd391a1960084580d3cd19c423aJohn McCall new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(), 6529021718882441dd391a1960084580d3cd19c423aJohn McCall /*isConstant=*/true, 6539021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::GlobalVariable::PrivateLinkage, 6549021718882441dd391a1960084580d3cd19c423aJohn McCall NullConstant, llvm::Twine()); 6559021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::Value *SrcPtr = 6569021718882441dd391a1960084580d3cd19c423aJohn McCall Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()); 6579021718882441dd391a1960084580d3cd19c423aJohn McCall 6587143325db76d6c3dabce82500f8cc7c93a941970John McCall if (vla) return emitNonZeroVLAInit(*this, Ty, DestPtr, SrcPtr, SizeVal); 6597143325db76d6c3dabce82500f8cc7c93a941970John McCall 6609021718882441dd391a1960084580d3cd19c423aJohn McCall // Get and call the appropriate llvm.memcpy overload. 6619f0c7cc36d29cf591c33962931f5862847145f3eBenjamin Kramer Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, Align, false); 66288207c9ca218486b93ae7df14e9764cd0c2c3383Chris Lattner return; 6639021718882441dd391a1960084580d3cd19c423aJohn McCall } 6649021718882441dd391a1960084580d3cd19c423aJohn McCall 6659021718882441dd391a1960084580d3cd19c423aJohn McCall // Otherwise, just memset the whole thing to zero. This is legal 6669021718882441dd391a1960084580d3cd19c423aJohn McCall // because in LLVM, all default initializers (other than the ones we just 6679021718882441dd391a1960084580d3cd19c423aJohn McCall // handled above) are guaranteed to have a bit pattern of all zeros. 6689f0c7cc36d29cf591c33962931f5862847145f3eBenjamin Kramer Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal, Align, false); 6693d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson} 6703d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 671ad8dcf4a9df0e24051dc31bf9e6f3cd138a34298Chris Lattnerllvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelDecl *L) { 672d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Make sure that there is a block for the indirect goto. 673d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch == 0) 674d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner GetIndirectGotoBlock(); 6753d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 676ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock(); 6773d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 678d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Make sure the indirect branch includes all of the address-taken blocks. 679d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner IndirectBranch->addDestination(BB); 680d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return llvm::BlockAddress::get(CurFn, BB); 6813d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner} 6821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6833d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattnerllvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() { 684d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If we already made the indirect branch for indirect goto, return its block. 685d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) return IndirectBranch->getParent(); 6863d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 687d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner CGBuilderTy TmpBuilder(createBasicBlock("indirectgoto")); 6883d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 6893d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner // Create the PHI node that indirect gotos will add entries to. 690d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, "indirect.goto.dest"); 6913d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 692d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Create the indirect branch instruction. 693d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal); 694d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return IndirectBranch->getParent(); 6950ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar} 696ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 697d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbarllvm::Value *CodeGenFunction::GetVLASize(const VariableArrayType *VAT) { 698bbed6b964414145b29e7b60b3e538093734ea3f8Eli Friedman llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()]; 6991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 700f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson assert(SizeEntry && "Did not emit size for type"); 701f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson return SizeEntry; 702f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson} 703dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson 704d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbarllvm::Value *CodeGenFunction::EmitVLASize(QualType Ty) { 70560d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson assert(Ty->isVariablyModifiedType() && 70660d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson "Must pass variably modified type to EmitVLASizes!"); 7071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 708d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbar EnsureInsertPoint(); 7091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 71060d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson if (const VariableArrayType *VAT = getContext().getAsVariableArrayType(Ty)) { 711745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian // unknown size indication requires no size computation. 712745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian if (!VAT->getSizeExpr()) 713745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian return 0; 714bbed6b964414145b29e7b60b3e538093734ea3f8Eli Friedman llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()]; 7151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 716fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson if (!SizeEntry) { 71796f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson const llvm::Type *SizeTy = ConvertType(getContext().getSizeType()); 7181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 719ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner // Get the element size; 720ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner QualType ElemTy = VAT->getElementType(); 721ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner llvm::Value *ElemSize; 722fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson if (ElemTy->isVariableArrayType()) 723fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson ElemSize = EmitVLASize(ElemTy); 724ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner else 7254a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson ElemSize = llvm::ConstantInt::get(SizeTy, 726199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck getContext().getTypeSizeInChars(ElemTy).getQuantity()); 7271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 728fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson llvm::Value *NumElements = EmitScalarExpr(VAT->getSizeExpr()); 72996f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson NumElements = Builder.CreateIntCast(NumElements, SizeTy, false, "tmp"); 7301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 731fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson SizeEntry = Builder.CreateMul(ElemSize, NumElements); 732fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson } 7331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 73460d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson return SizeEntry; 735dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson } 7361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 737ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner if (const ArrayType *AT = dyn_cast<ArrayType>(Ty)) { 738ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner EmitVLASize(AT->getElementType()); 739ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner return 0; 7401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 7411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 742075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara if (const ParenType *PT = dyn_cast<ParenType>(Ty)) { 743075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara EmitVLASize(PT->getInnerType()); 744075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return 0; 745075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara } 746075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 747ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner const PointerType *PT = Ty->getAs<PointerType>(); 748ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner assert(PT && "unknown VM type!"); 749ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner EmitVLASize(PT->getPointeeType()); 75060d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson return 0; 751dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson} 7524fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman 7534fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedmanllvm::Value* CodeGenFunction::EmitVAListRef(const Expr* E) { 754bc07a55b68342a230aafd8875cc7a26450dd3f64Dan Gohman if (getContext().getBuiltinVaListType()->isArrayType()) 7554fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman return EmitScalarExpr(E); 7564fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman return EmitLValue(E).getAddress(); 7574fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman} 7586ccc47698d0311ddabf32fa0f6db8e4f09ac96f8Anders Carlsson 7598d308384a220c7dc81755c47cdcbdd87dac25d5bDevang Patelvoid CodeGenFunction::EmitDeclRefExprDbgValue(const DeclRefExpr *E, 760189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall llvm::Constant *Init) { 76125c2c8fb9309050612009a6571e2660e75531348Devang Patel assert (Init && "Invalid DeclRefExpr initializer!"); 76225c2c8fb9309050612009a6571e2660e75531348Devang Patel if (CGDebugInfo *Dbg = getDebugInfo()) 763d2829b76a87a70791184b3cac89900d2cda46ce4Devang Patel Dbg->EmitGlobalVariable(E->getDecl(), Init); 7648d308384a220c7dc81755c47cdcbdd87dac25d5bDevang Patel} 765