CodeGenFunction.cpp revision c3bf52ced9652f555aa0767bb822ec4c64546212
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" 15a4ae2294b6ebfb2554aacb6a6a0682fb5ed1f276Peter Collingbourne#include "CGCUDARuntime.h" 164c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall#include "CGCXXABI.h" 173f2af1002249c8acc9ce17f1fc50324864feb8e1Eli Friedman#include "CGDebugInfo.h" 1855fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "CodeGenModule.h" 19de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 20c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/Decl.h" 212b77ba8bc7a842829ad9193816dc1d7d5e9c5be6Anders Carlsson#include "clang/AST/DeclCXX.h" 226a1e0eb557d47e85185e09bdf8721f53f4bf9c9cMike Stump#include "clang/AST/StmtCXX.h" 231db7040604154f71c54cf1329ae384fbef196668Guy Benyei#include "clang/Basic/OpenCL.h" 2455fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "clang/Basic/TargetInfo.h" 257255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner#include "clang/Frontend/CodeGenOptions.h" 263b844ba7d5be205a9b4f5f0b0d1b7978977f4b8cChandler Carruth#include "llvm/IR/DataLayout.h" 273b844ba7d5be205a9b4f5f0b0d1b7978977f4b8cChandler Carruth#include "llvm/IR/Intrinsics.h" 283b844ba7d5be205a9b4f5f0b0d1b7978977f4b8cChandler Carruth#include "llvm/IR/MDBuilder.h" 293b844ba7d5be205a9b4f5f0b0d1b7978977f4b8cChandler Carruth#include "llvm/IR/Operator.h" 305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace CodeGen; 325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 334904bf4e84cfb48080270ebaa9005327f18ab0e5Fariborz JahanianCodeGenFunction::CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext) 3464aa4b3ec7e62288e2e66c1935487ece995ca94bJohn McCall : CodeGenTypeCache(cgm), CGM(cgm), Target(cgm.getTarget()), 35cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman Builder(cgm.getModule().getContext()), 364f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz SanitizePerformTypeCheck(CGM.getSanOpts().Null | 374f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz CGM.getSanOpts().Alignment | 384f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz CGM.getSanOpts().ObjectSize | 394f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz CGM.getSanOpts().Vptr), 404f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz SanOpts(&CGM.getSanOpts()), 41f85e193739c953358c865005855253af4f68a497John McCall AutoreleaseResult(false), BlockInfo(0), BlockPointer(0), 4223f0267e2d56c0407f12e62df3561ecf75d74e6eEli Friedman LambdaThisCaptureField(0), NormalCleanupDest(0), NextCleanupDestIndex(1), 43cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman FirstBlockInfo(0), EHResumeBlock(0), ExceptionSlot(0), EHSelectorSlot(0), 4494d46b55103bf7ba0dc5425baf1eb7e4adcaa7eaManman Ren DebugInfo(0), DisableDebugInfo(false), CalleeWithThisReturn(0), 4594d46b55103bf7ba0dc5425baf1eb7e4adcaa7eaManman Ren DidCallStackSave(false), 4693c332a8ba2c193c435b293966d343dab15f555bJohn McCall IndirectBranch(0), SwitchInsn(0), CaseRangeBlock(0), UnreachableBlock(0), 4759660c21178b6af518bd4b564e032d5c9cc218cbTimur Iskhodzhanov CXXABIThisDecl(0), CXXABIThisValue(0), CXXThisValue(0), 48c3bf52ced9652f555aa0767bb822ec4c64546212Richard Smith CXXDefaultInitExprThis(0), 4959660c21178b6af518bd4b564e032d5c9cc218cbTimur Iskhodzhanov CXXStructorImplicitParamDecl(0), CXXStructorImplicitParamValue(0), 50495cfa46300979642acde8d93a1f21c9291dac98Nadav Rotem OutermostConditional(0), CurLexicalScope(0), TerminateLandingPad(0), 51cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman TerminateHandler(0), TrapBB(0) { 524904bf4e84cfb48080270ebaa9005327f18ab0e5Fariborz Jahanian if (!suppressNewContext) 534904bf4e84cfb48080270ebaa9005327f18ab0e5Fariborz Jahanian CGM.getCXXABI().getMangleContext().startNewFunction(); 54cdeb7d57a4867c28e3e6a8c391cba6f13c781fa6Michael Ilseman 55cdeb7d57a4867c28e3e6a8c391cba6f13c781fa6Michael Ilseman llvm::FastMathFlags FMF; 56cdeb7d57a4867c28e3e6a8c391cba6f13c781fa6Michael Ilseman if (CGM.getLangOpts().FastMath) 5729573b0a825b888c233d7859a257e866ffc5276eBenjamin Kramer FMF.setUnsafeAlgebra(); 58cdeb7d57a4867c28e3e6a8c391cba6f13c781fa6Michael Ilseman if (CGM.getLangOpts().FiniteMathOnly) { 5929573b0a825b888c233d7859a257e866ffc5276eBenjamin Kramer FMF.setNoNaNs(); 6029573b0a825b888c233d7859a257e866ffc5276eBenjamin Kramer FMF.setNoInfs(); 61cdeb7d57a4867c28e3e6a8c391cba6f13c781fa6Michael Ilseman } 62cdeb7d57a4867c28e3e6a8c391cba6f13c781fa6Michael Ilseman Builder.SetFastMathFlags(FMF); 634111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner} 645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 651a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCallCodeGenFunction::~CodeGenFunction() { 661a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall // If there are any unclaimed block infos, go ahead and destroy them 671a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall // now. This can happen if IR-gen gets clever and skips evaluating 681a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall // something. 691a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall if (FirstBlockInfo) 701a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall destroyBlockInfos(FirstBlockInfo); 711a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall} 721a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall 735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 749cbe4f0ba01ec304e1e3d071c071f7bca33631c0Chris Lattnerllvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) { 758b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar return CGM.getTypes().ConvertTypeForMem(T); 768b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar} 778b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar 789cbe4f0ba01ec304e1e3d071c071f7bca33631c0Chris Lattnerllvm::Type *CodeGenFunction::ConvertType(QualType T) { 795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return CGM.getTypes().ConvertType(T); 805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 829d232c884ea9872d6555df0fd7359699819bc1f1John McCallTypeEvaluationKind CodeGenFunction::getEvaluationKind(QualType type) { 839d232c884ea9872d6555df0fd7359699819bc1f1John McCall type = type.getCanonicalType(); 849d232c884ea9872d6555df0fd7359699819bc1f1John McCall while (true) { 859d232c884ea9872d6555df0fd7359699819bc1f1John McCall switch (type->getTypeClass()) { 86f2aac84709c418189e476ad591848dad50291885John McCall#define TYPE(name, parent) 87f2aac84709c418189e476ad591848dad50291885John McCall#define ABSTRACT_TYPE(name, parent) 88f2aac84709c418189e476ad591848dad50291885John McCall#define NON_CANONICAL_TYPE(name, parent) case Type::name: 89f2aac84709c418189e476ad591848dad50291885John McCall#define DEPENDENT_TYPE(name, parent) case Type::name: 90f2aac84709c418189e476ad591848dad50291885John McCall#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(name, parent) case Type::name: 91f2aac84709c418189e476ad591848dad50291885John McCall#include "clang/AST/TypeNodes.def" 929d232c884ea9872d6555df0fd7359699819bc1f1John McCall llvm_unreachable("non-canonical or dependent type in IR-generation"); 939d232c884ea9872d6555df0fd7359699819bc1f1John McCall 949d232c884ea9872d6555df0fd7359699819bc1f1John McCall // Various scalar types. 959d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::Builtin: 969d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::Pointer: 979d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::BlockPointer: 989d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::LValueReference: 999d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::RValueReference: 1009d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::MemberPointer: 1019d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::Vector: 1029d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::ExtVector: 1039d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::FunctionProto: 1049d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::FunctionNoProto: 1059d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::Enum: 1069d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::ObjCObjectPointer: 1079d232c884ea9872d6555df0fd7359699819bc1f1John McCall return TEK_Scalar; 1089d232c884ea9872d6555df0fd7359699819bc1f1John McCall 1099d232c884ea9872d6555df0fd7359699819bc1f1John McCall // Complexes. 1109d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::Complex: 1119d232c884ea9872d6555df0fd7359699819bc1f1John McCall return TEK_Complex; 1129d232c884ea9872d6555df0fd7359699819bc1f1John McCall 1139d232c884ea9872d6555df0fd7359699819bc1f1John McCall // Arrays, records, and Objective-C objects. 1149d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::ConstantArray: 1159d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::IncompleteArray: 1169d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::VariableArray: 1179d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::Record: 1189d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::ObjCObject: 1199d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::ObjCInterface: 1209d232c884ea9872d6555df0fd7359699819bc1f1John McCall return TEK_Aggregate; 1219d232c884ea9872d6555df0fd7359699819bc1f1John McCall 1229d232c884ea9872d6555df0fd7359699819bc1f1John McCall // We operate on atomic values according to their underlying type. 1239d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::Atomic: 1249d232c884ea9872d6555df0fd7359699819bc1f1John McCall type = cast<AtomicType>(type)->getValueType(); 1259d232c884ea9872d6555df0fd7359699819bc1f1John McCall continue; 1269d232c884ea9872d6555df0fd7359699819bc1f1John McCall } 1279d232c884ea9872d6555df0fd7359699819bc1f1John McCall llvm_unreachable("unknown type kind!"); 128f2aac84709c418189e476ad591848dad50291885John McCall } 1294111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner} 130391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 1310a0f93c90fd397a1aa9f97283c55f8ba0062bf55David Blaikievoid CodeGenFunction::EmitReturnBlock() { 1321c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // For cleanliness, we try to avoid emitting the return block for 1331c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // simple cases. 1341c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); 1351c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 1361c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar if (CurBB) { 1371c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar assert(!CurBB->getTerminator() && "Unexpected terminated block."); 1381c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 13996e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar // We have a valid insert point, reuse it if it is empty or there are no 14096e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar // explicit jumps to the return block. 141ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) { 142ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall ReturnBlock.getBlock()->replaceAllUsesWith(CurBB); 143ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall delete ReturnBlock.getBlock(); 14496e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar } else 145ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitBlock(ReturnBlock.getBlock()); 1460a0f93c90fd397a1aa9f97283c55f8ba0062bf55David Blaikie return; 1471c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 1481c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 1491c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // Otherwise, if the return block is the target of a single direct 1501c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // branch then we can just put the code in that block instead. This 1511c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // cleans up functions which started with a unified return block. 152ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (ReturnBlock.getBlock()->hasOneUse()) { 1531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump llvm::BranchInst *BI = 154ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->use_begin()); 155f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (BI && BI->isUnconditional() && 156ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BI->getSuccessor(0) == ReturnBlock.getBlock()) { 157c5139a9f0c9d4f835e4ab0b51e78d2f74fb488d9David Blaikie // Reset insertion point, including debug location, and delete the 158c5139a9f0c9d4f835e4ab0b51e78d2f74fb488d9David Blaikie // branch. This is really subtle and only works because the next change 159c5139a9f0c9d4f835e4ab0b51e78d2f74fb488d9David Blaikie // in location will hit the caching in CGDebugInfo::EmitLocation and not 160c5139a9f0c9d4f835e4ab0b51e78d2f74fb488d9David Blaikie // override this. 161acae01124151392a842bd6c37bd01b1ad56d6b4dEric Christopher Builder.SetCurrentDebugLocation(BI->getDebugLoc()); 1621c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar Builder.SetInsertPoint(BI->getParent()); 1631c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar BI->eraseFromParent(); 164ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall delete ReturnBlock.getBlock(); 1650a0f93c90fd397a1aa9f97283c55f8ba0062bf55David Blaikie return; 1661c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 1671c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 1681c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 169f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // FIXME: We are at an unreachable point, there is no reason to emit the block 170f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // unless it has uses. However, we still need a place to put the debug 171f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // region.end for now. 1721c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 173ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitBlock(ReturnBlock.getBlock()); 174f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall} 175f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 176f1549f66a8216a78112286e3978cea2c29d6334cJohn McCallstatic void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) { 177f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (!BB) return; 178f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (!BB->use_empty()) 179f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall return CGF.CurFn->getBasicBlockList().push_back(BB); 180f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall delete BB; 1811c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar} 1821c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 183af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbarvoid CodeGenFunction::FinishFunction(SourceLocation EndLoc) { 184391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner assert(BreakContinueStack.empty() && 185391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner "mismatched push/pop in break/continue stack!"); 1861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1870a0f93c90fd397a1aa9f97283c55f8ba0062bf55David Blaikie if (CGDebugInfo *DI = getDebugInfo()) 1880a0f93c90fd397a1aa9f97283c55f8ba0062bf55David Blaikie DI->EmitLocation(Builder, EndLoc); 1890a0f93c90fd397a1aa9f97283c55f8ba0062bf55David Blaikie 190f85e193739c953358c865005855253af4f68a497John McCall // Pop any cleanups that might have been associated with the 191f85e193739c953358c865005855253af4f68a497John McCall // parameters. Do this in whatever block we're currently in; it's 192f85e193739c953358c865005855253af4f68a497John McCall // important to do this before we enter the return block or return 193f85e193739c953358c865005855253af4f68a497John McCall // edges will be *really* confused. 194f85e193739c953358c865005855253af4f68a497John McCall if (EHStack.stable_begin() != PrologueCleanupDepth) 195f85e193739c953358c865005855253af4f68a497John McCall PopCleanupBlocks(PrologueCleanupDepth); 196f85e193739c953358c865005855253af4f68a497John McCall 1971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Emit function epilog (to return). 1980a0f93c90fd397a1aa9f97283c55f8ba0062bf55David Blaikie EmitReturnBlock(); 199f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar 200a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar if (ShouldInstrumentFunction()) 201a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar EmitFunctionInstrumentation("__cyg_profile_func_exit"); 2027255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 203f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar // Emit debug descriptor for function end. 204e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson if (CGDebugInfo *DI = getDebugInfo()) { 2055a6fbcfd8c15a2296f94a0473a68ec09d429827fDevang Patel DI->EmitFunctionEnd(Builder); 206f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar } 207f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar 20835b21b884e5c3447a52a74d7ffaba966b07ac81fChris Lattner EmitFunctionEpilog(*CurFnInfo); 209cce3d4f9812182ed4e551b7cf0fc86576be8d9c5Mike Stump EmitEndEHSpec(CurCodeDecl); 2105ca2084cf9b529563209429857f01fdae9dcdfa5Daniel Dunbar 211f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall assert(EHStack.empty() && 212f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall "did not remove all scopes from cleanup stack!"); 213f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 214d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If someone did an indirect goto, emit the indirect goto block at the end of 215d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // the function. 216d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) { 217d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner EmitBlock(IndirectBranch->getParent()); 218d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner Builder.ClearInsertionPoint(); 219d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 2209dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 221391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // Remove the AllocaInsertPt instruction, which is just a convenience for us. 222481769b5dc102b0256b35581e787909ad5edfab5Chris Lattner llvm::Instruction *Ptr = AllocaInsertPt; 223391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner AllocaInsertPt = 0; 224481769b5dc102b0256b35581e787909ad5edfab5Chris Lattner Ptr->eraseFromParent(); 2259dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 226d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If someone took the address of a label but never did an indirect goto, we 227d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // made a zero entry PHI node, which is illegal, zap it now. 228d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) { 229d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress()); 230d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (PN->getNumIncomingValues() == 0) { 231d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType())); 232d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner PN->eraseFromParent(); 233d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 234d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 235f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 236777d6e56ad9b1fed9866daf3ee6486d85c5b7d32John McCall EmitIfUsed(*this, EHResumeBlock); 237f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, TerminateLandingPad); 238f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, TerminateHandler); 239f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, UnreachableBlock); 240744016dde06fcffd50931e94a98c850f8b12cd87John McCall 241744016dde06fcffd50931e94a98c850f8b12cd87John McCall if (CGM.getCodeGenOpts().EmitDeclMetadata) 242744016dde06fcffd50931e94a98c850f8b12cd87John McCall EmitDeclMetadata(); 243c8aa5f1f264fb230c38182adab944232bb160c2bChris Lattner} 244c8aa5f1f264fb230c38182adab944232bb160c2bChris Lattner 2457255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// ShouldInstrumentFunction - Return true if the current function should be 2467255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// instrumented with __cyg_profile_func_* calls 2477255a2d997b15beae82e627052fdb1b2474495c2Chris Lattnerbool CodeGenFunction::ShouldInstrumentFunction() { 2487255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner if (!CGM.getCodeGenOpts().InstrumentFunctions) 2497255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return false; 2507aa488a7fc5c3a8cd1a2b93476150e9737760713Ted Kremenek if (!CurFuncDecl || CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>()) 2517255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return false; 2527255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return true; 2537255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner} 2547255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 2557255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// EmitFunctionInstrumentation - Emit LLVM code to call the specified 2567255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// instrumentation function with the current function and the call site, if 2577255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// function instrumentation is enabled. 2587255a2d997b15beae82e627052fdb1b2474495c2Chris Lattnervoid CodeGenFunction::EmitFunctionInstrumentation(const char *Fn) { 2598dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner // void __cyg_profile_func_{enter,exit} (void *this_fn, void *call_site); 2609cbe4f0ba01ec304e1e3d071c071f7bca33631c0Chris Lattner llvm::PointerType *PointerTy = Int8PtrTy; 2619cbe4f0ba01ec304e1e3d071c071f7bca33631c0Chris Lattner llvm::Type *ProfileFuncArgs[] = { PointerTy, PointerTy }; 2622acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::FunctionType *FunctionTy = 2638b418685e9e4f02f4eb2a76e1ec063e07552b68dChris Lattner llvm::FunctionType::get(VoidTy, ProfileFuncArgs, false); 2647255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 2657255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner llvm::Constant *F = CGM.CreateRuntimeFunction(FunctionTy, Fn); 2667255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner llvm::CallInst *CallSite = Builder.CreateCall( 2678dd55a3c3b28d195717c87bbc60e765951d408feBenjamin Kramer CGM.getIntrinsic(llvm::Intrinsic::returnaddress), 26877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::ConstantInt::get(Int32Ty, 0), 2697255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner "callsite"); 2707255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 271bd7370a78604e9a20d698bfe328c1e43f12a0613John McCall llvm::Value *args[] = { 272bd7370a78604e9a20d698bfe328c1e43f12a0613John McCall llvm::ConstantExpr::getBitCast(CurFn, PointerTy), 273bd7370a78604e9a20d698bfe328c1e43f12a0613John McCall CallSite 274bd7370a78604e9a20d698bfe328c1e43f12a0613John McCall }; 275bd7370a78604e9a20d698bfe328c1e43f12a0613John McCall 276bd7370a78604e9a20d698bfe328c1e43f12a0613John McCall EmitNounwindRuntimeCall(F, args); 2777255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner} 2787255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 279be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divackyvoid CodeGenFunction::EmitMCountInstrumentation() { 2808b418685e9e4f02f4eb2a76e1ec063e07552b68dChris Lattner llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); 281be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky 28264aa4b3ec7e62288e2e66c1935487ece995ca94bJohn McCall llvm::Constant *MCountFn = 28364aa4b3ec7e62288e2e66c1935487ece995ca94bJohn McCall CGM.CreateRuntimeFunction(FTy, getTarget().getMCountName()); 284bd7370a78604e9a20d698bfe328c1e43f12a0613John McCall EmitNounwindRuntimeCall(MCountFn); 285be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky} 286be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky 287198871cc90375246d8692680467ff6e810edac36Tanya Lattner// OpenCL v1.2 s5.6.4.6 allows the compiler to store kernel argument 288198871cc90375246d8692680467ff6e810edac36Tanya Lattner// information in the program executable. The argument information stored 289198871cc90375246d8692680467ff6e810edac36Tanya Lattner// includes the argument name, its type, the address and access qualifiers used. 290198871cc90375246d8692680467ff6e810edac36Tanya Lattnerstatic void GenOpenCLArgMetadata(const FunctionDecl *FD, llvm::Function *Fn, 291198871cc90375246d8692680467ff6e810edac36Tanya Lattner CodeGenModule &CGM,llvm::LLVMContext &Context, 2921db7040604154f71c54cf1329ae384fbef196668Guy Benyei SmallVector <llvm::Value*, 5> &kernelMDArgs, 2931db7040604154f71c54cf1329ae384fbef196668Guy Benyei CGBuilderTy& Builder, ASTContext &ASTCtx) { 2941db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Create MDNodes that represent the kernel arg metadata. 295198871cc90375246d8692680467ff6e810edac36Tanya Lattner // Each MDNode is a list in the form of "key", N number of values which is 296198871cc90375246d8692680467ff6e810edac36Tanya Lattner // the same number of values as their are kernel arguments. 2979dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 2981db7040604154f71c54cf1329ae384fbef196668Guy Benyei // MDNode for the kernel argument address space qualifiers. 2991db7040604154f71c54cf1329ae384fbef196668Guy Benyei SmallVector<llvm::Value*, 8> addressQuals; 3001db7040604154f71c54cf1329ae384fbef196668Guy Benyei addressQuals.push_back(llvm::MDString::get(Context, "kernel_arg_addr_space")); 3011db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3021db7040604154f71c54cf1329ae384fbef196668Guy Benyei // MDNode for the kernel argument access qualifiers (images only). 3031db7040604154f71c54cf1329ae384fbef196668Guy Benyei SmallVector<llvm::Value*, 8> accessQuals; 3041db7040604154f71c54cf1329ae384fbef196668Guy Benyei accessQuals.push_back(llvm::MDString::get(Context, "kernel_arg_access_qual")); 3051db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3061db7040604154f71c54cf1329ae384fbef196668Guy Benyei // MDNode for the kernel argument type names. 3071db7040604154f71c54cf1329ae384fbef196668Guy Benyei SmallVector<llvm::Value*, 8> argTypeNames; 3081db7040604154f71c54cf1329ae384fbef196668Guy Benyei argTypeNames.push_back(llvm::MDString::get(Context, "kernel_arg_type")); 3091db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3101db7040604154f71c54cf1329ae384fbef196668Guy Benyei // MDNode for the kernel argument type qualifiers. 3111db7040604154f71c54cf1329ae384fbef196668Guy Benyei SmallVector<llvm::Value*, 8> argTypeQuals; 3121db7040604154f71c54cf1329ae384fbef196668Guy Benyei argTypeQuals.push_back(llvm::MDString::get(Context, "kernel_arg_type_qual")); 3131db7040604154f71c54cf1329ae384fbef196668Guy Benyei 314198871cc90375246d8692680467ff6e810edac36Tanya Lattner // MDNode for the kernel argument names. 315198871cc90375246d8692680467ff6e810edac36Tanya Lattner SmallVector<llvm::Value*, 8> argNames; 316198871cc90375246d8692680467ff6e810edac36Tanya Lattner argNames.push_back(llvm::MDString::get(Context, "kernel_arg_name")); 3179dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 318198871cc90375246d8692680467ff6e810edac36Tanya Lattner for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) { 319198871cc90375246d8692680467ff6e810edac36Tanya Lattner const ParmVarDecl *parm = FD->getParamDecl(i); 3201db7040604154f71c54cf1329ae384fbef196668Guy Benyei QualType ty = parm->getType(); 3211db7040604154f71c54cf1329ae384fbef196668Guy Benyei std::string typeQuals; 3221db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3231db7040604154f71c54cf1329ae384fbef196668Guy Benyei if (ty->isPointerType()) { 3241db7040604154f71c54cf1329ae384fbef196668Guy Benyei QualType pointeeTy = ty->getPointeeType(); 3251db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3261db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Get address qualifier. 3271db7040604154f71c54cf1329ae384fbef196668Guy Benyei addressQuals.push_back(Builder.getInt32(ASTCtx.getTargetAddressSpace( 3281db7040604154f71c54cf1329ae384fbef196668Guy Benyei pointeeTy.getAddressSpace()))); 3291db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3301db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Get argument type name. 3311db7040604154f71c54cf1329ae384fbef196668Guy Benyei std::string typeName = pointeeTy.getUnqualifiedType().getAsString() + "*"; 3321db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3331db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Turn "unsigned type" to "utype" 3341db7040604154f71c54cf1329ae384fbef196668Guy Benyei std::string::size_type pos = typeName.find("unsigned"); 335f4492448a201c352be3d2e1e76220cf7cd499c55Benjamin Kramer if (pos != std::string::npos) 336f4492448a201c352be3d2e1e76220cf7cd499c55Benjamin Kramer typeName.erase(pos+1, 8); 3371db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3381db7040604154f71c54cf1329ae384fbef196668Guy Benyei argTypeNames.push_back(llvm::MDString::get(Context, typeName)); 3391db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3401db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Get argument type qualifiers: 3411db7040604154f71c54cf1329ae384fbef196668Guy Benyei if (ty.isRestrictQualified()) 3421db7040604154f71c54cf1329ae384fbef196668Guy Benyei typeQuals = "restrict"; 3431db7040604154f71c54cf1329ae384fbef196668Guy Benyei if (pointeeTy.isConstQualified() || 3441db7040604154f71c54cf1329ae384fbef196668Guy Benyei (pointeeTy.getAddressSpace() == LangAS::opencl_constant)) 345f4492448a201c352be3d2e1e76220cf7cd499c55Benjamin Kramer typeQuals += typeQuals.empty() ? "const" : " const"; 3461db7040604154f71c54cf1329ae384fbef196668Guy Benyei if (pointeeTy.isVolatileQualified()) 347f4492448a201c352be3d2e1e76220cf7cd499c55Benjamin Kramer typeQuals += typeQuals.empty() ? "volatile" : " volatile"; 3481db7040604154f71c54cf1329ae384fbef196668Guy Benyei } else { 3491db7040604154f71c54cf1329ae384fbef196668Guy Benyei addressQuals.push_back(Builder.getInt32(0)); 3501db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3511db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Get argument type name. 3521db7040604154f71c54cf1329ae384fbef196668Guy Benyei std::string typeName = ty.getUnqualifiedType().getAsString(); 3531db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3541db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Turn "unsigned type" to "utype" 3551db7040604154f71c54cf1329ae384fbef196668Guy Benyei std::string::size_type pos = typeName.find("unsigned"); 356f4492448a201c352be3d2e1e76220cf7cd499c55Benjamin Kramer if (pos != std::string::npos) 357f4492448a201c352be3d2e1e76220cf7cd499c55Benjamin Kramer typeName.erase(pos+1, 8); 3581db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3591db7040604154f71c54cf1329ae384fbef196668Guy Benyei argTypeNames.push_back(llvm::MDString::get(Context, typeName)); 3601db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3611db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Get argument type qualifiers: 3621db7040604154f71c54cf1329ae384fbef196668Guy Benyei if (ty.isConstQualified()) 3631db7040604154f71c54cf1329ae384fbef196668Guy Benyei typeQuals = "const"; 3641db7040604154f71c54cf1329ae384fbef196668Guy Benyei if (ty.isVolatileQualified()) 365f4492448a201c352be3d2e1e76220cf7cd499c55Benjamin Kramer typeQuals += typeQuals.empty() ? "volatile" : " volatile"; 3661db7040604154f71c54cf1329ae384fbef196668Guy Benyei } 3671db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3681db7040604154f71c54cf1329ae384fbef196668Guy Benyei argTypeQuals.push_back(llvm::MDString::get(Context, typeQuals)); 3691db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3701db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Get image access qualifier: 3711db7040604154f71c54cf1329ae384fbef196668Guy Benyei if (ty->isImageType()) { 3721db7040604154f71c54cf1329ae384fbef196668Guy Benyei if (parm->hasAttr<OpenCLImageAccessAttr>() && 3731db7040604154f71c54cf1329ae384fbef196668Guy Benyei parm->getAttr<OpenCLImageAccessAttr>()->getAccess() == CLIA_write_only) 3741db7040604154f71c54cf1329ae384fbef196668Guy Benyei accessQuals.push_back(llvm::MDString::get(Context, "write_only")); 3751db7040604154f71c54cf1329ae384fbef196668Guy Benyei else 3761db7040604154f71c54cf1329ae384fbef196668Guy Benyei accessQuals.push_back(llvm::MDString::get(Context, "read_only")); 3771db7040604154f71c54cf1329ae384fbef196668Guy Benyei } else 3781db7040604154f71c54cf1329ae384fbef196668Guy Benyei accessQuals.push_back(llvm::MDString::get(Context, "none")); 3799dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 380198871cc90375246d8692680467ff6e810edac36Tanya Lattner // Get argument name. 381198871cc90375246d8692680467ff6e810edac36Tanya Lattner argNames.push_back(llvm::MDString::get(Context, parm->getName())); 382198871cc90375246d8692680467ff6e810edac36Tanya Lattner } 3831db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3841db7040604154f71c54cf1329ae384fbef196668Guy Benyei kernelMDArgs.push_back(llvm::MDNode::get(Context, addressQuals)); 3851db7040604154f71c54cf1329ae384fbef196668Guy Benyei kernelMDArgs.push_back(llvm::MDNode::get(Context, accessQuals)); 3861db7040604154f71c54cf1329ae384fbef196668Guy Benyei kernelMDArgs.push_back(llvm::MDNode::get(Context, argTypeNames)); 3871db7040604154f71c54cf1329ae384fbef196668Guy Benyei kernelMDArgs.push_back(llvm::MDNode::get(Context, argTypeQuals)); 388198871cc90375246d8692680467ff6e810edac36Tanya Lattner kernelMDArgs.push_back(llvm::MDNode::get(Context, argNames)); 389198871cc90375246d8692680467ff6e810edac36Tanya Lattner} 390198871cc90375246d8692680467ff6e810edac36Tanya Lattner 3919dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilsemanvoid CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD, 3920df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner llvm::Function *Fn) 3930df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner{ 3940df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner if (!FD->hasAttr<OpenCLKernelAttr>()) 3950df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner return; 3960df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner 3970df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner llvm::LLVMContext &Context = getLLVMContext(); 3980df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner 399cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko SmallVector <llvm::Value*, 5> kernelMDArgs; 4000df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner kernelMDArgs.push_back(Fn); 4010df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner 402198871cc90375246d8692680467ff6e810edac36Tanya Lattner if (CGM.getCodeGenOpts().EmitOpenCLArgMetadata) 4031db7040604154f71c54cf1329ae384fbef196668Guy Benyei GenOpenCLArgMetadata(FD, Fn, CGM, Context, kernelMDArgs, 4041db7040604154f71c54cf1329ae384fbef196668Guy Benyei Builder, getContext()); 4059dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 40637453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly if (FD->hasAttr<VecTypeHintAttr>()) { 40737453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly VecTypeHintAttr *attr = FD->getAttr<VecTypeHintAttr>(); 40837453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly QualType hintQTy = attr->getTypeHint(); 40937453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly const ExtVectorType *hintEltQTy = hintQTy->getAs<ExtVectorType>(); 41037453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly bool isSignedInteger = 41137453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly hintQTy->isSignedIntegerType() || 41237453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly (hintEltQTy && hintEltQTy->getElementType()->isSignedIntegerType()); 41337453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly llvm::Value *attrMDArgs[] = { 41437453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly llvm::MDString::get(Context, "vec_type_hint"), 41537453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly llvm::UndefValue::get(CGM.getTypes().ConvertType(attr->getTypeHint())), 41637453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly llvm::ConstantInt::get( 41737453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly llvm::IntegerType::get(Context, 32), 41837453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly llvm::APInt(32, (uint64_t)(isSignedInteger ? 1 : 0))) 41937453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly }; 42037453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs)); 42137453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly } 42237453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly 4230df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner if (FD->hasAttr<WorkGroupSizeHintAttr>()) { 4240df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner WorkGroupSizeHintAttr *attr = FD->getAttr<WorkGroupSizeHintAttr>(); 4258fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer llvm::Value *attrMDArgs[] = { 4268fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer llvm::MDString::get(Context, "work_group_size_hint"), 4278fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer Builder.getInt32(attr->getXDim()), 4288fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer Builder.getInt32(attr->getYDim()), 4298fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer Builder.getInt32(attr->getZDim()) 4308fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer }; 4310df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs)); 4320df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner } 4330df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner 4340df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner if (FD->hasAttr<ReqdWorkGroupSizeAttr>()) { 4350df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner ReqdWorkGroupSizeAttr *attr = FD->getAttr<ReqdWorkGroupSizeAttr>(); 4368fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer llvm::Value *attrMDArgs[] = { 4378fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer llvm::MDString::get(Context, "reqd_work_group_size"), 4388fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer Builder.getInt32(attr->getXDim()), 4398fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer Builder.getInt32(attr->getYDim()), 4408fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer Builder.getInt32(attr->getZDim()) 4418fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer }; 4420df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs)); 4430df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner } 4440df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner 4450df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner llvm::MDNode *kernelMDNode = llvm::MDNode::get(Context, kernelMDArgs); 4460df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner llvm::NamedMDNode *OpenCLKernelMetadata = 4470df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner CGM.getModule().getOrInsertNamedMetadata("opencl.kernels"); 4480df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner OpenCLKernelMetadata->addOperand(kernelMDNode); 4490df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner} 4500df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner 4510ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlssonvoid CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy, 4527c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar llvm::Function *Fn, 453d26bc76c98006609002d9930f8840490e88ac5b5John McCall const CGFunctionInfo &FnInfo, 4542284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar const FunctionArgList &Args, 4559c6082fe89c61af697f017aa80937581cc2128d8Tilmann Scheller SourceLocation StartLoc) { 4560ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson const Decl *D = GD.getDecl(); 4579dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 4584cc1a4703363ff940b6273aeef9d96a87edeb04bAnders Carlsson DidCallStackSave = false; 459b5437d238752dc297e42410e98d38d5250fe0463Chris Lattner CurCodeDecl = CurFuncDecl = D; 4607c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FnRetTy = RetTy; 461bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar CurFn = Fn; 462d26bc76c98006609002d9930f8840490e88ac5b5John McCall CurFnInfo = &FnInfo; 4635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(CurFn->isDeclaration() && "Function already has body?"); 464ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner 4654f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz if (CGM.getSanitizerBlacklist().isIn(*Fn)) { 4664f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz SanOpts = &SanitizerOptions::Disabled; 4674f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz SanitizePerformTypeCheck = false; 4684f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz } 4694f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz 470a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen // Pass inline keyword to optimizer if it appears explicitly on any 471a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen // declaration. 4729dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman if (!CGM.getCodeGenOpts().NoInline) 4738fbe3855db0c341964bb550e13659505efe06c43Chad Rosier if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) 4748fbe3855db0c341964bb550e13659505efe06c43Chad Rosier for (FunctionDecl::redecl_iterator RI = FD->redecls_begin(), 4758fbe3855db0c341964bb550e13659505efe06c43Chad Rosier RE = FD->redecls_end(); RI != RE; ++RI) 4768fbe3855db0c341964bb550e13659505efe06c43Chad Rosier if (RI->isInlineSpecified()) { 47772390b39c545426023ec104afe8706395d732badBill Wendling Fn->addFnAttr(llvm::Attribute::InlineHint); 4788fbe3855db0c341964bb550e13659505efe06c43Chad Rosier break; 4798fbe3855db0c341964bb550e13659505efe06c43Chad Rosier } 480a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen 4817edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith if (getLangOpts().OpenCL) { 482f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne // Add metadata for a kernel function. 483f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) 4840df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner EmitOpenCLKernelMetadata(FD, Fn); 485f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne } 486f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne 48755e874299f2ad827646a4ca9ea38c402aaeb38c9Daniel Dunbar llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn); 4885ca2084cf9b529563209429857f01fdae9dcdfa5Daniel Dunbar 4895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Create a marker to make it easy to insert allocas into the entryblock 49055352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner // later. Don't create this with the builder, because we don't want it 49155352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner // folded. 49277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Value *Undef = llvm::UndefValue::get(Int32Ty); 49377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "", EntryBB); 494f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner if (Builder.isNamePreserving()) 495f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner AllocaInsertPt->setName("allocapt"); 4961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 497f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall ReturnBlock = getJumpDestInCurrentScope("return"); 4981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 49955352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner Builder.SetInsertPoint(EntryBB); 5001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 501af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta // Emit subprogram debug descriptor. 502e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson if (CGDebugInfo *DI = getDebugInfo()) { 503bea522ff43a3f11c7a2bc7949119dbb9fce19e39Jordan Rose SmallVector<QualType, 16> ArgTypes; 50406253664315307d34ab57b892b6a0c6c5b3153bbEric Christopher for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); 50506253664315307d34ab57b892b6a0c6c5b3153bbEric Christopher i != e; ++i) { 506bea522ff43a3f11c7a2bc7949119dbb9fce19e39Jordan Rose ArgTypes.push_back((*i)->getType()); 50706253664315307d34ab57b892b6a0c6c5b3153bbEric Christopher } 50806253664315307d34ab57b892b6a0c6c5b3153bbEric Christopher 509e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall QualType FnType = 510bea522ff43a3f11c7a2bc7949119dbb9fce19e39Jordan Rose getContext().getFunctionType(RetTy, ArgTypes, 511e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo()); 512e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 5132284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar DI->setLocation(StartLoc); 5149c6c3a0e3ae09626d2d4b04e4ffa42c3d7cab32bDevang Patel DI->EmitFunctionStart(GD, FnType, CurFn, Builder); 515af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta } 516af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta 517a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar if (ShouldInstrumentFunction()) 518a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar EmitFunctionInstrumentation("__cyg_profile_func_enter"); 5197255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 520be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky if (CGM.getCodeGenOpts().InstrumentForProfiling) 521be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky EmitMCountInstrumentation(); 522be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky 523b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman if (RetTy->isVoidType()) { 524b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman // Void type; nothing to return. 525b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman ReturnValue = 0; 526b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect && 5279d232c884ea9872d6555df0fd7359699819bc1f1John McCall !hasScalarEvaluationKind(CurFnInfo->getReturnType())) { 528b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman // Indirect aggregate return; emit returned value directly into sret slot. 529647a1ec397fa13af176d07d9f5d071560a94c7a9Daniel Dunbar // This reduces code size, and affects correctness in C++. 530b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman ReturnValue = CurFn->arg_begin(); 531b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } else { 532647a1ec397fa13af176d07d9f5d071560a94c7a9Daniel Dunbar ReturnValue = CreateIRTemp(RetTy, "retval"); 533f85e193739c953358c865005855253af4f68a497John McCall 534f85e193739c953358c865005855253af4f68a497John McCall // Tell the epilog emitter to autorelease the result. We do this 535f85e193739c953358c865005855253af4f68a497John McCall // now so that various specialized functions can suppress it 536f85e193739c953358c865005855253af4f68a497John McCall // during their IR-generation. 5374e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (getLangOpts().ObjCAutoRefCount && 538f85e193739c953358c865005855253af4f68a497John McCall !CurFnInfo->isReturnsRetained() && 539f85e193739c953358c865005855253af4f68a497John McCall RetTy->isObjCRetainableType()) 540f85e193739c953358c865005855253af4f68a497John McCall AutoreleaseResult = true; 541b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } 542b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman 543cce3d4f9812182ed4e551b7cf0fc86576be8d9c5Mike Stump EmitStartEHSpec(CurCodeDecl); 544f85e193739c953358c865005855253af4f68a497John McCall 545f85e193739c953358c865005855253af4f68a497John McCall PrologueCleanupDepth = EHStack.stable_begin(); 54688b5396b0897f28d22ae3debf4a0d97b33b6c362Daniel Dunbar EmitFunctionProlog(*CurFnInfo, CurFn, Args); 5471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 548cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) { 5494c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().EmitInstanceFunctionProlog(*this); 550cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman const CXXMethodDecl *MD = cast<CXXMethodDecl>(D); 551cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman if (MD->getParent()->isLambda() && 552cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman MD->getOverloadedOperator() == OO_Call) { 553cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman // We're in a lambda; figure out the captures. 554cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman MD->getParent()->getCaptureFields(LambdaCaptureFields, 555cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman LambdaThisCaptureField); 556cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman if (LambdaThisCaptureField) { 557cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman // If this lambda captures this, load it. 558377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman QualType LambdaTagType = 559377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman getContext().getTagDeclType(LambdaThisCaptureField->getParent()); 560377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman LValue LambdaLV = MakeNaturalAlignAddrLValue(CXXABIThisValue, 561377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman LambdaTagType); 562377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman LValue ThisLValue = EmitLValueForField(LambdaLV, 563377ecc7996dce6803f7b7b6208cab5e197c9c5b8Eli Friedman LambdaThisCaptureField); 564cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman CXXThisValue = EmitLoadOfLValue(ThisLValue).getScalarVal(); 565cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman } 566cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman } else { 567cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman // Not in a lambda; just use 'this' from the method. 568cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman // FIXME: Should we generate a new load for each use of 'this'? The 569cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman // fast register allocator would be happier... 570cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman CXXThisValue = CXXABIThisValue; 571cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman } 572cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman } 5732504941793b549323f9d29c62507cf21d865fadeJohn McCall 574751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson // If any of the arguments have a variably modified type, make sure to 575751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson // emit the type size. 576751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); 577751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson i != e; ++i) { 578f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman const VarDecl *VD = *i; 579f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman 580f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman // Dig out the type as written from ParmVarDecls; it's unclear whether 581f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman // the standard (C99 6.9.1p10) requires this, but we're following the 582f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman // precedent set by gcc. 583f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman QualType Ty; 584f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD)) 585f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman Ty = PVD->getOriginalType(); 586f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman else 587f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman Ty = VD->getType(); 588751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson 589751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson if (Ty->isVariablyModifiedType()) 590bc8d40d85f3fa1e34569834916f18fecaa635152John McCall EmitVariablyModifiedType(Ty); 591751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson } 59273fb35003aad027492e661a3749e921b5d1ecaf9Eric Christopher // Emit a location at the end of the prologue. 59373fb35003aad027492e661a3749e921b5d1ecaf9Eric Christopher if (CGDebugInfo *DI = getDebugInfo()) 59473fb35003aad027492e661a3749e921b5d1ecaf9Eric Christopher DI->EmitLocation(Builder, StartLoc); 5957c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar} 596eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman 5979fc6a7774643a810c8501dae2323e863fefb623eJohn McCallvoid CodeGenFunction::EmitFunctionBody(FunctionArgList &Args) { 5989fc6a7774643a810c8501dae2323e863fefb623eJohn McCall const FunctionDecl *FD = cast<FunctionDecl>(CurGD.getDecl()); 59906a9f3680d22529a2fcf20c52d71cf221d99d910Douglas Gregor assert(FD->getBody()); 600a6504853d297c30cfa271f4710af5a3d5db59449David Blaikie if (const CompoundStmt *S = dyn_cast<CompoundStmt>(FD->getBody())) 601a6504853d297c30cfa271f4710af5a3d5db59449David Blaikie EmitCompoundStmtWithoutScope(*S); 602a6504853d297c30cfa271f4710af5a3d5db59449David Blaikie else 603a6504853d297c30cfa271f4710af5a3d5db59449David Blaikie EmitStmt(FD->getBody()); 604a355e07454463b19829ac92ffd115a097faff0e0John McCall} 605a355e07454463b19829ac92ffd115a097faff0e0John McCall 60639dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// Tries to mark the given function nounwind based on the 60739dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// non-existence of any throwing calls within it. We believe this is 60839dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// lightweight enough to do at -O0. 60939dad53772c42eb36ebec1c81c56ba99d038fb94John McCallstatic void TryMarkNoThrow(llvm::Function *F) { 610b3a29f132794f67108bccc9c7cc3795365e8a965John McCall // LLVM treats 'nounwind' on a function as part of the type, so we 611b3a29f132794f67108bccc9c7cc3795365e8a965John McCall // can't do this on functions that can be overwritten. 612b3a29f132794f67108bccc9c7cc3795365e8a965John McCall if (F->mayBeOverridden()) return; 613b3a29f132794f67108bccc9c7cc3795365e8a965John McCall 61439dad53772c42eb36ebec1c81c56ba99d038fb94John McCall for (llvm::Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI) 61539dad53772c42eb36ebec1c81c56ba99d038fb94John McCall for (llvm::BasicBlock::iterator 61639dad53772c42eb36ebec1c81c56ba99d038fb94John McCall BI = FI->begin(), BE = FI->end(); BI != BE; ++BI) 617285cfd8953d4ca4da613a47a0d691f7234068f8cBill Wendling if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(&*BI)) { 61839dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (!Call->doesNotThrow()) 61939dad53772c42eb36ebec1c81c56ba99d038fb94John McCall return; 620285cfd8953d4ca4da613a47a0d691f7234068f8cBill Wendling } else if (isa<llvm::ResumeInst>(&*BI)) { 621285cfd8953d4ca4da613a47a0d691f7234068f8cBill Wendling return; 622285cfd8953d4ca4da613a47a0d691f7234068f8cBill Wendling } 623fac631052809b59c1b66f687c08a743de7fb50e9Bill Wendling F->setDoesNotThrow(); 62439dad53772c42eb36ebec1c81c56ba99d038fb94John McCall} 62539dad53772c42eb36ebec1c81c56ba99d038fb94John McCall 626d26bc76c98006609002d9930f8840490e88ac5b5John McCallvoid CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn, 627d26bc76c98006609002d9930f8840490e88ac5b5John McCall const CGFunctionInfo &FnInfo) { 6280ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 6299dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 630e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson // Check if we should generate debug info for this function. 631a240df2ec1b374b3e9e7f760875ffb17cd64506fAlexey Samsonov if (!FD->hasAttr<NoDebugAttr>()) 632a240df2ec1b374b3e9e7f760875ffb17cd64506fAlexey Samsonov maybeInitializeDebugInfo(); 6331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6347c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FunctionArgList Args; 6354c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall QualType ResTy = FD->getResultType(); 6361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6376a1e0eb557d47e85185e09bdf8721f53f4bf9c9cMike Stump CurGD = GD; 6384c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall if (isa<CXXMethodDecl>(FD) && cast<CXXMethodDecl>(FD)->isInstance()) 6394c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResTy, Args); 6401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6416e94f6c0f124c9a88b3dae0eea5e6b27957df183Chad Rosier for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) 6426e94f6c0f124c9a88b3dae0eea5e6b27957df183Chad Rosier Args.push_back(FD->getParamDecl(i)); 643af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar 644a355e07454463b19829ac92ffd115a097faff0e0John McCall SourceRange BodyRange; 645a355e07454463b19829ac92ffd115a097faff0e0John McCall if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange(); 6464365bba95be15342575b4f030c6583a770a5da3dAnders Carlsson 64763fd408a61ae9b94e8d8a986832f526f7cdbfa84Manman Ren // CalleeWithThisReturn keeps track of the last callee inside this function 64863fd408a61ae9b94e8d8a986832f526f7cdbfa84Manman Ren // that returns 'this'. Before starting the function, we set it to null. 64963fd408a61ae9b94e8d8a986832f526f7cdbfa84Manman Ren CalleeWithThisReturn = 0; 65063fd408a61ae9b94e8d8a986832f526f7cdbfa84Manman Ren 651a355e07454463b19829ac92ffd115a097faff0e0John McCall // Emit the standard function prologue. 652d26bc76c98006609002d9930f8840490e88ac5b5John McCall StartFunction(GD, ResTy, Fn, FnInfo, Args, BodyRange.getBegin()); 6531851a12605bc6f1ea70d11974a315340ebaab6ebAnders Carlsson 654a355e07454463b19829ac92ffd115a097faff0e0John McCall // Generate the body of the function. 6559fc6a7774643a810c8501dae2323e863fefb623eJohn McCall if (isa<CXXDestructorDecl>(FD)) 6569fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitDestructorBody(Args); 6579fc6a7774643a810c8501dae2323e863fefb623eJohn McCall else if (isa<CXXConstructorDecl>(FD)) 6589fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitConstructorBody(Args); 6597edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith else if (getLangOpts().CUDA && 660a4ae2294b6ebfb2554aacb6a6a0682fb5ed1f276Peter Collingbourne !CGM.getCodeGenOpts().CUDAIsDevice && 661a4ae2294b6ebfb2554aacb6a6a0682fb5ed1f276Peter Collingbourne FD->hasAttr<CUDAGlobalAttr>()) 662a4ae2294b6ebfb2554aacb6a6a0682fb5ed1f276Peter Collingbourne CGM.getCUDARuntime().EmitDeviceStubBody(*this, Args); 663bd89f8c2caa9550e41daa1aa9bf30f0f1e0dfaf7Eli Friedman else if (isa<CXXConversionDecl>(FD) && 66427dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor cast<CXXConversionDecl>(FD)->isLambdaToBlockPointerConversion()) { 66527dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor // The lambda conversion to block pointer is special; the semantics can't be 66627dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor // expressed in the AST, so IRGen needs to special-case it. 66727dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor EmitLambdaToBlockPointerBody(Args); 66827dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor } else if (isa<CXXMethodDecl>(FD) && 66927dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor cast<CXXMethodDecl>(FD)->isLambdaStaticInvoker()) { 67027dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor // The lambda "__invoke" function is special, because it forwards or 67127dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor // clones the body of the function call operator (but is actually static). 67227dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor EmitLambdaStaticInvokeFunction(cast<CXXMethodDecl>(FD)); 67356c00c4868831c9a137ca7b0e16d063cf986d110Lang Hames } else if (FD->isDefaulted() && isa<CXXMethodDecl>(FD) && 67456c00c4868831c9a137ca7b0e16d063cf986d110Lang Hames cast<CXXMethodDecl>(FD)->isCopyAssignmentOperator()) { 67556c00c4868831c9a137ca7b0e16d063cf986d110Lang Hames // Implicit copy-assignment gets the same special treatment as implicit 67656c00c4868831c9a137ca7b0e16d063cf986d110Lang Hames // copy-constructors. 67756c00c4868831c9a137ca7b0e16d063cf986d110Lang Hames emitImplicitAssignmentOperatorBody(Args); 678bd89f8c2caa9550e41daa1aa9bf30f0f1e0dfaf7Eli Friedman } 6799fc6a7774643a810c8501dae2323e863fefb623eJohn McCall else 6809fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitFunctionBody(Args); 681c33e4ba20304e222692e77f2c6ad26a5d8d32f83Anders Carlsson 68236ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith // C++11 [stmt.return]p2: 68336ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith // Flowing off the end of a function [...] results in undefined behavior in 68436ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith // a value-returning function. 68536ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith // C11 6.9.1p12: 68636ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith // If the '}' that terminates a function is reached, and the value of the 68736ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith // function call is used by the caller, the behavior is undefined. 6887edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith if (getLangOpts().CPlusPlus && !FD->hasImplicitReturnZero() && 68936ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith !FD->getResultType()->isVoidType() && Builder.GetInsertBlock()) { 6904f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz if (SanOpts->Return) 6914def70d3040e73707c738f7c366737a986135edfRichard Smith EmitCheck(Builder.getFalse(), "missing_return", 6924def70d3040e73707c738f7c366737a986135edfRichard Smith EmitCheckSourceLocation(FD->getLocation()), 693cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko ArrayRef<llvm::Value *>(), CRK_Unrecoverable); 694802cd5b1974bab2038b9d3c969d9beb0ab34f435Richard Smith else if (CGM.getCodeGenOpts().OptimizationLevel == 0) 695802cd5b1974bab2038b9d3c969d9beb0ab34f435Richard Smith Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::trap)); 69636ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith Builder.CreateUnreachable(); 69736ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith Builder.ClearInsertionPoint(); 69836ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith } 69936ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith 700a355e07454463b19829ac92ffd115a097faff0e0John McCall // Emit the standard function epilogue. 701a355e07454463b19829ac92ffd115a097faff0e0John McCall FinishFunction(BodyRange.getEnd()); 70263fd408a61ae9b94e8d8a986832f526f7cdbfa84Manman Ren // CalleeWithThisReturn keeps track of the last callee inside this function 70363fd408a61ae9b94e8d8a986832f526f7cdbfa84Manman Ren // that returns 'this'. After finishing the function, we set it to null. 70463fd408a61ae9b94e8d8a986832f526f7cdbfa84Manman Ren CalleeWithThisReturn = 0; 70539dad53772c42eb36ebec1c81c56ba99d038fb94John McCall 70639dad53772c42eb36ebec1c81c56ba99d038fb94John McCall // If we haven't marked the function nothrow through other means, do 70739dad53772c42eb36ebec1c81c56ba99d038fb94John McCall // a quick pass now to see if we can. 70839dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (!CurFn->doesNotThrow()) 70939dad53772c42eb36ebec1c81c56ba99d038fb94John McCall TryMarkNoThrow(CurFn); 7105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 7115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 7120946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// ContainsLabel - Return true if the statement contains a label in it. If 7130946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// this statement is not executed normally, it not containing a label means 7140946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// that we can just remove the code. 7150946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattnerbool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) { 7160946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // Null statement, not a label! 7170946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (S == 0) return false; 7181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7190946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a label, we have to emit the code, consider something like: 7200946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // if (0) { ... foo: bar(); } goto foo; 721ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // 722ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // TODO: If anyone cared, we could track __label__'s, since we know that you 723ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // can't jump to one from outside their declared region. 7240946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<LabelStmt>(S)) 7250946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 7269dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 7270946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a case/default statement, and we haven't seen a switch, we have 7280946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // to emit the code. 7290946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<SwitchCase>(S) && !IgnoreCaseStmts) 7300946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 7311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7320946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a switch statement, we want to ignore cases below it. 7330946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<SwitchStmt>(S)) 7340946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner IgnoreCaseStmts = true; 7351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7360946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // Scan subexpressions for verboten labels. 7377502c1d3ce8bb97bcc4f7bebef507040bd93b26fJohn McCall for (Stmt::const_child_range I = S->children(); I; ++I) 7380946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (ContainsLabel(*I, IgnoreCaseStmts)) 7390946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 7401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7410946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return false; 7420946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner} 7430946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner 744ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// containsBreak - Return true if the statement contains a break out of it. 745ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// If the statement (recursively) contains a switch or loop with a break 746ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// inside of it, this is fine. 747ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattnerbool CodeGenFunction::containsBreak(const Stmt *S) { 748ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // Null statement, not a label! 749ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner if (S == 0) return false; 750ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 751ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // If this is a switch or loop that defines its own break scope, then we can 752ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // include it and anything inside of it. 753ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || isa<DoStmt>(S) || 754ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner isa<ForStmt>(S)) 7552bef7f5499541e3b68f114cc4d7d197e9a902fe7Chris Lattner return false; 7569dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 7572bef7f5499541e3b68f114cc4d7d197e9a902fe7Chris Lattner if (isa<BreakStmt>(S)) 758ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner return true; 7599dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 760ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // Scan subexpressions for verboten breaks. 761ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner for (Stmt::const_child_range I = S->children(); I; ++I) 762ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner if (containsBreak(*I)) 763ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner return true; 7649dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 765ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner return false; 766ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner} 767ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 76831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 769c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner/// ConstantFoldsToSimpleInteger - If the specified expression does not fold 770c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner/// to a constant, or if it does but contains a label, return false. If it 771c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner/// constant folds return true and set the boolean result in Result. 772c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattnerbool CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond, 773c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner bool &ResultBool) { 774e1ecdc168175719d74e112bcacd4aae5e12d4631Richard Trieu llvm::APSInt ResultInt; 775ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner if (!ConstantFoldsToSimpleInteger(Cond, ResultInt)) 776ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner return false; 7779dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 778ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner ResultBool = ResultInt.getBoolValue(); 779ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner return true; 780ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner} 781ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 782ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// ConstantFoldsToSimpleInteger - If the specified expression does not fold 783ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// to a constant, or if it does but contains a label, return false. If it 784ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// constant folds return true and set the folded value. 785ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattnerbool CodeGenFunction:: 786e1ecdc168175719d74e112bcacd4aae5e12d4631Richard TrieuConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APSInt &ResultInt) { 78736bc14c3a1cf63ee306df5687ac8e85f924f8639Daniel Dunbar // FIXME: Rename and handle conversion of other evaluatable things 78836bc14c3a1cf63ee306df5687ac8e85f924f8639Daniel Dunbar // to bool. 78980d4b55db94db2172a04617d1a80feca6bbcea5cRichard Smith llvm::APSInt Int; 79080d4b55db94db2172a04617d1a80feca6bbcea5cRichard Smith if (!Cond->EvaluateAsInt(Int, getContext())) 791c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner return false; // Not foldable, not integer or not fully evaluatable. 79280d4b55db94db2172a04617d1a80feca6bbcea5cRichard Smith 79331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (CodeGenFunction::ContainsLabel(Cond)) 794c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner return false; // Contains a label. 79580d4b55db94db2172a04617d1a80feca6bbcea5cRichard Smith 79680d4b55db94db2172a04617d1a80feca6bbcea5cRichard Smith ResultInt = Int; 797c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner return true; 79831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner} 79931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 80031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 801ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 80231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if 80331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// statement) to the specified blocks. Based on the condition, this might try 80431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// to simplify the codegen of the conditional based on the branch. 80531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// 80631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattnervoid CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond, 80731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::BasicBlock *TrueBlock, 80831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::BasicBlock *FalseBlock) { 809f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne Cond = Cond->IgnoreParens(); 8101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 81131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) { 81231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Handle X && Y in a condition. 8132de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CondBOp->getOpcode() == BO_LAnd) { 81431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "1 && X", simplify the code. "0 && X" would have constant 81531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // folded if the case was simple enough. 816e3eb83b93751544a5fab19b3824f56aeac454f82Bill Wendling bool ConstantBool = false; 817c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) && 818c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner ConstantBool) { 81931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(1 && X) -> br(X). 82031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 82131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 8221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 82331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "X && 1", simplify the code to use an uncond branch. 82431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // "X && 0" would have been constant folded to 0. 825c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) && 826c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner ConstantBool) { 82731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(X && 1) -> br(X). 82831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 82931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 8301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 83131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the LHS as a conditional. If the LHS conditional is false, we 83231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // want to jump to the FalseBlock. 8339615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true"); 834150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 835150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall ConditionalEvaluation eval(*this); 83631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock); 83731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBlock(LHSTrue); 8381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 83908e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson // Any temporaries created here are conditional. 840150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(*this); 84131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 842150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(*this); 84308e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson 84431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return; 845c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner } 8469dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 847c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (CondBOp->getOpcode() == BO_LOr) { 84831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "0 || X", simplify the code. "1 || X" would have constant 84931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // folded if the case was simple enough. 850e3eb83b93751544a5fab19b3824f56aeac454f82Bill Wendling bool ConstantBool = false; 851c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) && 852c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner !ConstantBool) { 85331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(0 || X) -> br(X). 85431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 85531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 8561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 85731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "X || 0", simplify the code to use an uncond branch. 85831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // "X || 1" would have been constant folded to 1. 859c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) && 860c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner !ConstantBool) { 86131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(X || 0) -> br(X). 86231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 86331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 8641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 86531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the LHS as a conditional. If the LHS conditional is true, we 86631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // want to jump to the TrueBlock. 8679615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false"); 868150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 869150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall ConditionalEvaluation eval(*this); 87031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse); 87131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBlock(LHSFalse); 8721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 87308e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson // Any temporaries created here are conditional. 874150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(*this); 87531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 876150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(*this); 87708e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson 87831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return; 87931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 880552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner } 8811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 882552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) { 883552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner // br(!x, t, f) -> br(x, f, t) 8842de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CondUOp->getOpcode() == UO_LNot) 885552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock); 88631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 8871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 88809b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) { 889df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f)) 890df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true"); 891df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false"); 89209b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar 893df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman ConditionalEvaluation cond(*this); 894df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock); 895150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 896df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman cond.begin(*this); 897df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman EmitBlock(LHSBlock); 898df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock); 899df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman cond.end(*this); 900150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 901df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman cond.begin(*this); 902df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman EmitBlock(RHSBlock); 903df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock); 904df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman cond.end(*this); 905150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 906df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman return; 90709b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar } 90809b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar 90931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the code with the fully general case. 91031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::Value *CondV = EvaluateExprAsBool(Cond); 91131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner Builder.CreateCondBr(CondV, TrueBlock, FalseBlock); 91231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner} 91331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 914488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar/// ErrorUnsupported - Print out an error that codegen doesn't support the 915dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner/// specified stmt yet. 91690df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbarvoid CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type, 91790df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar bool OmitOnError) { 91890df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar CGM.ErrorUnsupported(S, Type, OmitOnError); 919dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner} 920dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner 9217143325db76d6c3dabce82500f8cc7c93a941970John McCall/// emitNonZeroVLAInit - Emit the "zero" initialization of a 9227143325db76d6c3dabce82500f8cc7c93a941970John McCall/// variable-length array whose elements have a non-zero bit-pattern. 9237143325db76d6c3dabce82500f8cc7c93a941970John McCall/// 9242ee5ba35febf830d366b65dd0dcbf8e291c41342James Dennett/// \param baseType the inner-most element type of the array 9257143325db76d6c3dabce82500f8cc7c93a941970John McCall/// \param src - a char* pointing to the bit-pattern for a single 9267143325db76d6c3dabce82500f8cc7c93a941970John McCall/// base element of the array 9277143325db76d6c3dabce82500f8cc7c93a941970John McCall/// \param sizeInChars - the total size of the VLA, in chars 9287143325db76d6c3dabce82500f8cc7c93a941970John McCallstatic void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType, 9299dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman llvm::Value *dest, llvm::Value *src, 9307143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *sizeInChars) { 9317143325db76d6c3dabce82500f8cc7c93a941970John McCall std::pair<CharUnits,CharUnits> baseSizeAndAlign 9327143325db76d6c3dabce82500f8cc7c93a941970John McCall = CGF.getContext().getTypeInfoInChars(baseType); 9337143325db76d6c3dabce82500f8cc7c93a941970John McCall 9347143325db76d6c3dabce82500f8cc7c93a941970John McCall CGBuilderTy &Builder = CGF.Builder; 9357143325db76d6c3dabce82500f8cc7c93a941970John McCall 9367143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *baseSizeInChars 9377143325db76d6c3dabce82500f8cc7c93a941970John McCall = llvm::ConstantInt::get(CGF.IntPtrTy, baseSizeAndAlign.first.getQuantity()); 9387143325db76d6c3dabce82500f8cc7c93a941970John McCall 9392acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *i8p = Builder.getInt8PtrTy(); 9407143325db76d6c3dabce82500f8cc7c93a941970John McCall 9417143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *begin = Builder.CreateBitCast(dest, i8p, "vla.begin"); 9427143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *end = Builder.CreateInBoundsGEP(dest, sizeInChars, "vla.end"); 9437143325db76d6c3dabce82500f8cc7c93a941970John McCall 9447143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock(); 9457143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *loopBB = CGF.createBasicBlock("vla-init.loop"); 9467143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *contBB = CGF.createBasicBlock("vla-init.cont"); 9477143325db76d6c3dabce82500f8cc7c93a941970John McCall 9487143325db76d6c3dabce82500f8cc7c93a941970John McCall // Make a loop over the VLA. C99 guarantees that the VLA element 9497143325db76d6c3dabce82500f8cc7c93a941970John McCall // count must be nonzero. 9507143325db76d6c3dabce82500f8cc7c93a941970John McCall CGF.EmitBlock(loopBB); 9517143325db76d6c3dabce82500f8cc7c93a941970John McCall 952bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *cur = Builder.CreatePHI(i8p, 2, "vla.cur"); 9537143325db76d6c3dabce82500f8cc7c93a941970John McCall cur->addIncoming(begin, originBB); 9547143325db76d6c3dabce82500f8cc7c93a941970John McCall 9557143325db76d6c3dabce82500f8cc7c93a941970John McCall // memcpy the individual element bit-pattern. 9567143325db76d6c3dabce82500f8cc7c93a941970John McCall Builder.CreateMemCpy(cur, src, baseSizeInChars, 9577143325db76d6c3dabce82500f8cc7c93a941970John McCall baseSizeAndAlign.second.getQuantity(), 9587143325db76d6c3dabce82500f8cc7c93a941970John McCall /*volatile*/ false); 9597143325db76d6c3dabce82500f8cc7c93a941970John McCall 9607143325db76d6c3dabce82500f8cc7c93a941970John McCall // Go to the next element. 9617143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *next = Builder.CreateConstInBoundsGEP1_32(cur, 1, "vla.next"); 9627143325db76d6c3dabce82500f8cc7c93a941970John McCall 9637143325db76d6c3dabce82500f8cc7c93a941970John McCall // Leave if that's the end of the VLA. 9647143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *done = Builder.CreateICmpEQ(next, end, "vla-init.isdone"); 9657143325db76d6c3dabce82500f8cc7c93a941970John McCall Builder.CreateCondBr(done, contBB, loopBB); 9667143325db76d6c3dabce82500f8cc7c93a941970John McCall cur->addIncoming(next, loopBB); 9677143325db76d6c3dabce82500f8cc7c93a941970John McCall 9687143325db76d6c3dabce82500f8cc7c93a941970John McCall CGF.EmitBlock(contBB); 9699dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman} 9707143325db76d6c3dabce82500f8cc7c93a941970John McCall 9711884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlssonvoid 9721884eb0b5c55edda4893ddec45e7dbad79758782Anders CarlssonCodeGenFunction::EmitNullInitialization(llvm::Value *DestPtr, QualType Ty) { 9730d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson // Ignore empty classes in C++. 9747edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith if (getLangOpts().CPlusPlus) { 9750d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (const RecordType *RT = Ty->getAs<RecordType>()) { 9760d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty()) 9770d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson return; 9780d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson } 9790d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson } 9809021718882441dd391a1960084580d3cd19c423aJohn McCall 9819021718882441dd391a1960084580d3cd19c423aJohn McCall // Cast the dest ptr to the appropriate i8 pointer type. 9829021718882441dd391a1960084580d3cd19c423aJohn McCall unsigned DestAS = 9839021718882441dd391a1960084580d3cd19c423aJohn McCall cast<llvm::PointerType>(DestPtr->getType())->getAddressSpace(); 9842acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *BP = Builder.getInt8PtrTy(DestAS); 9853d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson if (DestPtr->getType() != BP) 986578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer DestPtr = Builder.CreateBitCast(DestPtr, BP); 9873d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 9883d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson // Get size and alignment info for this aggregate. 9899dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman std::pair<CharUnits, CharUnits> TypeInfo = 99079be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck getContext().getTypeInfoInChars(Ty); 99179be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck CharUnits Size = TypeInfo.first; 99279be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck CharUnits Align = TypeInfo.second; 9933d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 9945576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall llvm::Value *SizeVal; 9957143325db76d6c3dabce82500f8cc7c93a941970John McCall const VariableArrayType *vla; 9969021718882441dd391a1960084580d3cd19c423aJohn McCall 9975576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall // Don't bother emitting a zero-byte memset. 99879be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck if (Size.isZero()) { 9995576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall // But note that getTypeInfo returns 0 for a VLA. 10005576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall if (const VariableArrayType *vlaType = 10015576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall dyn_cast_or_null<VariableArrayType>( 10025576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall getContext().getAsArrayType(Ty))) { 1003bc8d40d85f3fa1e34569834916f18fecaa635152John McCall QualType eltType; 1004bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::Value *numElts; 1005bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::tie(numElts, eltType) = getVLASize(vlaType); 1006bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1007bc8d40d85f3fa1e34569834916f18fecaa635152John McCall SizeVal = numElts; 1008bc8d40d85f3fa1e34569834916f18fecaa635152John McCall CharUnits eltSize = getContext().getTypeSizeInChars(eltType); 1009bc8d40d85f3fa1e34569834916f18fecaa635152John McCall if (!eltSize.isOne()) 1010bc8d40d85f3fa1e34569834916f18fecaa635152John McCall SizeVal = Builder.CreateNUWMul(SizeVal, CGM.getSize(eltSize)); 10117143325db76d6c3dabce82500f8cc7c93a941970John McCall vla = vlaType; 10125576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } else { 10135576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall return; 10145576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } 10155576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } else { 1016bc8d40d85f3fa1e34569834916f18fecaa635152John McCall SizeVal = CGM.getSize(Size); 10177143325db76d6c3dabce82500f8cc7c93a941970John McCall vla = 0; 10185576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } 10199021718882441dd391a1960084580d3cd19c423aJohn McCall 10209021718882441dd391a1960084580d3cd19c423aJohn McCall // If the type contains a pointer to data member we can't memset it to zero. 10219021718882441dd391a1960084580d3cd19c423aJohn McCall // Instead, create a null constant and copy it to the destination. 10227143325db76d6c3dabce82500f8cc7c93a941970John McCall // TODO: there are other patterns besides zero that we can usefully memset, 10237143325db76d6c3dabce82500f8cc7c93a941970John McCall // like -1, which happens to be the pattern used by member-pointers. 1024f16aa103d3afd42fbca2ab346f191bf745cec092John McCall if (!CGM.getTypes().isZeroInitializable(Ty)) { 10257143325db76d6c3dabce82500f8cc7c93a941970John McCall // For a VLA, emit a single element, then splat that over the VLA. 10267143325db76d6c3dabce82500f8cc7c93a941970John McCall if (vla) Ty = getContext().getBaseElementType(vla); 10275576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall 10289021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty); 10299021718882441dd391a1960084580d3cd19c423aJohn McCall 10309dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman llvm::GlobalVariable *NullVariable = 10319021718882441dd391a1960084580d3cd19c423aJohn McCall new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(), 10329dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman /*isConstant=*/true, 10339021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::GlobalVariable::PrivateLinkage, 10345f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner NullConstant, Twine()); 10359021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::Value *SrcPtr = 10369021718882441dd391a1960084580d3cd19c423aJohn McCall Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()); 10379021718882441dd391a1960084580d3cd19c423aJohn McCall 10387143325db76d6c3dabce82500f8cc7c93a941970John McCall if (vla) return emitNonZeroVLAInit(*this, Ty, DestPtr, SrcPtr, SizeVal); 10397143325db76d6c3dabce82500f8cc7c93a941970John McCall 10409021718882441dd391a1960084580d3cd19c423aJohn McCall // Get and call the appropriate llvm.memcpy overload. 104179be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, Align.getQuantity(), false); 104288207c9ca218486b93ae7df14e9764cd0c2c3383Chris Lattner return; 10439dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman } 10449dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 10459021718882441dd391a1960084580d3cd19c423aJohn McCall // Otherwise, just memset the whole thing to zero. This is legal 10469021718882441dd391a1960084580d3cd19c423aJohn McCall // because in LLVM, all default initializers (other than the ones we just 10479021718882441dd391a1960084580d3cd19c423aJohn McCall // handled above) are guaranteed to have a bit pattern of all zeros. 10489dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal, 104979be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck Align.getQuantity(), false); 10503d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson} 10513d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 1052ad8dcf4a9df0e24051dc31bf9e6f3cd138a34298Chris Lattnerllvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelDecl *L) { 1053d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Make sure that there is a block for the indirect goto. 1054d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch == 0) 1055d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner GetIndirectGotoBlock(); 10569dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 1057ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock(); 10589dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 1059d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Make sure the indirect branch includes all of the address-taken blocks. 1060d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner IndirectBranch->addDestination(BB); 1061d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return llvm::BlockAddress::get(CurFn, BB); 10623d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner} 10631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10643d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattnerllvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() { 1065d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If we already made the indirect branch for indirect goto, return its block. 1066d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) return IndirectBranch->getParent(); 10679dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 1068d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner CGBuilderTy TmpBuilder(createBasicBlock("indirectgoto")); 10699dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 10703d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner // Create the PHI node that indirect gotos will add entries to. 1071bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, 0, 1072bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad "indirect.goto.dest"); 10739dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 1074d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Create the indirect branch instruction. 1075d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal); 1076d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return IndirectBranch->getParent(); 10770ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar} 1078ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 1079bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall/// Computes the length of an array in elements, as well as the base 1080bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall/// element type and a properly-typed first element pointer. 1081bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCallllvm::Value *CodeGenFunction::emitArrayLength(const ArrayType *origArrayType, 1082bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall QualType &baseType, 1083bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall llvm::Value *&addr) { 1084bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall const ArrayType *arrayType = origArrayType; 1085bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1086bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // If it's a VLA, we have to load the stored size. Note that 1087bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // this is the size of the VLA in bytes, not its size in elements. 1088bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall llvm::Value *numVLAElements = 0; 1089bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall if (isa<VariableArrayType>(arrayType)) { 1090bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall numVLAElements = getVLASize(cast<VariableArrayType>(arrayType)).first; 1091bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1092bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // Walk into all VLAs. This doesn't require changes to addr, 1093bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // which has type T* where T is the first non-VLA element type. 1094bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall do { 1095bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall QualType elementType = arrayType->getElementType(); 1096bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall arrayType = getContext().getAsArrayType(elementType); 1097bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1098bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // If we only have VLA components, 'addr' requires no adjustment. 1099bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall if (!arrayType) { 1100bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall baseType = elementType; 1101bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall return numVLAElements; 1102bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall } 1103bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall } while (isa<VariableArrayType>(arrayType)); 1104bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1105bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // We get out here only if we find a constant array type 1106bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // inside the VLA. 1107bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall } 1108bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1109bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // We have some number of constant-length arrays, so addr should 1110bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // have LLVM type [M x [N x [...]]]*. Build a GEP that walks 1111bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // down to the first element of addr. 11125f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<llvm::Value*, 8> gepIndices; 1113bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1114bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // GEP down to the array type. 1115bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall llvm::ConstantInt *zero = Builder.getInt32(0); 1116bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall gepIndices.push_back(zero); 1117bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1118bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall uint64_t countFromCLAs = 1; 11191664d540d1524f0faffd2f839fccb56178975c60Richard Smith QualType eltType; 1120bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 11212acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::ArrayType *llvmArrayType = 11221664d540d1524f0faffd2f839fccb56178975c60Richard Smith dyn_cast<llvm::ArrayType>( 1123bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall cast<llvm::PointerType>(addr->getType())->getElementType()); 11241664d540d1524f0faffd2f839fccb56178975c60Richard Smith while (llvmArrayType) { 1125bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall assert(isa<ConstantArrayType>(arrayType)); 1126bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall assert(cast<ConstantArrayType>(arrayType)->getSize().getZExtValue() 1127bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall == llvmArrayType->getNumElements()); 1128bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1129bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall gepIndices.push_back(zero); 1130bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall countFromCLAs *= llvmArrayType->getNumElements(); 11311664d540d1524f0faffd2f839fccb56178975c60Richard Smith eltType = arrayType->getElementType(); 1132bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1133bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall llvmArrayType = 1134bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall dyn_cast<llvm::ArrayType>(llvmArrayType->getElementType()); 1135bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall arrayType = getContext().getAsArrayType(arrayType->getElementType()); 11361664d540d1524f0faffd2f839fccb56178975c60Richard Smith assert((!llvmArrayType || arrayType) && 11371664d540d1524f0faffd2f839fccb56178975c60Richard Smith "LLVM and Clang types are out-of-synch"); 1138bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall } 1139bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 11401664d540d1524f0faffd2f839fccb56178975c60Richard Smith if (arrayType) { 11411664d540d1524f0faffd2f839fccb56178975c60Richard Smith // From this point onwards, the Clang array type has been emitted 11421664d540d1524f0faffd2f839fccb56178975c60Richard Smith // as some other type (probably a packed struct). Compute the array 11431664d540d1524f0faffd2f839fccb56178975c60Richard Smith // size, and just emit the 'begin' expression as a bitcast. 11441664d540d1524f0faffd2f839fccb56178975c60Richard Smith while (arrayType) { 11451664d540d1524f0faffd2f839fccb56178975c60Richard Smith countFromCLAs *= 11461664d540d1524f0faffd2f839fccb56178975c60Richard Smith cast<ConstantArrayType>(arrayType)->getSize().getZExtValue(); 11471664d540d1524f0faffd2f839fccb56178975c60Richard Smith eltType = arrayType->getElementType(); 11481664d540d1524f0faffd2f839fccb56178975c60Richard Smith arrayType = getContext().getAsArrayType(eltType); 11491664d540d1524f0faffd2f839fccb56178975c60Richard Smith } 11501664d540d1524f0faffd2f839fccb56178975c60Richard Smith 1151956a5a17713deb1b5b27893303c4f308a1bd2a62Micah Villmow unsigned AddressSpace = addr->getType()->getPointerAddressSpace(); 11521664d540d1524f0faffd2f839fccb56178975c60Richard Smith llvm::Type *BaseType = ConvertType(eltType)->getPointerTo(AddressSpace); 11531664d540d1524f0faffd2f839fccb56178975c60Richard Smith addr = Builder.CreateBitCast(addr, BaseType, "array.begin"); 11541664d540d1524f0faffd2f839fccb56178975c60Richard Smith } else { 11551664d540d1524f0faffd2f839fccb56178975c60Richard Smith // Create the actual GEP. 11561664d540d1524f0faffd2f839fccb56178975c60Richard Smith addr = Builder.CreateInBoundsGEP(addr, gepIndices, "array.begin"); 11571664d540d1524f0faffd2f839fccb56178975c60Richard Smith } 1158bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 11591664d540d1524f0faffd2f839fccb56178975c60Richard Smith baseType = eltType; 1160bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1161bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall llvm::Value *numElements 1162bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall = llvm::ConstantInt::get(SizeTy, countFromCLAs); 1163bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1164bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // If we had any VLA dimensions, factor them in. 1165bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall if (numVLAElements) 1166bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall numElements = Builder.CreateNUWMul(numVLAElements, numElements); 1167bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1168bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall return numElements; 1169bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall} 1170bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1171bc8d40d85f3fa1e34569834916f18fecaa635152John McCallstd::pair<llvm::Value*, QualType> 1172bc8d40d85f3fa1e34569834916f18fecaa635152John McCallCodeGenFunction::getVLASize(QualType type) { 1173bc8d40d85f3fa1e34569834916f18fecaa635152John McCall const VariableArrayType *vla = getContext().getAsVariableArrayType(type); 1174bc8d40d85f3fa1e34569834916f18fecaa635152John McCall assert(vla && "type was not a variable array type!"); 1175bc8d40d85f3fa1e34569834916f18fecaa635152John McCall return getVLASize(vla); 1176f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson} 1177dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson 1178bc8d40d85f3fa1e34569834916f18fecaa635152John McCallstd::pair<llvm::Value*, QualType> 1179bc8d40d85f3fa1e34569834916f18fecaa635152John McCallCodeGenFunction::getVLASize(const VariableArrayType *type) { 1180bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // The number of elements so far; always size_t. 1181bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::Value *numElements = 0; 11821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1183bc8d40d85f3fa1e34569834916f18fecaa635152John McCall QualType elementType; 1184bc8d40d85f3fa1e34569834916f18fecaa635152John McCall do { 1185bc8d40d85f3fa1e34569834916f18fecaa635152John McCall elementType = type->getElementType(); 1186bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::Value *vlaSize = VLASizeMap[type->getSizeExpr()]; 1187bc8d40d85f3fa1e34569834916f18fecaa635152John McCall assert(vlaSize && "no size for VLA!"); 1188bc8d40d85f3fa1e34569834916f18fecaa635152John McCall assert(vlaSize->getType() == SizeTy); 11891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1190bc8d40d85f3fa1e34569834916f18fecaa635152John McCall if (!numElements) { 1191bc8d40d85f3fa1e34569834916f18fecaa635152John McCall numElements = vlaSize; 1192bc8d40d85f3fa1e34569834916f18fecaa635152John McCall } else { 1193bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // It's undefined behavior if this wraps around, so mark it that way. 1194930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith // FIXME: Teach -fcatch-undefined-behavior to trap this. 1195bc8d40d85f3fa1e34569834916f18fecaa635152John McCall numElements = Builder.CreateNUWMul(numElements, vlaSize); 1196bc8d40d85f3fa1e34569834916f18fecaa635152John McCall } 1197bc8d40d85f3fa1e34569834916f18fecaa635152John McCall } while ((type = getContext().getAsVariableArrayType(elementType))); 11981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1199bc8d40d85f3fa1e34569834916f18fecaa635152John McCall return std::pair<llvm::Value*,QualType>(numElements, elementType); 1200bc8d40d85f3fa1e34569834916f18fecaa635152John McCall} 12011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1202bc8d40d85f3fa1e34569834916f18fecaa635152John McCallvoid CodeGenFunction::EmitVariablyModifiedType(QualType type) { 1203bc8d40d85f3fa1e34569834916f18fecaa635152John McCall assert(type->isVariablyModifiedType() && 1204bc8d40d85f3fa1e34569834916f18fecaa635152John McCall "Must pass variably modified type to EmitVLASizes!"); 12051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1206bc8d40d85f3fa1e34569834916f18fecaa635152John McCall EnsureInsertPoint(); 12071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1208bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // We're going to walk down into the type and look for VLA 1209bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // expressions. 1210bc8d40d85f3fa1e34569834916f18fecaa635152John McCall do { 1211bc8d40d85f3fa1e34569834916f18fecaa635152John McCall assert(type->isVariablyModifiedType()); 1212bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1213bc8d40d85f3fa1e34569834916f18fecaa635152John McCall const Type *ty = type.getTypePtr(); 1214bc8d40d85f3fa1e34569834916f18fecaa635152John McCall switch (ty->getTypeClass()) { 121506284c1dc56caed19850bc3766c89f51763724c3Abramo Bagnara 1216bc8d40d85f3fa1e34569834916f18fecaa635152John McCall#define TYPE(Class, Base) 1217bc8d40d85f3fa1e34569834916f18fecaa635152John McCall#define ABSTRACT_TYPE(Class, Base) 121806284c1dc56caed19850bc3766c89f51763724c3Abramo Bagnara#define NON_CANONICAL_TYPE(Class, Base) 1219bc8d40d85f3fa1e34569834916f18fecaa635152John McCall#define DEPENDENT_TYPE(Class, Base) case Type::Class: 122006284c1dc56caed19850bc3766c89f51763724c3Abramo Bagnara#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) 1221bc8d40d85f3fa1e34569834916f18fecaa635152John McCall#include "clang/AST/TypeNodes.def" 122206284c1dc56caed19850bc3766c89f51763724c3Abramo Bagnara llvm_unreachable("unexpected dependent type!"); 1223bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1224bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // These types are never variably-modified. 1225bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::Builtin: 1226bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::Complex: 1227bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::Vector: 1228bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::ExtVector: 1229bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::Record: 1230bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::Enum: 12315ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::Elaborated: 12325ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::TemplateSpecialization: 1233bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::ObjCObject: 1234bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::ObjCInterface: 1235bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::ObjCObjectPointer: 1236bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm_unreachable("type class is never variably-modified!"); 1237bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1238bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::Pointer: 1239bc8d40d85f3fa1e34569834916f18fecaa635152John McCall type = cast<PointerType>(ty)->getPointeeType(); 1240bc8d40d85f3fa1e34569834916f18fecaa635152John McCall break; 1241bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1242bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::BlockPointer: 1243bc8d40d85f3fa1e34569834916f18fecaa635152John McCall type = cast<BlockPointerType>(ty)->getPointeeType(); 1244bc8d40d85f3fa1e34569834916f18fecaa635152John McCall break; 1245bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1246bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::LValueReference: 1247bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::RValueReference: 1248bc8d40d85f3fa1e34569834916f18fecaa635152John McCall type = cast<ReferenceType>(ty)->getPointeeType(); 1249bc8d40d85f3fa1e34569834916f18fecaa635152John McCall break; 1250bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1251bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::MemberPointer: 1252bc8d40d85f3fa1e34569834916f18fecaa635152John McCall type = cast<MemberPointerType>(ty)->getPointeeType(); 1253bc8d40d85f3fa1e34569834916f18fecaa635152John McCall break; 1254bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1255bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::ConstantArray: 1256bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::IncompleteArray: 1257bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // Losing element qualification here is fine. 1258bc8d40d85f3fa1e34569834916f18fecaa635152John McCall type = cast<ArrayType>(ty)->getElementType(); 1259bc8d40d85f3fa1e34569834916f18fecaa635152John McCall break; 1260bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1261bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::VariableArray: { 1262bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // Losing element qualification here is fine. 1263bc8d40d85f3fa1e34569834916f18fecaa635152John McCall const VariableArrayType *vat = cast<VariableArrayType>(ty); 1264bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1265bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // Unknown size indication requires no size computation. 1266bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // Otherwise, evaluate and record it. 1267bc8d40d85f3fa1e34569834916f18fecaa635152John McCall if (const Expr *size = vat->getSizeExpr()) { 1268bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // It's possible that we might have emitted this already, 1269bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // e.g. with a typedef and a pointer to it. 1270bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::Value *&entry = VLASizeMap[size]; 1271bc8d40d85f3fa1e34569834916f18fecaa635152John McCall if (!entry) { 1272930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith llvm::Value *Size = EmitScalarExpr(size); 1273930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith 1274930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith // C11 6.7.6.2p5: 1275930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith // If the size is an expression that is not an integer constant 1276930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith // expression [...] each time it is evaluated it shall have a value 1277930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith // greater than zero. 12784f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz if (SanOpts->VLABound && 1279d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith size->getType()->isSignedIntegerType()) { 1280930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith llvm::Value *Zero = llvm::Constant::getNullValue(Size->getType()); 1281930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith llvm::Constant *StaticArgs[] = { 1282930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith EmitCheckSourceLocation(size->getLocStart()), 1283930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith EmitCheckTypeDescriptor(size->getType()) 1284930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith }; 1285930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith EmitCheck(Builder.CreateICmpSGT(Size, Zero), 1286ad95481b2769ad61f23afc5e2c31f11c66090657Will Dietz "vla_bound_not_positive", StaticArgs, Size, 1287ad95481b2769ad61f23afc5e2c31f11c66090657Will Dietz CRK_Recoverable); 1288930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith } 1289930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith 1290bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // Always zexting here would be wrong if it weren't 1291bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // undefined behavior to have a negative bound. 1292bf43f2fdfbd7c4f8cd1f1403765eca9e5dc6c8aeRichard Smith entry = Builder.CreateIntCast(Size, SizeTy, /*signed*/ false); 1293bc8d40d85f3fa1e34569834916f18fecaa635152John McCall } 1294bc8d40d85f3fa1e34569834916f18fecaa635152John McCall } 1295bc8d40d85f3fa1e34569834916f18fecaa635152John McCall type = vat->getElementType(); 1296bc8d40d85f3fa1e34569834916f18fecaa635152John McCall break; 1297fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson } 12981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 129906284c1dc56caed19850bc3766c89f51763724c3Abramo Bagnara case Type::FunctionProto: 1300bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::FunctionNoProto: 1301bc8d40d85f3fa1e34569834916f18fecaa635152John McCall type = cast<FunctionType>(ty)->getResultType(); 1302bc8d40d85f3fa1e34569834916f18fecaa635152John McCall break; 1303b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 13045ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::Paren: 13055ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::TypeOf: 13065ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::UnaryTransform: 13075ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::Attributed: 13085ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::SubstTemplateTypeParm: 13095ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara // Keep walking after single level desugaring. 13105ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara type = type.getSingleStepDesugaredType(getContext()); 13115ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara break; 13125ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara 13135ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::Typedef: 13145ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::Decltype: 13155ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::Auto: 13165ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara // Stop walking: nothing to do. 13175ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara return; 13185ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara 13195ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::TypeOfExpr: 13205ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara // Stop walking: emit typeof expression. 13215ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara EmitIgnoredExpr(cast<TypeOfExprType>(ty)->getUnderlyingExpr()); 13225ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara return; 13235ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara 1324b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: 1325b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman type = cast<AtomicType>(ty)->getValueType(); 1326b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman break; 1327bc8d40d85f3fa1e34569834916f18fecaa635152John McCall } 1328bc8d40d85f3fa1e34569834916f18fecaa635152John McCall } while (type->isVariablyModifiedType()); 1329dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson} 13304fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman 13314fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedmanllvm::Value* CodeGenFunction::EmitVAListRef(const Expr* E) { 1332bc07a55b68342a230aafd8875cc7a26450dd3f64Dan Gohman if (getContext().getBuiltinVaListType()->isArrayType()) 13334fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman return EmitScalarExpr(E); 13344fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman return EmitLValue(E).getAddress(); 13354fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman} 13366ccc47698d0311ddabf32fa0f6db8e4f09ac96f8Anders Carlsson 13379dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilsemanvoid CodeGenFunction::EmitDeclRefExprDbgValue(const DeclRefExpr *E, 1338189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall llvm::Constant *Init) { 133925c2c8fb9309050612009a6571e2660e75531348Devang Patel assert (Init && "Invalid DeclRefExpr initializer!"); 134025c2c8fb9309050612009a6571e2660e75531348Devang Patel if (CGDebugInfo *Dbg = getDebugInfo()) 13414cdad3151bfb2075c6bdbfe89fbb08f31a90a45bDouglas Gregor if (CGM.getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) 1342fd00eecad6fa5400cf37269d84361a0551d0e6d3Alexey Samsonov Dbg->EmitGlobalVariable(E->getDecl(), Init); 13438d308384a220c7dc81755c47cdcbdd87dac25d5bDevang Patel} 134456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 134556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCallCodeGenFunction::PeepholeProtection 134656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCallCodeGenFunction::protectFromPeepholes(RValue rvalue) { 134756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // At the moment, the only aggressive peephole we do in IR gen 134856ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // is trunc(zext) folding, but if we add more, we can easily 134956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // extend this protection. 135056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 135156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (!rvalue.isScalar()) return PeepholeProtection(); 135256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *value = rvalue.getScalarVal(); 135356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (!isa<llvm::ZExtInst>(value)) return PeepholeProtection(); 135456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 135556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // Just make an extra bitcast. 135656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall assert(HaveInsertPoint()); 135756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Instruction *inst = new llvm::BitCastInst(value, value->getType(), "", 135856ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Builder.GetInsertBlock()); 135956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 136056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall PeepholeProtection protection; 136156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall protection.Inst = inst; 136256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall return protection; 136356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall} 136456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 136556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCallvoid CodeGenFunction::unprotectFromPeepholes(PeepholeProtection protection) { 136656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (!protection.Inst) return; 136756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 136856ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // In theory, we could try to duplicate the peepholes now, but whatever. 136956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall protection.Inst->eraseFromParent(); 137056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall} 137177f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge 137277f68bb90af93b95045fb994e7cd68137adcc132Julien Lerougellvm::Value *CodeGenFunction::EmitAnnotationCall(llvm::Value *AnnotationFn, 137377f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge llvm::Value *AnnotatedVal, 1374cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko StringRef AnnotationStr, 137577f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge SourceLocation Location) { 137677f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge llvm::Value *Args[4] = { 137777f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge AnnotatedVal, 137877f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge Builder.CreateBitCast(CGM.EmitAnnotationString(AnnotationStr), Int8PtrTy), 137977f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge Builder.CreateBitCast(CGM.EmitAnnotationUnit(Location), Int8PtrTy), 138077f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge CGM.EmitAnnotationLineNo(Location) 138177f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge }; 138277f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge return Builder.CreateCall(AnnotationFn, Args); 138377f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge} 138477f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge 138577f68bb90af93b95045fb994e7cd68137adcc132Julien Lerougevoid CodeGenFunction::EmitVarAnnotations(const VarDecl *D, llvm::Value *V) { 138677f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute"); 138777f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge // FIXME We create a new bitcast for every annotation because that's what 138877f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge // llvm-gcc was doing. 138977f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge for (specific_attr_iterator<AnnotateAttr> 139077f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge ai = D->specific_attr_begin<AnnotateAttr>(), 139177f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai) 139277f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge EmitAnnotationCall(CGM.getIntrinsic(llvm::Intrinsic::var_annotation), 139377f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge Builder.CreateBitCast(V, CGM.Int8PtrTy, V->getName()), 139477f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge (*ai)->getAnnotation(), D->getLocation()); 139577f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge} 139677f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge 139777f68bb90af93b95045fb994e7cd68137adcc132Julien Lerougellvm::Value *CodeGenFunction::EmitFieldAnnotations(const FieldDecl *D, 139877f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge llvm::Value *V) { 139977f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute"); 140077f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge llvm::Type *VTy = V->getType(); 140177f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::ptr_annotation, 140277f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge CGM.Int8PtrTy); 140377f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge 140477f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge for (specific_attr_iterator<AnnotateAttr> 140577f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge ai = D->specific_attr_begin<AnnotateAttr>(), 140677f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai) { 140777f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge // FIXME Always emit the cast inst so we can differentiate between 140877f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge // annotation on the first field of a struct and annotation on the struct 140977f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge // itself. 141077f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge if (VTy != CGM.Int8PtrTy) 141177f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge V = Builder.Insert(new llvm::BitCastInst(V, CGM.Int8PtrTy)); 141277f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge V = EmitAnnotationCall(F, V, (*ai)->getAnnotation(), D->getLocation()); 141377f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge V = Builder.CreateBitCast(V, VTy); 141477f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge } 141577f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge 141677f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge return V; 141777f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge} 1418