CodeGenFunction.cpp revision 79be76c0e360d9e9c44285c9838af02adc43e55f
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), 36aa11289f754d220c9c155b68a4f84cdcfcefef6aDevang Patel ExceptionSlot(0), DebugInfo(0), DisableDebugInfo(false), 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) { 42c1cfdf8647a499b6b3024f4bd14a236cddb23988Anders Carlsson 439c276ae0f24d4cee8f7954069d4b8eae45d0447dMike Stump CatchUndefined = getContext().getLangOptions().CatchUndefined; 444c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().getMangleContext().startNewFunction(); 454111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner} 465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerASTContext &CodeGenFunction::getContext() const { 485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return CGM.getContext(); 495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 528b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbarconst llvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) { 538b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar return CGM.getTypes().ConvertTypeForMem(T); 548b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar} 558b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar 565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst llvm::Type *CodeGenFunction::ConvertType(QualType T) { 575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return CGM.getTypes().ConvertType(T); 585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 604111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattnerbool CodeGenFunction::hasAggregateLLVMType(QualType T) { 61e9d34dc7afe06c9adaacad7a678a0cbbf749ea75Anders Carlsson return T->isRecordType() || T->isArrayType() || T->isAnyComplexType() || 62d608cdb7c044365cf4e8764ade1e11e99c176078John McCall T->isObjCObjectType(); 634111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner} 64391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 651c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbarvoid CodeGenFunction::EmitReturnBlock() { 661c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // For cleanliness, we try to avoid emitting the return block for 671c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // simple cases. 681c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); 691c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 701c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar if (CurBB) { 711c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar assert(!CurBB->getTerminator() && "Unexpected terminated block."); 721c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 7396e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar // We have a valid insert point, reuse it if it is empty or there are no 7496e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar // explicit jumps to the return block. 75ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) { 76ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall ReturnBlock.getBlock()->replaceAllUsesWith(CurBB); 77ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall delete ReturnBlock.getBlock(); 7896e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar } else 79ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitBlock(ReturnBlock.getBlock()); 801c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar return; 811c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 821c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 831c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // Otherwise, if the return block is the target of a single direct 841c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // branch then we can just put the code in that block instead. This 851c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // cleans up functions which started with a unified return block. 86ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (ReturnBlock.getBlock()->hasOneUse()) { 871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump llvm::BranchInst *BI = 88ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->use_begin()); 89f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (BI && BI->isUnconditional() && 90ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BI->getSuccessor(0) == ReturnBlock.getBlock()) { 911c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // Reset insertion point and delete the branch. 921c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar Builder.SetInsertPoint(BI->getParent()); 931c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar BI->eraseFromParent(); 94ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall delete ReturnBlock.getBlock(); 951c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar return; 961c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 971c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 981c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 99f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // FIXME: We are at an unreachable point, there is no reason to emit the block 100f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // unless it has uses. However, we still need a place to put the debug 101f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // region.end for now. 1021c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 103ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitBlock(ReturnBlock.getBlock()); 104f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall} 105f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 106f1549f66a8216a78112286e3978cea2c29d6334cJohn McCallstatic void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) { 107f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (!BB) return; 108f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (!BB->use_empty()) 109f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall return CGF.CurFn->getBasicBlockList().push_back(BB); 110f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall delete BB; 1111c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar} 1121c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 113af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbarvoid CodeGenFunction::FinishFunction(SourceLocation EndLoc) { 114391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner assert(BreakContinueStack.empty() && 115391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner "mismatched push/pop in break/continue stack!"); 1161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Emit function epilog (to return). 1181c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar EmitReturnBlock(); 119f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar 120a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar if (ShouldInstrumentFunction()) 121a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar EmitFunctionInstrumentation("__cyg_profile_func_exit"); 1227255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 123f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar // Emit debug descriptor for function end. 124e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson if (CGDebugInfo *DI = getDebugInfo()) { 125f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar DI->setLocation(EndLoc); 1265a6fbcfd8c15a2296f94a0473a68ec09d429827fDevang Patel DI->EmitFunctionEnd(Builder); 127f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar } 128f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar 12935b21b884e5c3447a52a74d7ffaba966b07ac81fChris Lattner EmitFunctionEpilog(*CurFnInfo); 130cce3d4f9812182ed4e551b7cf0fc86576be8d9c5Mike Stump EmitEndEHSpec(CurCodeDecl); 1315ca2084cf9b529563209429857f01fdae9dcdfa5Daniel Dunbar 132f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall assert(EHStack.empty() && 133f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall "did not remove all scopes from cleanup stack!"); 134f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 135d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If someone did an indirect goto, emit the indirect goto block at the end of 136d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // the function. 137d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) { 138d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner EmitBlock(IndirectBranch->getParent()); 139d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner Builder.ClearInsertionPoint(); 140d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 141d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner 142391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // Remove the AllocaInsertPt instruction, which is just a convenience for us. 143481769b5dc102b0256b35581e787909ad5edfab5Chris Lattner llvm::Instruction *Ptr = AllocaInsertPt; 144391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner AllocaInsertPt = 0; 145481769b5dc102b0256b35581e787909ad5edfab5Chris Lattner Ptr->eraseFromParent(); 146d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner 147d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If someone took the address of a label but never did an indirect goto, we 148d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // made a zero entry PHI node, which is illegal, zap it now. 149d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) { 150d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress()); 151d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (PN->getNumIncomingValues() == 0) { 152d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType())); 153d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner PN->eraseFromParent(); 154d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 155d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 156f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 157ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitIfUsed(*this, RethrowBlock.getBlock()); 158f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, TerminateLandingPad); 159f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, TerminateHandler); 160f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, UnreachableBlock); 161744016dde06fcffd50931e94a98c850f8b12cd87John McCall 162744016dde06fcffd50931e94a98c850f8b12cd87John McCall if (CGM.getCodeGenOpts().EmitDeclMetadata) 163744016dde06fcffd50931e94a98c850f8b12cd87John McCall EmitDeclMetadata(); 164c8aa5f1f264fb230c38182adab944232bb160c2bChris Lattner} 165c8aa5f1f264fb230c38182adab944232bb160c2bChris Lattner 1667255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// ShouldInstrumentFunction - Return true if the current function should be 1677255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// instrumented with __cyg_profile_func_* calls 1687255a2d997b15beae82e627052fdb1b2474495c2Chris Lattnerbool CodeGenFunction::ShouldInstrumentFunction() { 1697255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner if (!CGM.getCodeGenOpts().InstrumentFunctions) 1707255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return false; 1717255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner if (CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>()) 1727255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return false; 1737255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return true; 1747255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner} 1757255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 1767255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// EmitFunctionInstrumentation - Emit LLVM code to call the specified 1777255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// instrumentation function with the current function and the call site, if 1787255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// function instrumentation is enabled. 1797255a2d997b15beae82e627052fdb1b2474495c2Chris Lattnervoid CodeGenFunction::EmitFunctionInstrumentation(const char *Fn) { 1808dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner const llvm::PointerType *PointerTy; 1817255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner const llvm::FunctionType *FunctionTy; 1827255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner std::vector<const llvm::Type*> ProfileFuncArgs; 1837255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 1848dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner // void __cyg_profile_func_{enter,exit} (void *this_fn, void *call_site); 185d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall PointerTy = Int8PtrTy; 1868dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner ProfileFuncArgs.push_back(PointerTy); 1878dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner ProfileFuncArgs.push_back(PointerTy); 188d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall FunctionTy = llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()), 189d16c2cf1cafa413709aa487cbbd5dc392f1ba1ffJohn McCall ProfileFuncArgs, false); 1907255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 1917255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner llvm::Constant *F = CGM.CreateRuntimeFunction(FunctionTy, Fn); 1927255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner llvm::CallInst *CallSite = Builder.CreateCall( 1937255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner CGM.getIntrinsic(llvm::Intrinsic::returnaddress, 0, 0), 19477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::ConstantInt::get(Int32Ty, 0), 1957255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner "callsite"); 1967255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 1978dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner Builder.CreateCall2(F, 1988dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner llvm::ConstantExpr::getBitCast(CurFn, PointerTy), 1998dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner CallSite); 2007255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner} 2017255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 202be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divackyvoid CodeGenFunction::EmitMCountInstrumentation() { 203be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky llvm::FunctionType *FTy = 204be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()), false); 205be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky 206be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky llvm::Constant *MCountFn = CGM.CreateRuntimeFunction(FTy, 207be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky Target.getMCountName()); 208be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky Builder.CreateCall(MCountFn); 209be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky} 210be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky 2110ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlssonvoid CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy, 2127c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar llvm::Function *Fn, 213d26bc76c98006609002d9930f8840490e88ac5b5John McCall const CGFunctionInfo &FnInfo, 2142284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar const FunctionArgList &Args, 2159c6082fe89c61af697f017aa80937581cc2128d8Tilmann Scheller 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; 222d26bc76c98006609002d9930f8840490e88ac5b5John McCall CurFnInfo = &FnInfo; 2235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(CurFn->isDeclaration() && "Function already has body?"); 224ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner 225a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen // Pass inline keyword to optimizer if it appears explicitly on any 226a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen // declaration. 227a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) 228a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen for (FunctionDecl::redecl_iterator RI = FD->redecls_begin(), 229a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen RE = FD->redecls_end(); RI != RE; ++RI) 230a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen if (RI->isInlineSpecified()) { 231a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen Fn->addFnAttr(llvm::Attribute::InlineHint); 232a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen break; 233a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen } 234a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen 235f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne if (getContext().getLangOptions().OpenCL) { 236f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne // Add metadata for a kernel function. 237f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) 238f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne if (FD->hasAttr<OpenCLKernelAttr>()) { 239f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne llvm::LLVMContext &Context = getLLVMContext(); 240f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne llvm::NamedMDNode *OpenCLMetadata = 241f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne CGM.getModule().getOrInsertNamedMetadata("opencl.kernels"); 242f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne 243f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne llvm::Value *Op = Fn; 2446f141659cab11109d9931d92d0988f8850778de3Jay Foad OpenCLMetadata->addOperand(llvm::MDNode::get(Context, Op)); 245f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne } 246f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne } 247f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne 24855e874299f2ad827646a4ca9ea38c402aaeb38c9Daniel Dunbar llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn); 2495ca2084cf9b529563209429857f01fdae9dcdfa5Daniel Dunbar 2505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Create a marker to make it easy to insert allocas into the entryblock 25155352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner // later. Don't create this with the builder, because we don't want it 25255352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner // folded. 25377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Value *Undef = llvm::UndefValue::get(Int32Ty); 25477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "", EntryBB); 255f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner if (Builder.isNamePreserving()) 256f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner AllocaInsertPt->setName("allocapt"); 2571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 258f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall ReturnBlock = getJumpDestInCurrentScope("return"); 2591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 26055352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner Builder.SetInsertPoint(EntryBB); 2611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 262af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta // Emit subprogram debug descriptor. 263e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson if (CGDebugInfo *DI = getDebugInfo()) { 264e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall // FIXME: what is going on here and why does it ignore all these 265e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall // interesting type properties? 266e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall QualType FnType = 267e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall getContext().getFunctionType(RetTy, 0, 0, 268e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo()); 269e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 2702284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar DI->setLocation(StartLoc); 2719c6c3a0e3ae09626d2d4b04e4ffa42c3d7cab32bDevang Patel DI->EmitFunctionStart(GD, FnType, CurFn, Builder); 272af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta } 273af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta 274a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar if (ShouldInstrumentFunction()) 275a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar EmitFunctionInstrumentation("__cyg_profile_func_enter"); 2767255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 277be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky if (CGM.getCodeGenOpts().InstrumentForProfiling) 278be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky EmitMCountInstrumentation(); 279be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky 280b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman if (RetTy->isVoidType()) { 281b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman // Void type; nothing to return. 282b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman ReturnValue = 0; 283b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect && 284b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman hasAggregateLLVMType(CurFnInfo->getReturnType())) { 285b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman // Indirect aggregate return; emit returned value directly into sret slot. 286647a1ec397fa13af176d07d9f5d071560a94c7a9Daniel Dunbar // This reduces code size, and affects correctness in C++. 287b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman ReturnValue = CurFn->arg_begin(); 288b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } else { 289647a1ec397fa13af176d07d9f5d071560a94c7a9Daniel Dunbar ReturnValue = CreateIRTemp(RetTy, "retval"); 290b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } 291b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman 292cce3d4f9812182ed4e551b7cf0fc86576be8d9c5Mike Stump EmitStartEHSpec(CurCodeDecl); 29388b5396b0897f28d22ae3debf4a0d97b33b6c362Daniel Dunbar EmitFunctionProlog(*CurFnInfo, CurFn, Args); 2941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2954c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) 2964c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().EmitInstanceFunctionProlog(*this); 2972504941793b549323f9d29c62507cf21d865fadeJohn McCall 298751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson // If any of the arguments have a variably modified type, make sure to 299751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson // emit the type size. 300751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); 301751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson i != e; ++i) { 302d26bc76c98006609002d9930f8840490e88ac5b5John McCall QualType Ty = (*i)->getType(); 303751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson 304751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson if (Ty->isVariablyModifiedType()) 305751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson EmitVLASize(Ty); 306751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson } 3077c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar} 308eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman 3099fc6a7774643a810c8501dae2323e863fefb623eJohn McCallvoid CodeGenFunction::EmitFunctionBody(FunctionArgList &Args) { 3109fc6a7774643a810c8501dae2323e863fefb623eJohn McCall const FunctionDecl *FD = cast<FunctionDecl>(CurGD.getDecl()); 31106a9f3680d22529a2fcf20c52d71cf221d99d910Douglas Gregor assert(FD->getBody()); 31206a9f3680d22529a2fcf20c52d71cf221d99d910Douglas Gregor EmitStmt(FD->getBody()); 313a355e07454463b19829ac92ffd115a097faff0e0John McCall} 314a355e07454463b19829ac92ffd115a097faff0e0John McCall 31539dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// Tries to mark the given function nounwind based on the 31639dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// non-existence of any throwing calls within it. We believe this is 31739dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// lightweight enough to do at -O0. 31839dad53772c42eb36ebec1c81c56ba99d038fb94John McCallstatic void TryMarkNoThrow(llvm::Function *F) { 319b3a29f132794f67108bccc9c7cc3795365e8a965John McCall // LLVM treats 'nounwind' on a function as part of the type, so we 320b3a29f132794f67108bccc9c7cc3795365e8a965John McCall // can't do this on functions that can be overwritten. 321b3a29f132794f67108bccc9c7cc3795365e8a965John McCall if (F->mayBeOverridden()) return; 322b3a29f132794f67108bccc9c7cc3795365e8a965John McCall 32339dad53772c42eb36ebec1c81c56ba99d038fb94John McCall for (llvm::Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI) 32439dad53772c42eb36ebec1c81c56ba99d038fb94John McCall for (llvm::BasicBlock::iterator 32539dad53772c42eb36ebec1c81c56ba99d038fb94John McCall BI = FI->begin(), BE = FI->end(); BI != BE; ++BI) 32639dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(&*BI)) 32739dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (!Call->doesNotThrow()) 32839dad53772c42eb36ebec1c81c56ba99d038fb94John McCall return; 32939dad53772c42eb36ebec1c81c56ba99d038fb94John McCall F->setDoesNotThrow(true); 33039dad53772c42eb36ebec1c81c56ba99d038fb94John McCall} 33139dad53772c42eb36ebec1c81c56ba99d038fb94John McCall 332d26bc76c98006609002d9930f8840490e88ac5b5John McCallvoid CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn, 333d26bc76c98006609002d9930f8840490e88ac5b5John McCall const CGFunctionInfo &FnInfo) { 3340ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 3350ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson 336e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson // Check if we should generate debug info for this function. 337aa11289f754d220c9c155b68a4f84cdcfcefef6aDevang Patel if (CGM.getModuleDebugInfo() && !FD->hasAttr<NoDebugAttr>()) 338aa11289f754d220c9c155b68a4f84cdcfcefef6aDevang Patel DebugInfo = CGM.getModuleDebugInfo(); 3391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3407c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FunctionArgList Args; 3414c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall QualType ResTy = FD->getResultType(); 3421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3436a1e0eb557d47e85185e09bdf8721f53f4bf9c9cMike Stump CurGD = GD; 3444c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall if (isa<CXXMethodDecl>(FD) && cast<CXXMethodDecl>(FD)->isInstance()) 3454c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResTy, Args); 3461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 347d26bc76c98006609002d9930f8840490e88ac5b5John McCall if (FD->getNumParams()) 3487c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) 349d26bc76c98006609002d9930f8840490e88ac5b5John McCall Args.push_back(FD->getParamDecl(i)); 350af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar 351a355e07454463b19829ac92ffd115a097faff0e0John McCall SourceRange BodyRange; 352a355e07454463b19829ac92ffd115a097faff0e0John McCall if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange(); 3534365bba95be15342575b4f030c6583a770a5da3dAnders Carlsson 354a355e07454463b19829ac92ffd115a097faff0e0John McCall // Emit the standard function prologue. 355d26bc76c98006609002d9930f8840490e88ac5b5John McCall StartFunction(GD, ResTy, Fn, FnInfo, Args, BodyRange.getBegin()); 3561851a12605bc6f1ea70d11974a315340ebaab6ebAnders Carlsson 357a355e07454463b19829ac92ffd115a097faff0e0John McCall // Generate the body of the function. 3589fc6a7774643a810c8501dae2323e863fefb623eJohn McCall if (isa<CXXDestructorDecl>(FD)) 3599fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitDestructorBody(Args); 3609fc6a7774643a810c8501dae2323e863fefb623eJohn McCall else if (isa<CXXConstructorDecl>(FD)) 3619fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitConstructorBody(Args); 3629fc6a7774643a810c8501dae2323e863fefb623eJohn McCall else 3639fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitFunctionBody(Args); 364c33e4ba20304e222692e77f2c6ad26a5d8d32f83Anders Carlsson 365a355e07454463b19829ac92ffd115a097faff0e0John McCall // Emit the standard function epilogue. 366a355e07454463b19829ac92ffd115a097faff0e0John McCall FinishFunction(BodyRange.getEnd()); 36739dad53772c42eb36ebec1c81c56ba99d038fb94John McCall 36839dad53772c42eb36ebec1c81c56ba99d038fb94John McCall // If we haven't marked the function nothrow through other means, do 36939dad53772c42eb36ebec1c81c56ba99d038fb94John McCall // a quick pass now to see if we can. 37039dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (!CurFn->doesNotThrow()) 37139dad53772c42eb36ebec1c81c56ba99d038fb94John McCall TryMarkNoThrow(CurFn); 3725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3740946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// ContainsLabel - Return true if the statement contains a label in it. If 3750946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// this statement is not executed normally, it not containing a label means 3760946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// that we can just remove the code. 3770946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattnerbool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) { 3780946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // Null statement, not a label! 3790946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (S == 0) return false; 3801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3810946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a label, we have to emit the code, consider something like: 3820946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // if (0) { ... foo: bar(); } goto foo; 383ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // 384ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // TODO: If anyone cared, we could track __label__'s, since we know that you 385ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // can't jump to one from outside their declared region. 3860946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<LabelStmt>(S)) 3870946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 388ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 3890946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a case/default statement, and we haven't seen a switch, we have 3900946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // to emit the code. 3910946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<SwitchCase>(S) && !IgnoreCaseStmts) 3920946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 3931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3940946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a switch statement, we want to ignore cases below it. 3950946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<SwitchStmt>(S)) 3960946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner IgnoreCaseStmts = true; 3971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3980946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // Scan subexpressions for verboten labels. 3997502c1d3ce8bb97bcc4f7bebef507040bd93b26fJohn McCall for (Stmt::const_child_range I = S->children(); I; ++I) 4000946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (ContainsLabel(*I, IgnoreCaseStmts)) 4010946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 4021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4030946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return false; 4040946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner} 4050946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner 406ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// containsBreak - Return true if the statement contains a break out of it. 407ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// If the statement (recursively) contains a switch or loop with a break 408ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// inside of it, this is fine. 409ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattnerbool CodeGenFunction::containsBreak(const Stmt *S) { 410ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // Null statement, not a label! 411ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner if (S == 0) return false; 412ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 413ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // If this is a switch or loop that defines its own break scope, then we can 414ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // include it and anything inside of it. 415ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || isa<DoStmt>(S) || 416ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner isa<ForStmt>(S)) 4172bef7f5499541e3b68f114cc4d7d197e9a902fe7Chris Lattner return false; 4182bef7f5499541e3b68f114cc4d7d197e9a902fe7Chris Lattner 4192bef7f5499541e3b68f114cc4d7d197e9a902fe7Chris Lattner if (isa<BreakStmt>(S)) 420ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner return true; 421ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 422ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // Scan subexpressions for verboten breaks. 423ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner for (Stmt::const_child_range I = S->children(); I; ++I) 424ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner if (containsBreak(*I)) 425ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner return true; 426ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 427ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner return false; 428ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner} 429ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 43031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 431c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner/// ConstantFoldsToSimpleInteger - If the specified expression does not fold 432c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner/// to a constant, or if it does but contains a label, return false. If it 433c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner/// constant folds return true and set the boolean result in Result. 434c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattnerbool CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond, 435c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner bool &ResultBool) { 436ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner llvm::APInt ResultInt; 437ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner if (!ConstantFoldsToSimpleInteger(Cond, ResultInt)) 438ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner return false; 439ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 440ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner ResultBool = ResultInt.getBoolValue(); 441ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner return true; 442ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner} 443ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 444ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// ConstantFoldsToSimpleInteger - If the specified expression does not fold 445ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// to a constant, or if it does but contains a label, return false. If it 446ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// constant folds return true and set the folded value. 447ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattnerbool CodeGenFunction:: 448ef425a69006afaa87751ee41ccf8ff405d9ede70Chris LattnerConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APInt &ResultInt) { 44936bc14c3a1cf63ee306df5687ac8e85f924f8639Daniel Dunbar // FIXME: Rename and handle conversion of other evaluatable things 45036bc14c3a1cf63ee306df5687ac8e85f924f8639Daniel Dunbar // to bool. 45164712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson Expr::EvalResult Result; 4521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!Cond->Evaluate(Result, getContext()) || !Result.Val.isInt() || 45364712f196bffd41fb0552c2643b07a25c3e45082Anders Carlsson Result.HasSideEffects) 454c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner return false; // Not foldable, not integer or not fully evaluatable. 455ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 45631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (CodeGenFunction::ContainsLabel(Cond)) 457c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner return false; // Contains a label. 458ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 459ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner ResultInt = Result.Val.getInt(); 460c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner return true; 46131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner} 46231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 46331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 464ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 46531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if 46631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// statement) to the specified blocks. Based on the condition, this might try 46731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// to simplify the codegen of the conditional based on the branch. 46831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// 46931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattnervoid CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond, 47031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::BasicBlock *TrueBlock, 47131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::BasicBlock *FalseBlock) { 472f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne Cond = Cond->IgnoreParens(); 4731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 47431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) { 47531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Handle X && Y in a condition. 4762de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CondBOp->getOpcode() == BO_LAnd) { 47731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "1 && X", simplify the code. "0 && X" would have constant 47831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // folded if the case was simple enough. 479e3eb83b93751544a5fab19b3824f56aeac454f82Bill Wendling bool ConstantBool = false; 480c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) && 481c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner ConstantBool) { 48231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(1 && X) -> br(X). 48331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 48431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 48631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "X && 1", simplify the code to use an uncond branch. 48731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // "X && 0" would have been constant folded to 0. 488c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) && 489c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner ConstantBool) { 49031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(X && 1) -> br(X). 49131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 49231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 4931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 49431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the LHS as a conditional. If the LHS conditional is false, we 49531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // want to jump to the FalseBlock. 4969615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true"); 497150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 498150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall ConditionalEvaluation eval(*this); 49931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock); 50031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBlock(LHSTrue); 5011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 50208e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson // Any temporaries created here are conditional. 503150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(*this); 50431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 505150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(*this); 50608e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson 50731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return; 508c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner } 509c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner 510c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (CondBOp->getOpcode() == BO_LOr) { 51131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "0 || X", simplify the code. "1 || X" would have constant 51231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // folded if the case was simple enough. 513e3eb83b93751544a5fab19b3824f56aeac454f82Bill Wendling bool ConstantBool = false; 514c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) && 515c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner !ConstantBool) { 51631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(0 || X) -> br(X). 51731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 51831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 5191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 52031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "X || 0", simplify the code to use an uncond branch. 52131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // "X || 1" would have been constant folded to 1. 522c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) && 523c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner !ConstantBool) { 52431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(X || 0) -> br(X). 52531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 52631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 5271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 52831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the LHS as a conditional. If the LHS conditional is true, we 52931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // want to jump to the TrueBlock. 5309615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false"); 531150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 532150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall ConditionalEvaluation eval(*this); 53331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse); 53431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBlock(LHSFalse); 5351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 53608e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson // Any temporaries created here are conditional. 537150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(*this); 53831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 539150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(*this); 54008e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson 54131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return; 54231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 543552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner } 5441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 545552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) { 546552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner // br(!x, t, f) -> br(x, f, t) 5472de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CondUOp->getOpcode() == UO_LNot) 548552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock); 54931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 5501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 55109b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) { 55209b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // Handle ?: operator. 55309b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar 55409b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // Just ignore GNU ?: extension. 55509b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar if (CondOp->getLHS()) { 55609b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f)) 55709b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true"); 55809b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false"); 559150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 560150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall ConditionalEvaluation cond(*this); 56109b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock); 562150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 563150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall cond.begin(*this); 56409b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBlock(LHSBlock); 56509b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock); 566150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall cond.end(*this); 567150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 568150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall cond.begin(*this); 56909b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBlock(RHSBlock); 57009b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock); 571150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall cond.end(*this); 572150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 57309b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar return; 57409b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar } 57509b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar } 57609b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar 57731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the code with the fully general case. 57831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::Value *CondV = EvaluateExprAsBool(Cond); 57931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner Builder.CreateCondBr(CondV, TrueBlock, FalseBlock); 58031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner} 58131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 582488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar/// ErrorUnsupported - Print out an error that codegen doesn't support the 583dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner/// specified stmt yet. 58490df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbarvoid CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type, 58590df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar bool OmitOnError) { 58690df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar CGM.ErrorUnsupported(S, Type, OmitOnError); 587dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner} 588dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner 5897143325db76d6c3dabce82500f8cc7c93a941970John McCall/// emitNonZeroVLAInit - Emit the "zero" initialization of a 5907143325db76d6c3dabce82500f8cc7c93a941970John McCall/// variable-length array whose elements have a non-zero bit-pattern. 5917143325db76d6c3dabce82500f8cc7c93a941970John McCall/// 5927143325db76d6c3dabce82500f8cc7c93a941970John McCall/// \param src - a char* pointing to the bit-pattern for a single 5937143325db76d6c3dabce82500f8cc7c93a941970John McCall/// base element of the array 5947143325db76d6c3dabce82500f8cc7c93a941970John McCall/// \param sizeInChars - the total size of the VLA, in chars 5957143325db76d6c3dabce82500f8cc7c93a941970John McCall/// \param align - the total alignment of the VLA 5967143325db76d6c3dabce82500f8cc7c93a941970John McCallstatic void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType, 5977143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *dest, llvm::Value *src, 5987143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *sizeInChars) { 5997143325db76d6c3dabce82500f8cc7c93a941970John McCall std::pair<CharUnits,CharUnits> baseSizeAndAlign 6007143325db76d6c3dabce82500f8cc7c93a941970John McCall = CGF.getContext().getTypeInfoInChars(baseType); 6017143325db76d6c3dabce82500f8cc7c93a941970John McCall 6027143325db76d6c3dabce82500f8cc7c93a941970John McCall CGBuilderTy &Builder = CGF.Builder; 6037143325db76d6c3dabce82500f8cc7c93a941970John McCall 6047143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *baseSizeInChars 6057143325db76d6c3dabce82500f8cc7c93a941970John McCall = llvm::ConstantInt::get(CGF.IntPtrTy, baseSizeAndAlign.first.getQuantity()); 6067143325db76d6c3dabce82500f8cc7c93a941970John McCall 6077143325db76d6c3dabce82500f8cc7c93a941970John McCall const llvm::Type *i8p = Builder.getInt8PtrTy(); 6087143325db76d6c3dabce82500f8cc7c93a941970John McCall 6097143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *begin = Builder.CreateBitCast(dest, i8p, "vla.begin"); 6107143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *end = Builder.CreateInBoundsGEP(dest, sizeInChars, "vla.end"); 6117143325db76d6c3dabce82500f8cc7c93a941970John McCall 6127143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock(); 6137143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *loopBB = CGF.createBasicBlock("vla-init.loop"); 6147143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *contBB = CGF.createBasicBlock("vla-init.cont"); 6157143325db76d6c3dabce82500f8cc7c93a941970John McCall 6167143325db76d6c3dabce82500f8cc7c93a941970John McCall // Make a loop over the VLA. C99 guarantees that the VLA element 6177143325db76d6c3dabce82500f8cc7c93a941970John McCall // count must be nonzero. 6187143325db76d6c3dabce82500f8cc7c93a941970John McCall CGF.EmitBlock(loopBB); 6197143325db76d6c3dabce82500f8cc7c93a941970John McCall 620bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *cur = Builder.CreatePHI(i8p, 2, "vla.cur"); 6217143325db76d6c3dabce82500f8cc7c93a941970John McCall cur->addIncoming(begin, originBB); 6227143325db76d6c3dabce82500f8cc7c93a941970John McCall 6237143325db76d6c3dabce82500f8cc7c93a941970John McCall // memcpy the individual element bit-pattern. 6247143325db76d6c3dabce82500f8cc7c93a941970John McCall Builder.CreateMemCpy(cur, src, baseSizeInChars, 6257143325db76d6c3dabce82500f8cc7c93a941970John McCall baseSizeAndAlign.second.getQuantity(), 6267143325db76d6c3dabce82500f8cc7c93a941970John McCall /*volatile*/ false); 6277143325db76d6c3dabce82500f8cc7c93a941970John McCall 6287143325db76d6c3dabce82500f8cc7c93a941970John McCall // Go to the next element. 6297143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *next = Builder.CreateConstInBoundsGEP1_32(cur, 1, "vla.next"); 6307143325db76d6c3dabce82500f8cc7c93a941970John McCall 6317143325db76d6c3dabce82500f8cc7c93a941970John McCall // Leave if that's the end of the VLA. 6327143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *done = Builder.CreateICmpEQ(next, end, "vla-init.isdone"); 6337143325db76d6c3dabce82500f8cc7c93a941970John McCall Builder.CreateCondBr(done, contBB, loopBB); 6347143325db76d6c3dabce82500f8cc7c93a941970John McCall cur->addIncoming(next, loopBB); 6357143325db76d6c3dabce82500f8cc7c93a941970John McCall 6367143325db76d6c3dabce82500f8cc7c93a941970John McCall CGF.EmitBlock(contBB); 6377143325db76d6c3dabce82500f8cc7c93a941970John McCall} 6387143325db76d6c3dabce82500f8cc7c93a941970John McCall 6391884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlssonvoid 6401884eb0b5c55edda4893ddec45e7dbad79758782Anders CarlssonCodeGenFunction::EmitNullInitialization(llvm::Value *DestPtr, QualType Ty) { 6410d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson // Ignore empty classes in C++. 6420d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (getContext().getLangOptions().CPlusPlus) { 6430d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (const RecordType *RT = Ty->getAs<RecordType>()) { 6440d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty()) 6450d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson return; 6460d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson } 6470d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson } 6489021718882441dd391a1960084580d3cd19c423aJohn McCall 6499021718882441dd391a1960084580d3cd19c423aJohn McCall // Cast the dest ptr to the appropriate i8 pointer type. 6509021718882441dd391a1960084580d3cd19c423aJohn McCall unsigned DestAS = 6519021718882441dd391a1960084580d3cd19c423aJohn McCall cast<llvm::PointerType>(DestPtr->getType())->getAddressSpace(); 6529f0c7cc36d29cf591c33962931f5862847145f3eBenjamin Kramer const llvm::Type *BP = Builder.getInt8PtrTy(DestAS); 6533d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson if (DestPtr->getType() != BP) 6543d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson DestPtr = Builder.CreateBitCast(DestPtr, BP, "tmp"); 6553d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 6563d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson // Get size and alignment info for this aggregate. 65779be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck std::pair<CharUnits, CharUnits> TypeInfo = 65879be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck getContext().getTypeInfoInChars(Ty); 65979be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck CharUnits Size = TypeInfo.first; 66079be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck CharUnits Align = TypeInfo.second; 6613d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 6625576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall llvm::Value *SizeVal; 6637143325db76d6c3dabce82500f8cc7c93a941970John McCall const VariableArrayType *vla; 6649021718882441dd391a1960084580d3cd19c423aJohn McCall 6655576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall // Don't bother emitting a zero-byte memset. 66679be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck if (Size.isZero()) { 6675576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall // But note that getTypeInfo returns 0 for a VLA. 6685576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall if (const VariableArrayType *vlaType = 6695576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall dyn_cast_or_null<VariableArrayType>( 6705576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall getContext().getAsArrayType(Ty))) { 6715576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall SizeVal = GetVLASize(vlaType); 6727143325db76d6c3dabce82500f8cc7c93a941970John McCall vla = vlaType; 6735576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } else { 6745576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall return; 6755576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } 6765576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } else { 67779be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck SizeVal = llvm::ConstantInt::get(IntPtrTy, Size.getQuantity()); 6787143325db76d6c3dabce82500f8cc7c93a941970John McCall vla = 0; 6795576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } 6809021718882441dd391a1960084580d3cd19c423aJohn McCall 6819021718882441dd391a1960084580d3cd19c423aJohn McCall // If the type contains a pointer to data member we can't memset it to zero. 6829021718882441dd391a1960084580d3cd19c423aJohn McCall // Instead, create a null constant and copy it to the destination. 6837143325db76d6c3dabce82500f8cc7c93a941970John McCall // TODO: there are other patterns besides zero that we can usefully memset, 6847143325db76d6c3dabce82500f8cc7c93a941970John McCall // like -1, which happens to be the pattern used by member-pointers. 685f16aa103d3afd42fbca2ab346f191bf745cec092John McCall if (!CGM.getTypes().isZeroInitializable(Ty)) { 6867143325db76d6c3dabce82500f8cc7c93a941970John McCall // For a VLA, emit a single element, then splat that over the VLA. 6877143325db76d6c3dabce82500f8cc7c93a941970John McCall if (vla) Ty = getContext().getBaseElementType(vla); 6885576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall 6899021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty); 6909021718882441dd391a1960084580d3cd19c423aJohn McCall 6919021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::GlobalVariable *NullVariable = 6929021718882441dd391a1960084580d3cd19c423aJohn McCall new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(), 6939021718882441dd391a1960084580d3cd19c423aJohn McCall /*isConstant=*/true, 6949021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::GlobalVariable::PrivateLinkage, 6959021718882441dd391a1960084580d3cd19c423aJohn McCall NullConstant, llvm::Twine()); 6969021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::Value *SrcPtr = 6979021718882441dd391a1960084580d3cd19c423aJohn McCall Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()); 6989021718882441dd391a1960084580d3cd19c423aJohn McCall 6997143325db76d6c3dabce82500f8cc7c93a941970John McCall if (vla) return emitNonZeroVLAInit(*this, Ty, DestPtr, SrcPtr, SizeVal); 7007143325db76d6c3dabce82500f8cc7c93a941970John McCall 7019021718882441dd391a1960084580d3cd19c423aJohn McCall // Get and call the appropriate llvm.memcpy overload. 70279be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, Align.getQuantity(), false); 70388207c9ca218486b93ae7df14e9764cd0c2c3383Chris Lattner return; 7049021718882441dd391a1960084580d3cd19c423aJohn McCall } 7059021718882441dd391a1960084580d3cd19c423aJohn McCall 7069021718882441dd391a1960084580d3cd19c423aJohn McCall // Otherwise, just memset the whole thing to zero. This is legal 7079021718882441dd391a1960084580d3cd19c423aJohn McCall // because in LLVM, all default initializers (other than the ones we just 7089021718882441dd391a1960084580d3cd19c423aJohn McCall // handled above) are guaranteed to have a bit pattern of all zeros. 70979be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal, 71079be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck Align.getQuantity(), false); 7113d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson} 7123d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 713ad8dcf4a9df0e24051dc31bf9e6f3cd138a34298Chris Lattnerllvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelDecl *L) { 714d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Make sure that there is a block for the indirect goto. 715d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch == 0) 716d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner GetIndirectGotoBlock(); 7173d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 718ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock(); 7193d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 720d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Make sure the indirect branch includes all of the address-taken blocks. 721d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner IndirectBranch->addDestination(BB); 722d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return llvm::BlockAddress::get(CurFn, BB); 7233d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner} 7241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7253d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattnerllvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() { 726d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If we already made the indirect branch for indirect goto, return its block. 727d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) return IndirectBranch->getParent(); 7283d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 729d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner CGBuilderTy TmpBuilder(createBasicBlock("indirectgoto")); 7303d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 7313d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner // Create the PHI node that indirect gotos will add entries to. 732bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, 0, 733bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad "indirect.goto.dest"); 7343d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner 735d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Create the indirect branch instruction. 736d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal); 737d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return IndirectBranch->getParent(); 7380ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar} 739ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 740d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbarllvm::Value *CodeGenFunction::GetVLASize(const VariableArrayType *VAT) { 741bbed6b964414145b29e7b60b3e538093734ea3f8Eli Friedman llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()]; 7421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 743f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson assert(SizeEntry && "Did not emit size for type"); 744f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson return SizeEntry; 745f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson} 746dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson 747d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbarllvm::Value *CodeGenFunction::EmitVLASize(QualType Ty) { 74860d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson assert(Ty->isVariablyModifiedType() && 74960d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson "Must pass variably modified type to EmitVLASizes!"); 7501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 751d286f05f1234bac289173f0eed88d7ecbaea0099Daniel Dunbar EnsureInsertPoint(); 7521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 75360d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson if (const VariableArrayType *VAT = getContext().getAsVariableArrayType(Ty)) { 754745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian // unknown size indication requires no size computation. 755745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian if (!VAT->getSizeExpr()) 756745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian return 0; 757bbed6b964414145b29e7b60b3e538093734ea3f8Eli Friedman llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()]; 7581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 759fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson if (!SizeEntry) { 76096f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson const llvm::Type *SizeTy = ConvertType(getContext().getSizeType()); 7611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 762ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner // Get the element size; 763ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner QualType ElemTy = VAT->getElementType(); 764ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner llvm::Value *ElemSize; 765fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson if (ElemTy->isVariableArrayType()) 766fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson ElemSize = EmitVLASize(ElemTy); 767ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner else 7684a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson ElemSize = llvm::ConstantInt::get(SizeTy, 769199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck getContext().getTypeSizeInChars(ElemTy).getQuantity()); 7701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 771fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson llvm::Value *NumElements = EmitScalarExpr(VAT->getSizeExpr()); 77296f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson NumElements = Builder.CreateIntCast(NumElements, SizeTy, false, "tmp"); 7731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 774fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson SizeEntry = Builder.CreateMul(ElemSize, NumElements); 775fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson } 7761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 77760d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson return SizeEntry; 778dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson } 7791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 780ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner if (const ArrayType *AT = dyn_cast<ArrayType>(Ty)) { 781ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner EmitVLASize(AT->getElementType()); 782ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner return 0; 7831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 7841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 785075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara if (const ParenType *PT = dyn_cast<ParenType>(Ty)) { 786075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara EmitVLASize(PT->getInnerType()); 787075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara return 0; 788075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara } 789075f8f1b6bed4d1b224c74f87508534cc6392ce6Abramo Bagnara 790ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner const PointerType *PT = Ty->getAs<PointerType>(); 791ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner assert(PT && "unknown VM type!"); 792ec18ddd33d5dc2cba5f64fa903bac7a83dc1e01eChris Lattner EmitVLASize(PT->getPointeeType()); 79360d35413662ebdcd1d31e34a8a7c665eb6977f1eAnders Carlsson return 0; 794dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson} 7954fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman 7964fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedmanllvm::Value* CodeGenFunction::EmitVAListRef(const Expr* E) { 797bc07a55b68342a230aafd8875cc7a26450dd3f64Dan Gohman if (getContext().getBuiltinVaListType()->isArrayType()) 7984fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman return EmitScalarExpr(E); 7994fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman return EmitLValue(E).getAddress(); 8004fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman} 8016ccc47698d0311ddabf32fa0f6db8e4f09ac96f8Anders Carlsson 8028d308384a220c7dc81755c47cdcbdd87dac25d5bDevang Patelvoid CodeGenFunction::EmitDeclRefExprDbgValue(const DeclRefExpr *E, 803189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall llvm::Constant *Init) { 80425c2c8fb9309050612009a6571e2660e75531348Devang Patel assert (Init && "Invalid DeclRefExpr initializer!"); 80525c2c8fb9309050612009a6571e2660e75531348Devang Patel if (CGDebugInfo *Dbg = getDebugInfo()) 806d2829b76a87a70791184b3cac89900d2cda46ce4Devang Patel Dbg->EmitGlobalVariable(E->getDecl(), Init); 8078d308384a220c7dc81755c47cdcbdd87dac25d5bDevang Patel} 80856ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 80956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCallCodeGenFunction::PeepholeProtection 81056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCallCodeGenFunction::protectFromPeepholes(RValue rvalue) { 81156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // At the moment, the only aggressive peephole we do in IR gen 81256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // is trunc(zext) folding, but if we add more, we can easily 81356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // extend this protection. 81456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 81556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (!rvalue.isScalar()) return PeepholeProtection(); 81656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *value = rvalue.getScalarVal(); 81756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (!isa<llvm::ZExtInst>(value)) return PeepholeProtection(); 81856ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 81956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // Just make an extra bitcast. 82056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall assert(HaveInsertPoint()); 82156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Instruction *inst = new llvm::BitCastInst(value, value->getType(), "", 82256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Builder.GetInsertBlock()); 82356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 82456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall PeepholeProtection protection; 82556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall protection.Inst = inst; 82656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall return protection; 82756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall} 82856ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 82956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCallvoid CodeGenFunction::unprotectFromPeepholes(PeepholeProtection protection) { 83056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (!protection.Inst) return; 83156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 83256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // In theory, we could try to duplicate the peepholes now, but whatever. 83356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall protection.Inst->eraseFromParent(); 83456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall} 835