CodeGenFunction.cpp revision f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58
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), 47bb09f7b1d9312471b701f2683a9d955b4e954630Adrian Prantl NumStopPoints(0), NumSimpleReturnExprs(0), 4859660c21178b6af518bd4b564e032d5c9cc218cbTimur Iskhodzhanov CXXABIThisDecl(0), CXXABIThisValue(0), CXXThisValue(0), 49c3bf52ced9652f555aa0767bb822ec4c64546212Richard Smith CXXDefaultInitExprThis(0), 5059660c21178b6af518bd4b564e032d5c9cc218cbTimur Iskhodzhanov CXXStructorImplicitParamDecl(0), CXXStructorImplicitParamValue(0), 51495cfa46300979642acde8d93a1f21c9291dac98Nadav Rotem OutermostConditional(0), CurLexicalScope(0), TerminateLandingPad(0), 52cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman TerminateHandler(0), TrapBB(0) { 534904bf4e84cfb48080270ebaa9005327f18ab0e5Fariborz Jahanian if (!suppressNewContext) 544904bf4e84cfb48080270ebaa9005327f18ab0e5Fariborz Jahanian CGM.getCXXABI().getMangleContext().startNewFunction(); 55cdeb7d57a4867c28e3e6a8c391cba6f13c781fa6Michael Ilseman 56cdeb7d57a4867c28e3e6a8c391cba6f13c781fa6Michael Ilseman llvm::FastMathFlags FMF; 57cdeb7d57a4867c28e3e6a8c391cba6f13c781fa6Michael Ilseman if (CGM.getLangOpts().FastMath) 5829573b0a825b888c233d7859a257e866ffc5276eBenjamin Kramer FMF.setUnsafeAlgebra(); 59cdeb7d57a4867c28e3e6a8c391cba6f13c781fa6Michael Ilseman if (CGM.getLangOpts().FiniteMathOnly) { 6029573b0a825b888c233d7859a257e866ffc5276eBenjamin Kramer FMF.setNoNaNs(); 6129573b0a825b888c233d7859a257e866ffc5276eBenjamin Kramer FMF.setNoInfs(); 62cdeb7d57a4867c28e3e6a8c391cba6f13c781fa6Michael Ilseman } 63cdeb7d57a4867c28e3e6a8c391cba6f13c781fa6Michael Ilseman Builder.SetFastMathFlags(FMF); 644111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner} 655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 661a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCallCodeGenFunction::~CodeGenFunction() { 671a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall // If there are any unclaimed block infos, go ahead and destroy them 681a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall // now. This can happen if IR-gen gets clever and skips evaluating 691a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall // something. 701a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall if (FirstBlockInfo) 711a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall destroyBlockInfos(FirstBlockInfo); 721a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall} 731a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall 745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 759cbe4f0ba01ec304e1e3d071c071f7bca33631c0Chris Lattnerllvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) { 768b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar return CGM.getTypes().ConvertTypeForMem(T); 778b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar} 788b1a343b6b360d63d5dc8a6beb841ce4414c1e00Daniel Dunbar 799cbe4f0ba01ec304e1e3d071c071f7bca33631c0Chris Lattnerllvm::Type *CodeGenFunction::ConvertType(QualType T) { 805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return CGM.getTypes().ConvertType(T); 815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 839d232c884ea9872d6555df0fd7359699819bc1f1John McCallTypeEvaluationKind CodeGenFunction::getEvaluationKind(QualType type) { 849d232c884ea9872d6555df0fd7359699819bc1f1John McCall type = type.getCanonicalType(); 859d232c884ea9872d6555df0fd7359699819bc1f1John McCall while (true) { 869d232c884ea9872d6555df0fd7359699819bc1f1John McCall switch (type->getTypeClass()) { 87f2aac84709c418189e476ad591848dad50291885John McCall#define TYPE(name, parent) 88f2aac84709c418189e476ad591848dad50291885John McCall#define ABSTRACT_TYPE(name, parent) 89f2aac84709c418189e476ad591848dad50291885John McCall#define NON_CANONICAL_TYPE(name, parent) case Type::name: 90f2aac84709c418189e476ad591848dad50291885John McCall#define DEPENDENT_TYPE(name, parent) case Type::name: 91f2aac84709c418189e476ad591848dad50291885John McCall#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(name, parent) case Type::name: 92f2aac84709c418189e476ad591848dad50291885John McCall#include "clang/AST/TypeNodes.def" 939d232c884ea9872d6555df0fd7359699819bc1f1John McCall llvm_unreachable("non-canonical or dependent type in IR-generation"); 949d232c884ea9872d6555df0fd7359699819bc1f1John McCall 95dc7a4f5d7a7e3b60d4dc4a80338d7a2728540998Richard Smith case Type::Auto: 96dc7a4f5d7a7e3b60d4dc4a80338d7a2728540998Richard Smith llvm_unreachable("undeduced auto type in IR-generation"); 97dc7a4f5d7a7e3b60d4dc4a80338d7a2728540998Richard Smith 989d232c884ea9872d6555df0fd7359699819bc1f1John McCall // Various scalar types. 999d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::Builtin: 1009d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::Pointer: 1019d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::BlockPointer: 1029d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::LValueReference: 1039d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::RValueReference: 1049d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::MemberPointer: 1059d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::Vector: 1069d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::ExtVector: 1079d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::FunctionProto: 1089d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::FunctionNoProto: 1099d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::Enum: 1109d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::ObjCObjectPointer: 1119d232c884ea9872d6555df0fd7359699819bc1f1John McCall return TEK_Scalar; 1129d232c884ea9872d6555df0fd7359699819bc1f1John McCall 1139d232c884ea9872d6555df0fd7359699819bc1f1John McCall // Complexes. 1149d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::Complex: 1159d232c884ea9872d6555df0fd7359699819bc1f1John McCall return TEK_Complex; 1169d232c884ea9872d6555df0fd7359699819bc1f1John McCall 1179d232c884ea9872d6555df0fd7359699819bc1f1John McCall // Arrays, records, and Objective-C objects. 1189d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::ConstantArray: 1199d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::IncompleteArray: 1209d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::VariableArray: 1219d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::Record: 1229d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::ObjCObject: 1239d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::ObjCInterface: 1249d232c884ea9872d6555df0fd7359699819bc1f1John McCall return TEK_Aggregate; 1259d232c884ea9872d6555df0fd7359699819bc1f1John McCall 1269d232c884ea9872d6555df0fd7359699819bc1f1John McCall // We operate on atomic values according to their underlying type. 1279d232c884ea9872d6555df0fd7359699819bc1f1John McCall case Type::Atomic: 1289d232c884ea9872d6555df0fd7359699819bc1f1John McCall type = cast<AtomicType>(type)->getValueType(); 1299d232c884ea9872d6555df0fd7359699819bc1f1John McCall continue; 1309d232c884ea9872d6555df0fd7359699819bc1f1John McCall } 1319d232c884ea9872d6555df0fd7359699819bc1f1John McCall llvm_unreachable("unknown type kind!"); 132f2aac84709c418189e476ad591848dad50291885John McCall } 1334111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner} 134391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner 1350a0f93c90fd397a1aa9f97283c55f8ba0062bf55David Blaikievoid CodeGenFunction::EmitReturnBlock() { 1361c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // For cleanliness, we try to avoid emitting the return block for 1371c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // simple cases. 1381c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); 1391c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 1401c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar if (CurBB) { 1411c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar assert(!CurBB->getTerminator() && "Unexpected terminated block."); 1421c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 14396e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar // We have a valid insert point, reuse it if it is empty or there are no 14496e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar // explicit jumps to the return block. 145ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) { 146ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall ReturnBlock.getBlock()->replaceAllUsesWith(CurBB); 147ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall delete ReturnBlock.getBlock(); 14896e18b05ea6b55aa92a1a576f29e9cee73a7e20bDaniel Dunbar } else 149ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitBlock(ReturnBlock.getBlock()); 1500a0f93c90fd397a1aa9f97283c55f8ba0062bf55David Blaikie return; 1511c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 1521c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 1531c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // Otherwise, if the return block is the target of a single direct 1541c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // branch then we can just put the code in that block instead. This 1551c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar // cleans up functions which started with a unified return block. 156ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall if (ReturnBlock.getBlock()->hasOneUse()) { 1571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump llvm::BranchInst *BI = 158ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->use_begin()); 159f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (BI && BI->isUnconditional() && 160ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall BI->getSuccessor(0) == ReturnBlock.getBlock()) { 161c5139a9f0c9d4f835e4ab0b51e78d2f74fb488d9David Blaikie // Reset insertion point, including debug location, and delete the 162c5139a9f0c9d4f835e4ab0b51e78d2f74fb488d9David Blaikie // branch. This is really subtle and only works because the next change 163c5139a9f0c9d4f835e4ab0b51e78d2f74fb488d9David Blaikie // in location will hit the caching in CGDebugInfo::EmitLocation and not 164c5139a9f0c9d4f835e4ab0b51e78d2f74fb488d9David Blaikie // override this. 165acae01124151392a842bd6c37bd01b1ad56d6b4dEric Christopher Builder.SetCurrentDebugLocation(BI->getDebugLoc()); 1661c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar Builder.SetInsertPoint(BI->getParent()); 1671c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar BI->eraseFromParent(); 168ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall delete ReturnBlock.getBlock(); 1690a0f93c90fd397a1aa9f97283c55f8ba0062bf55David Blaikie return; 1701c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 1711c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar } 1721c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 173f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // FIXME: We are at an unreachable point, there is no reason to emit the block 174f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // unless it has uses. However, we still need a place to put the debug 175f5408fe484495ee4efbdd709c8a2c2fdbbbdb328Mike Stump // region.end for now. 1761c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 177ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall EmitBlock(ReturnBlock.getBlock()); 178f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall} 179f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 180f1549f66a8216a78112286e3978cea2c29d6334cJohn McCallstatic void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) { 181f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (!BB) return; 182f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall if (!BB->use_empty()) 183f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall return CGF.CurFn->getBasicBlockList().push_back(BB); 184f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall delete BB; 1851c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar} 1861c1d6074f5a0296dd273362655b1b8f9057289e3Daniel Dunbar 187af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbarvoid CodeGenFunction::FinishFunction(SourceLocation EndLoc) { 188391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner assert(BreakContinueStack.empty() && 189391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner "mismatched push/pop in break/continue stack!"); 1901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 191bb09f7b1d9312471b701f2683a9d955b4e954630Adrian Prantl // If the function contains only a single, simple return statement, 192bb09f7b1d9312471b701f2683a9d955b4e954630Adrian Prantl // the cleanup code may become the first breakpoint in the 193bb09f7b1d9312471b701f2683a9d955b4e954630Adrian Prantl // function. To be safe set the debug location for it to the 194bb09f7b1d9312471b701f2683a9d955b4e954630Adrian Prantl // location of the return statement. Otherwise point it to end of 195bb09f7b1d9312471b701f2683a9d955b4e954630Adrian Prantl // the function's lexical scope. 196fa6b079b1231366696f6a497c6a084c73a35c85dAdrian Prantl if (CGDebugInfo *DI = getDebugInfo()) { 197bb09f7b1d9312471b701f2683a9d955b4e954630Adrian Prantl if (NumSimpleReturnExprs == 1 && NumStopPoints == 1) 198bb09f7b1d9312471b701f2683a9d955b4e954630Adrian Prantl DI->EmitLocation(Builder, FirstStopPoint); 199fa6b079b1231366696f6a497c6a084c73a35c85dAdrian Prantl else 200fa6b079b1231366696f6a497c6a084c73a35c85dAdrian Prantl DI->EmitLocation(Builder, EndLoc); 201fa6b079b1231366696f6a497c6a084c73a35c85dAdrian Prantl } 2020a0f93c90fd397a1aa9f97283c55f8ba0062bf55David Blaikie 203f85e193739c953358c865005855253af4f68a497John McCall // Pop any cleanups that might have been associated with the 204f85e193739c953358c865005855253af4f68a497John McCall // parameters. Do this in whatever block we're currently in; it's 205f85e193739c953358c865005855253af4f68a497John McCall // important to do this before we enter the return block or return 206f85e193739c953358c865005855253af4f68a497John McCall // edges will be *really* confused. 207fa6b079b1231366696f6a497c6a084c73a35c85dAdrian Prantl bool EmitRetDbgLoc = true; 208fa6b079b1231366696f6a497c6a084c73a35c85dAdrian Prantl if (EHStack.stable_begin() != PrologueCleanupDepth) { 209bb09f7b1d9312471b701f2683a9d955b4e954630Adrian Prantl PopCleanupBlocks(PrologueCleanupDepth); 210f85e193739c953358c865005855253af4f68a497John McCall 211fa6b079b1231366696f6a497c6a084c73a35c85dAdrian Prantl // Make sure the line table doesn't jump back into the body for 212fa6b079b1231366696f6a497c6a084c73a35c85dAdrian Prantl // the ret after it's been at EndLoc. 213fa6b079b1231366696f6a497c6a084c73a35c85dAdrian Prantl EmitRetDbgLoc = false; 214fa6b079b1231366696f6a497c6a084c73a35c85dAdrian Prantl 215fa6b079b1231366696f6a497c6a084c73a35c85dAdrian Prantl if (CGDebugInfo *DI = getDebugInfo()) 216bb09f7b1d9312471b701f2683a9d955b4e954630Adrian Prantl if (NumSimpleReturnExprs == 1 && NumStopPoints == 1) 217fa6b079b1231366696f6a497c6a084c73a35c85dAdrian Prantl DI->EmitLocation(Builder, EndLoc); 218fa6b079b1231366696f6a497c6a084c73a35c85dAdrian Prantl } 219fa6b079b1231366696f6a497c6a084c73a35c85dAdrian Prantl 2201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Emit function epilog (to return). 2210a0f93c90fd397a1aa9f97283c55f8ba0062bf55David Blaikie EmitReturnBlock(); 222f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar 223a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar if (ShouldInstrumentFunction()) 224a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar EmitFunctionInstrumentation("__cyg_profile_func_exit"); 2257255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 226f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar // Emit debug descriptor for function end. 227e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson if (CGDebugInfo *DI = getDebugInfo()) { 2285a6fbcfd8c15a2296f94a0473a68ec09d429827fDevang Patel DI->EmitFunctionEnd(Builder); 229f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar } 230f5bd45c8e6fa7519cdc17ec3ff4917e279c6a041Daniel Dunbar 231fa6b079b1231366696f6a497c6a084c73a35c85dAdrian Prantl EmitFunctionEpilog(*CurFnInfo, EmitRetDbgLoc); 232cce3d4f9812182ed4e551b7cf0fc86576be8d9c5Mike Stump EmitEndEHSpec(CurCodeDecl); 2335ca2084cf9b529563209429857f01fdae9dcdfa5Daniel Dunbar 234f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall assert(EHStack.empty() && 235f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall "did not remove all scopes from cleanup stack!"); 236f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 237d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If someone did an indirect goto, emit the indirect goto block at the end of 238d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // the function. 239d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) { 240d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner EmitBlock(IndirectBranch->getParent()); 241d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner Builder.ClearInsertionPoint(); 242d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 2439dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 244391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner // Remove the AllocaInsertPt instruction, which is just a convenience for us. 245481769b5dc102b0256b35581e787909ad5edfab5Chris Lattner llvm::Instruction *Ptr = AllocaInsertPt; 246391d77a26382dddf25da73e29fc1fa5aaaea4c6fChris Lattner AllocaInsertPt = 0; 247481769b5dc102b0256b35581e787909ad5edfab5Chris Lattner Ptr->eraseFromParent(); 2489dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 249d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If someone took the address of a label but never did an indirect goto, we 250d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // made a zero entry PHI node, which is illegal, zap it now. 251d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) { 252d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress()); 253d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (PN->getNumIncomingValues() == 0) { 254d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType())); 255d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner PN->eraseFromParent(); 256d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 257d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner } 258f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall 259777d6e56ad9b1fed9866daf3ee6486d85c5b7d32John McCall EmitIfUsed(*this, EHResumeBlock); 260f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, TerminateLandingPad); 261f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, TerminateHandler); 262f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall EmitIfUsed(*this, UnreachableBlock); 263744016dde06fcffd50931e94a98c850f8b12cd87John McCall 264744016dde06fcffd50931e94a98c850f8b12cd87John McCall if (CGM.getCodeGenOpts().EmitDeclMetadata) 265744016dde06fcffd50931e94a98c850f8b12cd87John McCall EmitDeclMetadata(); 266c8aa5f1f264fb230c38182adab944232bb160c2bChris Lattner} 267c8aa5f1f264fb230c38182adab944232bb160c2bChris Lattner 2687255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// ShouldInstrumentFunction - Return true if the current function should be 2697255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// instrumented with __cyg_profile_func_* calls 2707255a2d997b15beae82e627052fdb1b2474495c2Chris Lattnerbool CodeGenFunction::ShouldInstrumentFunction() { 2717255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner if (!CGM.getCodeGenOpts().InstrumentFunctions) 2727255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return false; 2737aa488a7fc5c3a8cd1a2b93476150e9737760713Ted Kremenek if (!CurFuncDecl || CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>()) 2747255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return false; 2757255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner return true; 2767255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner} 2777255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 2787255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// EmitFunctionInstrumentation - Emit LLVM code to call the specified 2797255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// instrumentation function with the current function and the call site, if 2807255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner/// function instrumentation is enabled. 2817255a2d997b15beae82e627052fdb1b2474495c2Chris Lattnervoid CodeGenFunction::EmitFunctionInstrumentation(const char *Fn) { 2828dab6571b2cab96f44d0a1d6e3edbfdb68b7ed6bChris Lattner // void __cyg_profile_func_{enter,exit} (void *this_fn, void *call_site); 2839cbe4f0ba01ec304e1e3d071c071f7bca33631c0Chris Lattner llvm::PointerType *PointerTy = Int8PtrTy; 2849cbe4f0ba01ec304e1e3d071c071f7bca33631c0Chris Lattner llvm::Type *ProfileFuncArgs[] = { PointerTy, PointerTy }; 2852acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::FunctionType *FunctionTy = 2868b418685e9e4f02f4eb2a76e1ec063e07552b68dChris Lattner llvm::FunctionType::get(VoidTy, ProfileFuncArgs, false); 2877255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 2887255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner llvm::Constant *F = CGM.CreateRuntimeFunction(FunctionTy, Fn); 2897255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner llvm::CallInst *CallSite = Builder.CreateCall( 2908dd55a3c3b28d195717c87bbc60e765951d408feBenjamin Kramer CGM.getIntrinsic(llvm::Intrinsic::returnaddress), 29177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::ConstantInt::get(Int32Ty, 0), 2927255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner "callsite"); 2937255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 294bd7370a78604e9a20d698bfe328c1e43f12a0613John McCall llvm::Value *args[] = { 295bd7370a78604e9a20d698bfe328c1e43f12a0613John McCall llvm::ConstantExpr::getBitCast(CurFn, PointerTy), 296bd7370a78604e9a20d698bfe328c1e43f12a0613John McCall CallSite 297bd7370a78604e9a20d698bfe328c1e43f12a0613John McCall }; 298bd7370a78604e9a20d698bfe328c1e43f12a0613John McCall 299bd7370a78604e9a20d698bfe328c1e43f12a0613John McCall EmitNounwindRuntimeCall(F, args); 3007255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner} 3017255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 302be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divackyvoid CodeGenFunction::EmitMCountInstrumentation() { 3038b418685e9e4f02f4eb2a76e1ec063e07552b68dChris Lattner llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); 304be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky 30564aa4b3ec7e62288e2e66c1935487ece995ca94bJohn McCall llvm::Constant *MCountFn = 30664aa4b3ec7e62288e2e66c1935487ece995ca94bJohn McCall CGM.CreateRuntimeFunction(FTy, getTarget().getMCountName()); 307bd7370a78604e9a20d698bfe328c1e43f12a0613John McCall EmitNounwindRuntimeCall(MCountFn); 308be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky} 309be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky 310198871cc90375246d8692680467ff6e810edac36Tanya Lattner// OpenCL v1.2 s5.6.4.6 allows the compiler to store kernel argument 311198871cc90375246d8692680467ff6e810edac36Tanya Lattner// information in the program executable. The argument information stored 312198871cc90375246d8692680467ff6e810edac36Tanya Lattner// includes the argument name, its type, the address and access qualifiers used. 313198871cc90375246d8692680467ff6e810edac36Tanya Lattnerstatic void GenOpenCLArgMetadata(const FunctionDecl *FD, llvm::Function *Fn, 314198871cc90375246d8692680467ff6e810edac36Tanya Lattner CodeGenModule &CGM,llvm::LLVMContext &Context, 3151db7040604154f71c54cf1329ae384fbef196668Guy Benyei SmallVector <llvm::Value*, 5> &kernelMDArgs, 3161db7040604154f71c54cf1329ae384fbef196668Guy Benyei CGBuilderTy& Builder, ASTContext &ASTCtx) { 3171db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Create MDNodes that represent the kernel arg metadata. 318198871cc90375246d8692680467ff6e810edac36Tanya Lattner // Each MDNode is a list in the form of "key", N number of values which is 319198871cc90375246d8692680467ff6e810edac36Tanya Lattner // the same number of values as their are kernel arguments. 3209dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 3211db7040604154f71c54cf1329ae384fbef196668Guy Benyei // MDNode for the kernel argument address space qualifiers. 3221db7040604154f71c54cf1329ae384fbef196668Guy Benyei SmallVector<llvm::Value*, 8> addressQuals; 3231db7040604154f71c54cf1329ae384fbef196668Guy Benyei addressQuals.push_back(llvm::MDString::get(Context, "kernel_arg_addr_space")); 3241db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3251db7040604154f71c54cf1329ae384fbef196668Guy Benyei // MDNode for the kernel argument access qualifiers (images only). 3261db7040604154f71c54cf1329ae384fbef196668Guy Benyei SmallVector<llvm::Value*, 8> accessQuals; 3271db7040604154f71c54cf1329ae384fbef196668Guy Benyei accessQuals.push_back(llvm::MDString::get(Context, "kernel_arg_access_qual")); 3281db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3291db7040604154f71c54cf1329ae384fbef196668Guy Benyei // MDNode for the kernel argument type names. 3301db7040604154f71c54cf1329ae384fbef196668Guy Benyei SmallVector<llvm::Value*, 8> argTypeNames; 3311db7040604154f71c54cf1329ae384fbef196668Guy Benyei argTypeNames.push_back(llvm::MDString::get(Context, "kernel_arg_type")); 3321db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3331db7040604154f71c54cf1329ae384fbef196668Guy Benyei // MDNode for the kernel argument type qualifiers. 3341db7040604154f71c54cf1329ae384fbef196668Guy Benyei SmallVector<llvm::Value*, 8> argTypeQuals; 3351db7040604154f71c54cf1329ae384fbef196668Guy Benyei argTypeQuals.push_back(llvm::MDString::get(Context, "kernel_arg_type_qual")); 3361db7040604154f71c54cf1329ae384fbef196668Guy Benyei 337198871cc90375246d8692680467ff6e810edac36Tanya Lattner // MDNode for the kernel argument names. 338198871cc90375246d8692680467ff6e810edac36Tanya Lattner SmallVector<llvm::Value*, 8> argNames; 339198871cc90375246d8692680467ff6e810edac36Tanya Lattner argNames.push_back(llvm::MDString::get(Context, "kernel_arg_name")); 3409dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 341198871cc90375246d8692680467ff6e810edac36Tanya Lattner for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) { 342198871cc90375246d8692680467ff6e810edac36Tanya Lattner const ParmVarDecl *parm = FD->getParamDecl(i); 3431db7040604154f71c54cf1329ae384fbef196668Guy Benyei QualType ty = parm->getType(); 3441db7040604154f71c54cf1329ae384fbef196668Guy Benyei std::string typeQuals; 3451db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3461db7040604154f71c54cf1329ae384fbef196668Guy Benyei if (ty->isPointerType()) { 3471db7040604154f71c54cf1329ae384fbef196668Guy Benyei QualType pointeeTy = ty->getPointeeType(); 3481db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3491db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Get address qualifier. 3501db7040604154f71c54cf1329ae384fbef196668Guy Benyei addressQuals.push_back(Builder.getInt32(ASTCtx.getTargetAddressSpace( 3511db7040604154f71c54cf1329ae384fbef196668Guy Benyei pointeeTy.getAddressSpace()))); 3521db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3531db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Get argument type name. 3541db7040604154f71c54cf1329ae384fbef196668Guy Benyei std::string typeName = pointeeTy.getUnqualifiedType().getAsString() + "*"; 3551db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3561db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Turn "unsigned type" to "utype" 3571db7040604154f71c54cf1329ae384fbef196668Guy Benyei std::string::size_type pos = typeName.find("unsigned"); 358f4492448a201c352be3d2e1e76220cf7cd499c55Benjamin Kramer if (pos != std::string::npos) 359f4492448a201c352be3d2e1e76220cf7cd499c55Benjamin Kramer typeName.erase(pos+1, 8); 3601db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3611db7040604154f71c54cf1329ae384fbef196668Guy Benyei argTypeNames.push_back(llvm::MDString::get(Context, typeName)); 3621db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3631db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Get argument type qualifiers: 3641db7040604154f71c54cf1329ae384fbef196668Guy Benyei if (ty.isRestrictQualified()) 3651db7040604154f71c54cf1329ae384fbef196668Guy Benyei typeQuals = "restrict"; 3661db7040604154f71c54cf1329ae384fbef196668Guy Benyei if (pointeeTy.isConstQualified() || 3671db7040604154f71c54cf1329ae384fbef196668Guy Benyei (pointeeTy.getAddressSpace() == LangAS::opencl_constant)) 368f4492448a201c352be3d2e1e76220cf7cd499c55Benjamin Kramer typeQuals += typeQuals.empty() ? "const" : " const"; 3691db7040604154f71c54cf1329ae384fbef196668Guy Benyei if (pointeeTy.isVolatileQualified()) 370f4492448a201c352be3d2e1e76220cf7cd499c55Benjamin Kramer typeQuals += typeQuals.empty() ? "volatile" : " volatile"; 3711db7040604154f71c54cf1329ae384fbef196668Guy Benyei } else { 3721db7040604154f71c54cf1329ae384fbef196668Guy Benyei addressQuals.push_back(Builder.getInt32(0)); 3731db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3741db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Get argument type name. 3751db7040604154f71c54cf1329ae384fbef196668Guy Benyei std::string typeName = ty.getUnqualifiedType().getAsString(); 3761db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3771db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Turn "unsigned type" to "utype" 3781db7040604154f71c54cf1329ae384fbef196668Guy Benyei std::string::size_type pos = typeName.find("unsigned"); 379f4492448a201c352be3d2e1e76220cf7cd499c55Benjamin Kramer if (pos != std::string::npos) 380f4492448a201c352be3d2e1e76220cf7cd499c55Benjamin Kramer typeName.erase(pos+1, 8); 3811db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3821db7040604154f71c54cf1329ae384fbef196668Guy Benyei argTypeNames.push_back(llvm::MDString::get(Context, typeName)); 3831db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3841db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Get argument type qualifiers: 3851db7040604154f71c54cf1329ae384fbef196668Guy Benyei if (ty.isConstQualified()) 3861db7040604154f71c54cf1329ae384fbef196668Guy Benyei typeQuals = "const"; 3871db7040604154f71c54cf1329ae384fbef196668Guy Benyei if (ty.isVolatileQualified()) 388f4492448a201c352be3d2e1e76220cf7cd499c55Benjamin Kramer typeQuals += typeQuals.empty() ? "volatile" : " volatile"; 3891db7040604154f71c54cf1329ae384fbef196668Guy Benyei } 3901db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3911db7040604154f71c54cf1329ae384fbef196668Guy Benyei argTypeQuals.push_back(llvm::MDString::get(Context, typeQuals)); 3921db7040604154f71c54cf1329ae384fbef196668Guy Benyei 3931db7040604154f71c54cf1329ae384fbef196668Guy Benyei // Get image access qualifier: 3941db7040604154f71c54cf1329ae384fbef196668Guy Benyei if (ty->isImageType()) { 3951db7040604154f71c54cf1329ae384fbef196668Guy Benyei if (parm->hasAttr<OpenCLImageAccessAttr>() && 3961db7040604154f71c54cf1329ae384fbef196668Guy Benyei parm->getAttr<OpenCLImageAccessAttr>()->getAccess() == CLIA_write_only) 3971db7040604154f71c54cf1329ae384fbef196668Guy Benyei accessQuals.push_back(llvm::MDString::get(Context, "write_only")); 3981db7040604154f71c54cf1329ae384fbef196668Guy Benyei else 3991db7040604154f71c54cf1329ae384fbef196668Guy Benyei accessQuals.push_back(llvm::MDString::get(Context, "read_only")); 4001db7040604154f71c54cf1329ae384fbef196668Guy Benyei } else 4011db7040604154f71c54cf1329ae384fbef196668Guy Benyei accessQuals.push_back(llvm::MDString::get(Context, "none")); 4029dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 403198871cc90375246d8692680467ff6e810edac36Tanya Lattner // Get argument name. 404198871cc90375246d8692680467ff6e810edac36Tanya Lattner argNames.push_back(llvm::MDString::get(Context, parm->getName())); 405198871cc90375246d8692680467ff6e810edac36Tanya Lattner } 4061db7040604154f71c54cf1329ae384fbef196668Guy Benyei 4071db7040604154f71c54cf1329ae384fbef196668Guy Benyei kernelMDArgs.push_back(llvm::MDNode::get(Context, addressQuals)); 4081db7040604154f71c54cf1329ae384fbef196668Guy Benyei kernelMDArgs.push_back(llvm::MDNode::get(Context, accessQuals)); 4091db7040604154f71c54cf1329ae384fbef196668Guy Benyei kernelMDArgs.push_back(llvm::MDNode::get(Context, argTypeNames)); 4101db7040604154f71c54cf1329ae384fbef196668Guy Benyei kernelMDArgs.push_back(llvm::MDNode::get(Context, argTypeQuals)); 411198871cc90375246d8692680467ff6e810edac36Tanya Lattner kernelMDArgs.push_back(llvm::MDNode::get(Context, argNames)); 412198871cc90375246d8692680467ff6e810edac36Tanya Lattner} 413198871cc90375246d8692680467ff6e810edac36Tanya Lattner 4149dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilsemanvoid CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD, 4150df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner llvm::Function *Fn) 4160df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner{ 4170df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner if (!FD->hasAttr<OpenCLKernelAttr>()) 4180df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner return; 4190df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner 4200df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner llvm::LLVMContext &Context = getLLVMContext(); 4210df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner 422cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko SmallVector <llvm::Value*, 5> kernelMDArgs; 4230df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner kernelMDArgs.push_back(Fn); 4240df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner 425198871cc90375246d8692680467ff6e810edac36Tanya Lattner if (CGM.getCodeGenOpts().EmitOpenCLArgMetadata) 4261db7040604154f71c54cf1329ae384fbef196668Guy Benyei GenOpenCLArgMetadata(FD, Fn, CGM, Context, kernelMDArgs, 4271db7040604154f71c54cf1329ae384fbef196668Guy Benyei Builder, getContext()); 4289dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 42937453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly if (FD->hasAttr<VecTypeHintAttr>()) { 43037453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly VecTypeHintAttr *attr = FD->getAttr<VecTypeHintAttr>(); 43137453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly QualType hintQTy = attr->getTypeHint(); 43237453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly const ExtVectorType *hintEltQTy = hintQTy->getAs<ExtVectorType>(); 43337453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly bool isSignedInteger = 43437453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly hintQTy->isSignedIntegerType() || 43537453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly (hintEltQTy && hintEltQTy->getElementType()->isSignedIntegerType()); 43637453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly llvm::Value *attrMDArgs[] = { 43737453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly llvm::MDString::get(Context, "vec_type_hint"), 43837453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly llvm::UndefValue::get(CGM.getTypes().ConvertType(attr->getTypeHint())), 43937453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly llvm::ConstantInt::get( 44037453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly llvm::IntegerType::get(Context, 32), 44137453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly llvm::APInt(32, (uint64_t)(isSignedInteger ? 1 : 0))) 44237453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly }; 44337453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs)); 44437453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly } 44537453b9580e293eef3bd60bd36047a93ac4515b1Joey Gouly 4460df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner if (FD->hasAttr<WorkGroupSizeHintAttr>()) { 4470df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner WorkGroupSizeHintAttr *attr = FD->getAttr<WorkGroupSizeHintAttr>(); 4488fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer llvm::Value *attrMDArgs[] = { 4498fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer llvm::MDString::get(Context, "work_group_size_hint"), 4508fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer Builder.getInt32(attr->getXDim()), 4518fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer Builder.getInt32(attr->getYDim()), 4528fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer Builder.getInt32(attr->getZDim()) 4538fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer }; 4540df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs)); 4550df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner } 4560df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner 4570df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner if (FD->hasAttr<ReqdWorkGroupSizeAttr>()) { 4580df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner ReqdWorkGroupSizeAttr *attr = FD->getAttr<ReqdWorkGroupSizeAttr>(); 4598fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer llvm::Value *attrMDArgs[] = { 4608fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer llvm::MDString::get(Context, "reqd_work_group_size"), 4618fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer Builder.getInt32(attr->getXDim()), 4628fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer Builder.getInt32(attr->getYDim()), 4638fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer Builder.getInt32(attr->getZDim()) 4648fd8ee9b718a7d6ebbcc382c1de39ed1260fe2d3Benjamin Kramer }; 4650df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs)); 4660df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner } 4670df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner 4680df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner llvm::MDNode *kernelMDNode = llvm::MDNode::get(Context, kernelMDArgs); 4690df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner llvm::NamedMDNode *OpenCLKernelMetadata = 4700df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner CGM.getModule().getOrInsertNamedMetadata("opencl.kernels"); 4710df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner OpenCLKernelMetadata->addOperand(kernelMDNode); 4720df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner} 4730df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner 474f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58John McCallvoid CodeGenFunction::StartFunction(GlobalDecl GD, 475f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58John McCall QualType RetTy, 4767c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar llvm::Function *Fn, 477d26bc76c98006609002d9930f8840490e88ac5b5John McCall const CGFunctionInfo &FnInfo, 4782284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar const FunctionArgList &Args, 4799c6082fe89c61af697f017aa80937581cc2128d8Tilmann Scheller SourceLocation StartLoc) { 4800ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson const Decl *D = GD.getDecl(); 4819dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 4824cc1a4703363ff940b6273aeef9d96a87edeb04bAnders Carlsson DidCallStackSave = false; 483f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58John McCall CurCodeDecl = D; 484f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58John McCall CurFuncDecl = (D ? D->getNonClosureContext() : 0); 4857c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FnRetTy = RetTy; 486bd012ff1fa088181646a784f385b28867372d434Daniel Dunbar CurFn = Fn; 487d26bc76c98006609002d9930f8840490e88ac5b5John McCall CurFnInfo = &FnInfo; 4885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(CurFn->isDeclaration() && "Function already has body?"); 489ddee4231e9bdfbac1e1f5385ff1a17fd0e0b0e39Chris Lattner 4904f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz if (CGM.getSanitizerBlacklist().isIn(*Fn)) { 4914f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz SanOpts = &SanitizerOptions::Disabled; 4924f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz SanitizePerformTypeCheck = false; 4934f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz } 4944f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz 495a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen // Pass inline keyword to optimizer if it appears explicitly on any 496a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen // declaration. 4979dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman if (!CGM.getCodeGenOpts().NoInline) 4988fbe3855db0c341964bb550e13659505efe06c43Chad Rosier if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) 4998fbe3855db0c341964bb550e13659505efe06c43Chad Rosier for (FunctionDecl::redecl_iterator RI = FD->redecls_begin(), 5008fbe3855db0c341964bb550e13659505efe06c43Chad Rosier RE = FD->redecls_end(); RI != RE; ++RI) 5018fbe3855db0c341964bb550e13659505efe06c43Chad Rosier if (RI->isInlineSpecified()) { 50272390b39c545426023ec104afe8706395d732badBill Wendling Fn->addFnAttr(llvm::Attribute::InlineHint); 5038fbe3855db0c341964bb550e13659505efe06c43Chad Rosier break; 5048fbe3855db0c341964bb550e13659505efe06c43Chad Rosier } 505a3fe2842e0cf953241ccc05809afdf84f13798e9Jakob Stoklund Olesen 5067edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith if (getLangOpts().OpenCL) { 507f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne // Add metadata for a kernel function. 508f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) 5090df579ec000ffe52e0cddf1e7ee5e50a55256835Tanya Lattner EmitOpenCLKernelMetadata(FD, Fn); 510f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne } 511f315fa81eef1977b3457fd7a7d4639e060fe7278Peter Collingbourne 51255e874299f2ad827646a4ca9ea38c402aaeb38c9Daniel Dunbar llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn); 5135ca2084cf9b529563209429857f01fdae9dcdfa5Daniel Dunbar 5145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Create a marker to make it easy to insert allocas into the entryblock 51555352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner // later. Don't create this with the builder, because we don't want it 51655352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner // folded. 51777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Value *Undef = llvm::UndefValue::get(Int32Ty); 51877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "", EntryBB); 519f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner if (Builder.isNamePreserving()) 520f1466848dce9c4c75d96a6cabdc8db560e26aac8Chris Lattner AllocaInsertPt->setName("allocapt"); 5211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 522f1549f66a8216a78112286e3978cea2c29d6334cJohn McCall ReturnBlock = getJumpDestInCurrentScope("return"); 5231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 52455352a2d616cf9fbb621d10faf8b960b4b268bd8Chris Lattner Builder.SetInsertPoint(EntryBB); 5251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 526af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta // Emit subprogram debug descriptor. 527e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson if (CGDebugInfo *DI = getDebugInfo()) { 528bea522ff43a3f11c7a2bc7949119dbb9fce19e39Jordan Rose SmallVector<QualType, 16> ArgTypes; 52906253664315307d34ab57b892b6a0c6c5b3153bbEric Christopher for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); 53006253664315307d34ab57b892b6a0c6c5b3153bbEric Christopher i != e; ++i) { 531bea522ff43a3f11c7a2bc7949119dbb9fce19e39Jordan Rose ArgTypes.push_back((*i)->getType()); 53206253664315307d34ab57b892b6a0c6c5b3153bbEric Christopher } 53306253664315307d34ab57b892b6a0c6c5b3153bbEric Christopher 534e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall QualType FnType = 535bea522ff43a3f11c7a2bc7949119dbb9fce19e39Jordan Rose getContext().getFunctionType(RetTy, ArgTypes, 536e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall FunctionProtoType::ExtProtoInfo()); 537e23cf437fe76b1ed02d63c3f61b456fd48a915f5John McCall 5382284ac9ec80299fcdefae9a2787cf85105a0f203Daniel Dunbar DI->setLocation(StartLoc); 5399c6c3a0e3ae09626d2d4b04e4ffa42c3d7cab32bDevang Patel DI->EmitFunctionStart(GD, FnType, CurFn, Builder); 540af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta } 541af99417156c652a6f04dff643925036dc3241d60Sanjiv Gupta 542a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar if (ShouldInstrumentFunction()) 543a18652fe1e8233fbf8b67484945c7f7b2bf272beDaniel Dunbar EmitFunctionInstrumentation("__cyg_profile_func_enter"); 5447255a2d997b15beae82e627052fdb1b2474495c2Chris Lattner 545be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky if (CGM.getCodeGenOpts().InstrumentForProfiling) 546be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky EmitMCountInstrumentation(); 547be4c8705e499b55548467eb7adaa23cbc6edfef9Roman Divacky 548b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman if (RetTy->isVoidType()) { 549b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman // Void type; nothing to return. 550b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman ReturnValue = 0; 551b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect && 5529d232c884ea9872d6555df0fd7359699819bc1f1John McCall !hasScalarEvaluationKind(CurFnInfo->getReturnType())) { 553b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman // Indirect aggregate return; emit returned value directly into sret slot. 554647a1ec397fa13af176d07d9f5d071560a94c7a9Daniel Dunbar // This reduces code size, and affects correctness in C++. 555b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman ReturnValue = CurFn->arg_begin(); 556b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } else { 557647a1ec397fa13af176d07d9f5d071560a94c7a9Daniel Dunbar ReturnValue = CreateIRTemp(RetTy, "retval"); 558f85e193739c953358c865005855253af4f68a497John McCall 559f85e193739c953358c865005855253af4f68a497John McCall // Tell the epilog emitter to autorelease the result. We do this 560f85e193739c953358c865005855253af4f68a497John McCall // now so that various specialized functions can suppress it 561f85e193739c953358c865005855253af4f68a497John McCall // during their IR-generation. 5624e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (getLangOpts().ObjCAutoRefCount && 563f85e193739c953358c865005855253af4f68a497John McCall !CurFnInfo->isReturnsRetained() && 564f85e193739c953358c865005855253af4f68a497John McCall RetTy->isObjCRetainableType()) 565f85e193739c953358c865005855253af4f68a497John McCall AutoreleaseResult = true; 566b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman } 567b17daf9ab790ae71aacad2cc4aa11cd8d86c25d1Eli Friedman 568cce3d4f9812182ed4e551b7cf0fc86576be8d9c5Mike Stump EmitStartEHSpec(CurCodeDecl); 569f85e193739c953358c865005855253af4f68a497John McCall 570f85e193739c953358c865005855253af4f68a497John McCall PrologueCleanupDepth = EHStack.stable_begin(); 57188b5396b0897f28d22ae3debf4a0d97b33b6c362Daniel Dunbar EmitFunctionProlog(*CurFnInfo, CurFn, Args); 5721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 573cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) { 5744c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().EmitInstanceFunctionProlog(*this); 575cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman const CXXMethodDecl *MD = cast<CXXMethodDecl>(D); 576cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman if (MD->getParent()->isLambda() && 577cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman MD->getOverloadedOperator() == OO_Call) { 578cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman // We're in a lambda; figure out the captures. 579cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman MD->getParent()->getCaptureFields(LambdaCaptureFields, 580cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman LambdaThisCaptureField); 581cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman if (LambdaThisCaptureField) { 582cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman // If this lambda captures this, load it. 583f5ebf9bf1df10ac15ba32a4b24dfe171b7848c58John McCall LValue ThisLValue = EmitLValueForLambdaField(LambdaThisCaptureField); 584cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman CXXThisValue = EmitLoadOfLValue(ThisLValue).getScalarVal(); 585cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman } 586cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman } else { 587cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman // Not in a lambda; just use 'this' from the method. 588cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman // FIXME: Should we generate a new load for each use of 'this'? The 589cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman // fast register allocator would be happier... 590cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman CXXThisValue = CXXABIThisValue; 591cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman } 592cec5ebd4a6a89a7023d04cec728fd340b541ed61Eli Friedman } 5932504941793b549323f9d29c62507cf21d865fadeJohn McCall 594751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson // If any of the arguments have a variably modified type, make sure to 595751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson // emit the type size. 596751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); 597751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson i != e; ++i) { 598f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman const VarDecl *VD = *i; 599f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman 600f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman // Dig out the type as written from ParmVarDecls; it's unclear whether 601f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman // the standard (C99 6.9.1p10) requires this, but we're following the 602f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman // precedent set by gcc. 603f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman QualType Ty; 604f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD)) 605f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman Ty = PVD->getOriginalType(); 606f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman else 607f5bf912767ba19832bba7694fc679a5ec3c055ffEli Friedman Ty = VD->getType(); 608751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson 609751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson if (Ty->isVariablyModifiedType()) 610bc8d40d85f3fa1e34569834916f18fecaa635152John McCall EmitVariablyModifiedType(Ty); 611751358ff73b155f5384e151e1d18aa3f6e7b061cAnders Carlsson } 61273fb35003aad027492e661a3749e921b5d1ecaf9Eric Christopher // Emit a location at the end of the prologue. 61373fb35003aad027492e661a3749e921b5d1ecaf9Eric Christopher if (CGDebugInfo *DI = getDebugInfo()) 61473fb35003aad027492e661a3749e921b5d1ecaf9Eric Christopher DI->EmitLocation(Builder, StartLoc); 6157c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar} 616eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman 6179fc6a7774643a810c8501dae2323e863fefb623eJohn McCallvoid CodeGenFunction::EmitFunctionBody(FunctionArgList &Args) { 6189fc6a7774643a810c8501dae2323e863fefb623eJohn McCall const FunctionDecl *FD = cast<FunctionDecl>(CurGD.getDecl()); 61906a9f3680d22529a2fcf20c52d71cf221d99d910Douglas Gregor assert(FD->getBody()); 620a6504853d297c30cfa271f4710af5a3d5db59449David Blaikie if (const CompoundStmt *S = dyn_cast<CompoundStmt>(FD->getBody())) 621a6504853d297c30cfa271f4710af5a3d5db59449David Blaikie EmitCompoundStmtWithoutScope(*S); 622a6504853d297c30cfa271f4710af5a3d5db59449David Blaikie else 623a6504853d297c30cfa271f4710af5a3d5db59449David Blaikie EmitStmt(FD->getBody()); 624a355e07454463b19829ac92ffd115a097faff0e0John McCall} 625a355e07454463b19829ac92ffd115a097faff0e0John McCall 62639dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// Tries to mark the given function nounwind based on the 62739dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// non-existence of any throwing calls within it. We believe this is 62839dad53772c42eb36ebec1c81c56ba99d038fb94John McCall/// lightweight enough to do at -O0. 62939dad53772c42eb36ebec1c81c56ba99d038fb94John McCallstatic void TryMarkNoThrow(llvm::Function *F) { 630b3a29f132794f67108bccc9c7cc3795365e8a965John McCall // LLVM treats 'nounwind' on a function as part of the type, so we 631b3a29f132794f67108bccc9c7cc3795365e8a965John McCall // can't do this on functions that can be overwritten. 632b3a29f132794f67108bccc9c7cc3795365e8a965John McCall if (F->mayBeOverridden()) return; 633b3a29f132794f67108bccc9c7cc3795365e8a965John McCall 63439dad53772c42eb36ebec1c81c56ba99d038fb94John McCall for (llvm::Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI) 63539dad53772c42eb36ebec1c81c56ba99d038fb94John McCall for (llvm::BasicBlock::iterator 63639dad53772c42eb36ebec1c81c56ba99d038fb94John McCall BI = FI->begin(), BE = FI->end(); BI != BE; ++BI) 637285cfd8953d4ca4da613a47a0d691f7234068f8cBill Wendling if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(&*BI)) { 63839dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (!Call->doesNotThrow()) 63939dad53772c42eb36ebec1c81c56ba99d038fb94John McCall return; 640285cfd8953d4ca4da613a47a0d691f7234068f8cBill Wendling } else if (isa<llvm::ResumeInst>(&*BI)) { 641285cfd8953d4ca4da613a47a0d691f7234068f8cBill Wendling return; 642285cfd8953d4ca4da613a47a0d691f7234068f8cBill Wendling } 643fac631052809b59c1b66f687c08a743de7fb50e9Bill Wendling F->setDoesNotThrow(); 64439dad53772c42eb36ebec1c81c56ba99d038fb94John McCall} 64539dad53772c42eb36ebec1c81c56ba99d038fb94John McCall 646d26bc76c98006609002d9930f8840490e88ac5b5John McCallvoid CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn, 647d26bc76c98006609002d9930f8840490e88ac5b5John McCall const CGFunctionInfo &FnInfo) { 6480ff8bafde95f6fa51ccea70738c1b99db870bddcAnders Carlsson const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 6499dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 650e896d98548b02223c7740d807a0aa6e20fba7079Anders Carlsson // Check if we should generate debug info for this function. 651a240df2ec1b374b3e9e7f760875ffb17cd64506fAlexey Samsonov if (!FD->hasAttr<NoDebugAttr>()) 652a240df2ec1b374b3e9e7f760875ffb17cd64506fAlexey Samsonov maybeInitializeDebugInfo(); 6531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6547c086516f3cc9fba2733b1919973206c6ba4b171Daniel Dunbar FunctionArgList Args; 6554c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall QualType ResTy = FD->getResultType(); 6561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6576a1e0eb557d47e85185e09bdf8721f53f4bf9c9cMike Stump CurGD = GD; 6584c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall if (isa<CXXMethodDecl>(FD) && cast<CXXMethodDecl>(FD)->isInstance()) 6594c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResTy, Args); 6601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6616e94f6c0f124c9a88b3dae0eea5e6b27957df183Chad Rosier for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) 6626e94f6c0f124c9a88b3dae0eea5e6b27957df183Chad Rosier Args.push_back(FD->getParamDecl(i)); 663af05bb9073319d8381b71c4325188853fd4b8ed6Daniel Dunbar 664a355e07454463b19829ac92ffd115a097faff0e0John McCall SourceRange BodyRange; 665a355e07454463b19829ac92ffd115a097faff0e0John McCall if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange(); 6664365bba95be15342575b4f030c6583a770a5da3dAnders Carlsson 66763fd408a61ae9b94e8d8a986832f526f7cdbfa84Manman Ren // CalleeWithThisReturn keeps track of the last callee inside this function 66863fd408a61ae9b94e8d8a986832f526f7cdbfa84Manman Ren // that returns 'this'. Before starting the function, we set it to null. 66963fd408a61ae9b94e8d8a986832f526f7cdbfa84Manman Ren CalleeWithThisReturn = 0; 67063fd408a61ae9b94e8d8a986832f526f7cdbfa84Manman Ren 671a355e07454463b19829ac92ffd115a097faff0e0John McCall // Emit the standard function prologue. 672d26bc76c98006609002d9930f8840490e88ac5b5John McCall StartFunction(GD, ResTy, Fn, FnInfo, Args, BodyRange.getBegin()); 6731851a12605bc6f1ea70d11974a315340ebaab6ebAnders Carlsson 674a355e07454463b19829ac92ffd115a097faff0e0John McCall // Generate the body of the function. 6759fc6a7774643a810c8501dae2323e863fefb623eJohn McCall if (isa<CXXDestructorDecl>(FD)) 6769fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitDestructorBody(Args); 6779fc6a7774643a810c8501dae2323e863fefb623eJohn McCall else if (isa<CXXConstructorDecl>(FD)) 6789fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitConstructorBody(Args); 6797edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith else if (getLangOpts().CUDA && 680a4ae2294b6ebfb2554aacb6a6a0682fb5ed1f276Peter Collingbourne !CGM.getCodeGenOpts().CUDAIsDevice && 681a4ae2294b6ebfb2554aacb6a6a0682fb5ed1f276Peter Collingbourne FD->hasAttr<CUDAGlobalAttr>()) 682a4ae2294b6ebfb2554aacb6a6a0682fb5ed1f276Peter Collingbourne CGM.getCUDARuntime().EmitDeviceStubBody(*this, Args); 683bd89f8c2caa9550e41daa1aa9bf30f0f1e0dfaf7Eli Friedman else if (isa<CXXConversionDecl>(FD) && 68427dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor cast<CXXConversionDecl>(FD)->isLambdaToBlockPointerConversion()) { 68527dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor // The lambda conversion to block pointer is special; the semantics can't be 68627dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor // expressed in the AST, so IRGen needs to special-case it. 68727dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor EmitLambdaToBlockPointerBody(Args); 68827dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor } else if (isa<CXXMethodDecl>(FD) && 68927dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor cast<CXXMethodDecl>(FD)->isLambdaStaticInvoker()) { 69027dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor // The lambda "__invoke" function is special, because it forwards or 69127dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor // clones the body of the function call operator (but is actually static). 69227dd7d962bbf774988bc5e59d04a7743ed503514Douglas Gregor EmitLambdaStaticInvokeFunction(cast<CXXMethodDecl>(FD)); 69356c00c4868831c9a137ca7b0e16d063cf986d110Lang Hames } else if (FD->isDefaulted() && isa<CXXMethodDecl>(FD) && 69456c00c4868831c9a137ca7b0e16d063cf986d110Lang Hames cast<CXXMethodDecl>(FD)->isCopyAssignmentOperator()) { 69556c00c4868831c9a137ca7b0e16d063cf986d110Lang Hames // Implicit copy-assignment gets the same special treatment as implicit 69656c00c4868831c9a137ca7b0e16d063cf986d110Lang Hames // copy-constructors. 69756c00c4868831c9a137ca7b0e16d063cf986d110Lang Hames emitImplicitAssignmentOperatorBody(Args); 698bd89f8c2caa9550e41daa1aa9bf30f0f1e0dfaf7Eli Friedman } 6999fc6a7774643a810c8501dae2323e863fefb623eJohn McCall else 7009fc6a7774643a810c8501dae2323e863fefb623eJohn McCall EmitFunctionBody(Args); 701c33e4ba20304e222692e77f2c6ad26a5d8d32f83Anders Carlsson 70236ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith // C++11 [stmt.return]p2: 70336ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith // Flowing off the end of a function [...] results in undefined behavior in 70436ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith // a value-returning function. 70536ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith // C11 6.9.1p12: 70636ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith // If the '}' that terminates a function is reached, and the value of the 70736ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith // function call is used by the caller, the behavior is undefined. 7087edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith if (getLangOpts().CPlusPlus && !FD->hasImplicitReturnZero() && 70936ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith !FD->getResultType()->isVoidType() && Builder.GetInsertBlock()) { 7104f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz if (SanOpts->Return) 7114def70d3040e73707c738f7c366737a986135edfRichard Smith EmitCheck(Builder.getFalse(), "missing_return", 7124def70d3040e73707c738f7c366737a986135edfRichard Smith EmitCheckSourceLocation(FD->getLocation()), 713cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko ArrayRef<llvm::Value *>(), CRK_Unrecoverable); 714802cd5b1974bab2038b9d3c969d9beb0ab34f435Richard Smith else if (CGM.getCodeGenOpts().OptimizationLevel == 0) 715802cd5b1974bab2038b9d3c969d9beb0ab34f435Richard Smith Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::trap)); 71636ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith Builder.CreateUnreachable(); 71736ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith Builder.ClearInsertionPoint(); 71836ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith } 71936ef0d54cfddf31cd48816e78ab4db73b31a6c1dRichard Smith 720a355e07454463b19829ac92ffd115a097faff0e0John McCall // Emit the standard function epilogue. 721a355e07454463b19829ac92ffd115a097faff0e0John McCall FinishFunction(BodyRange.getEnd()); 72263fd408a61ae9b94e8d8a986832f526f7cdbfa84Manman Ren // CalleeWithThisReturn keeps track of the last callee inside this function 72363fd408a61ae9b94e8d8a986832f526f7cdbfa84Manman Ren // that returns 'this'. After finishing the function, we set it to null. 72463fd408a61ae9b94e8d8a986832f526f7cdbfa84Manman Ren CalleeWithThisReturn = 0; 72539dad53772c42eb36ebec1c81c56ba99d038fb94John McCall 72639dad53772c42eb36ebec1c81c56ba99d038fb94John McCall // If we haven't marked the function nothrow through other means, do 72739dad53772c42eb36ebec1c81c56ba99d038fb94John McCall // a quick pass now to see if we can. 72839dad53772c42eb36ebec1c81c56ba99d038fb94John McCall if (!CurFn->doesNotThrow()) 72939dad53772c42eb36ebec1c81c56ba99d038fb94John McCall TryMarkNoThrow(CurFn); 7305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 7315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 7320946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// ContainsLabel - Return true if the statement contains a label in it. If 7330946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// this statement is not executed normally, it not containing a label means 7340946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner/// that we can just remove the code. 7350946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattnerbool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) { 7360946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // Null statement, not a label! 7370946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (S == 0) return false; 7381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7390946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a label, we have to emit the code, consider something like: 7400946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // if (0) { ... foo: bar(); } goto foo; 741ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // 742ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // TODO: If anyone cared, we could track __label__'s, since we know that you 743ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // can't jump to one from outside their declared region. 7440946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<LabelStmt>(S)) 7450946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 7469dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 7470946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a case/default statement, and we haven't seen a switch, we have 7480946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // to emit the code. 7490946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<SwitchCase>(S) && !IgnoreCaseStmts) 7500946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 7511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7520946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // If this is a switch statement, we want to ignore cases below it. 7530946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (isa<SwitchStmt>(S)) 7540946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner IgnoreCaseStmts = true; 7551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7560946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // Scan subexpressions for verboten labels. 7577502c1d3ce8bb97bcc4f7bebef507040bd93b26fJohn McCall for (Stmt::const_child_range I = S->children(); I; ++I) 7580946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner if (ContainsLabel(*I, IgnoreCaseStmts)) 7590946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return true; 7601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7610946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return false; 7620946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner} 7630946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner 764ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// containsBreak - Return true if the statement contains a break out of it. 765ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// If the statement (recursively) contains a switch or loop with a break 766ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// inside of it, this is fine. 767ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattnerbool CodeGenFunction::containsBreak(const Stmt *S) { 768ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // Null statement, not a label! 769ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner if (S == 0) return false; 770ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 771ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // If this is a switch or loop that defines its own break scope, then we can 772ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // include it and anything inside of it. 773ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || isa<DoStmt>(S) || 774ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner isa<ForStmt>(S)) 7752bef7f5499541e3b68f114cc4d7d197e9a902fe7Chris Lattner return false; 7769dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 7772bef7f5499541e3b68f114cc4d7d197e9a902fe7Chris Lattner if (isa<BreakStmt>(S)) 778ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner return true; 7799dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 780ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner // Scan subexpressions for verboten breaks. 781ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner for (Stmt::const_child_range I = S->children(); I; ++I) 782ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner if (containsBreak(*I)) 783ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner return true; 7849dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 785ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner return false; 786ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner} 787ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 78831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 789c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner/// ConstantFoldsToSimpleInteger - If the specified expression does not fold 790c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner/// to a constant, or if it does but contains a label, return false. If it 791c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner/// constant folds return true and set the boolean result in Result. 792c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattnerbool CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond, 793c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner bool &ResultBool) { 794e1ecdc168175719d74e112bcacd4aae5e12d4631Richard Trieu llvm::APSInt ResultInt; 795ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner if (!ConstantFoldsToSimpleInteger(Cond, ResultInt)) 796ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner return false; 7979dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 798ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner ResultBool = ResultInt.getBoolValue(); 799ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner return true; 800ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner} 801ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 802ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// ConstantFoldsToSimpleInteger - If the specified expression does not fold 803ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// to a constant, or if it does but contains a label, return false. If it 804ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner/// constant folds return true and set the folded value. 805ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattnerbool CodeGenFunction:: 806e1ecdc168175719d74e112bcacd4aae5e12d4631Richard TrieuConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APSInt &ResultInt) { 80736bc14c3a1cf63ee306df5687ac8e85f924f8639Daniel Dunbar // FIXME: Rename and handle conversion of other evaluatable things 80836bc14c3a1cf63ee306df5687ac8e85f924f8639Daniel Dunbar // to bool. 80980d4b55db94db2172a04617d1a80feca6bbcea5cRichard Smith llvm::APSInt Int; 81080d4b55db94db2172a04617d1a80feca6bbcea5cRichard Smith if (!Cond->EvaluateAsInt(Int, getContext())) 811c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner return false; // Not foldable, not integer or not fully evaluatable. 81280d4b55db94db2172a04617d1a80feca6bbcea5cRichard Smith 81331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (CodeGenFunction::ContainsLabel(Cond)) 814c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner return false; // Contains a label. 81580d4b55db94db2172a04617d1a80feca6bbcea5cRichard Smith 81680d4b55db94db2172a04617d1a80feca6bbcea5cRichard Smith ResultInt = Int; 817c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner return true; 81831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner} 81931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 82031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 821ef425a69006afaa87751ee41ccf8ff405d9ede70Chris Lattner 82231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if 82331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// statement) to the specified blocks. Based on the condition, this might try 82431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// to simplify the codegen of the conditional based on the branch. 82531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner/// 82631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattnervoid CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond, 82731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::BasicBlock *TrueBlock, 82831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::BasicBlock *FalseBlock) { 829f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne Cond = Cond->IgnoreParens(); 8301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 83131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) { 83231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Handle X && Y in a condition. 8332de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CondBOp->getOpcode() == BO_LAnd) { 83431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "1 && X", simplify the code. "0 && X" would have constant 83531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // folded if the case was simple enough. 836e3eb83b93751544a5fab19b3824f56aeac454f82Bill Wendling bool ConstantBool = false; 837c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) && 838c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner ConstantBool) { 83931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(1 && X) -> br(X). 84031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 84131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 8421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 84331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "X && 1", simplify the code to use an uncond branch. 84431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // "X && 0" would have been constant folded to 0. 845c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) && 846c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner ConstantBool) { 84731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(X && 1) -> br(X). 84831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 84931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 8501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 85131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the LHS as a conditional. If the LHS conditional is false, we 85231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // want to jump to the FalseBlock. 8539615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true"); 854150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 855150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall ConditionalEvaluation eval(*this); 85631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock); 85731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBlock(LHSTrue); 8581eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 85908e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson // Any temporaries created here are conditional. 860150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(*this); 86131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 862150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(*this); 86308e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson 86431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return; 865c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner } 8669dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 867c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (CondBOp->getOpcode() == BO_LOr) { 86831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "0 || X", simplify the code. "1 || X" would have constant 86931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // folded if the case was simple enough. 870e3eb83b93751544a5fab19b3824f56aeac454f82Bill Wendling bool ConstantBool = false; 871c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) && 872c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner !ConstantBool) { 87331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(0 || X) -> br(X). 87431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 87531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 8761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 87731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If we have "X || 0", simplify the code to use an uncond branch. 87831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // "X || 1" would have been constant folded to 1. 879c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) && 880c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner !ConstantBool) { 88131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // br(X || 0) -> br(X). 88231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 88331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 8841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 88531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the LHS as a conditional. If the LHS conditional is true, we 88631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // want to jump to the TrueBlock. 8879615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false"); 888150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 889150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall ConditionalEvaluation eval(*this); 89031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse); 89131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBlock(LHSFalse); 8921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 89308e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson // Any temporaries created here are conditional. 894150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(*this); 89531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 896150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(*this); 89708e9e453f40aff95a59bd67db49b8f050765e1f0Anders Carlsson 89831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return; 89931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 900552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner } 9011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 902552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) { 903552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner // br(!x, t, f) -> br(x, f, t) 9042de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CondUOp->getOpcode() == UO_LNot) 905552f4c45ba4f4a01f86d585edabd871a27829867Chris Lattner return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock); 90631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner } 9071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 90809b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) { 909df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f)) 910df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true"); 911df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false"); 91209b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar 913df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman ConditionalEvaluation cond(*this); 914df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock); 915150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 916df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman cond.begin(*this); 917df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman EmitBlock(LHSBlock); 918df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock); 919df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman cond.end(*this); 920150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 921df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman cond.begin(*this); 922df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman EmitBlock(RHSBlock); 923df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock); 924df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman cond.end(*this); 925150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 926df33a35f6010fea92c786c0d8f85bfd7c73ebd3eEli Friedman return; 92709b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar } 92809b14899039d828094c06ac25d60de62608e57b7Daniel Dunbar 92931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // Emit the code with the fully general case. 93031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner llvm::Value *CondV = EvaluateExprAsBool(Cond); 93131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner Builder.CreateCondBr(CondV, TrueBlock, FalseBlock); 93231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner} 93331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 934488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar/// ErrorUnsupported - Print out an error that codegen doesn't support the 935dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner/// specified stmt yet. 93690df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbarvoid CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type, 93790df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar bool OmitOnError) { 93890df4b6661968a84bf64baee489bb2f6d948fcc1Daniel Dunbar CGM.ErrorUnsupported(S, Type, OmitOnError); 939dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner} 940dc5e8268292046114ffe02e48773572a91a310f1Chris Lattner 9417143325db76d6c3dabce82500f8cc7c93a941970John McCall/// emitNonZeroVLAInit - Emit the "zero" initialization of a 9427143325db76d6c3dabce82500f8cc7c93a941970John McCall/// variable-length array whose elements have a non-zero bit-pattern. 9437143325db76d6c3dabce82500f8cc7c93a941970John McCall/// 9442ee5ba35febf830d366b65dd0dcbf8e291c41342James Dennett/// \param baseType the inner-most element type of the array 9457143325db76d6c3dabce82500f8cc7c93a941970John McCall/// \param src - a char* pointing to the bit-pattern for a single 9467143325db76d6c3dabce82500f8cc7c93a941970John McCall/// base element of the array 9477143325db76d6c3dabce82500f8cc7c93a941970John McCall/// \param sizeInChars - the total size of the VLA, in chars 9487143325db76d6c3dabce82500f8cc7c93a941970John McCallstatic void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType, 9499dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman llvm::Value *dest, llvm::Value *src, 9507143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *sizeInChars) { 9517143325db76d6c3dabce82500f8cc7c93a941970John McCall std::pair<CharUnits,CharUnits> baseSizeAndAlign 9527143325db76d6c3dabce82500f8cc7c93a941970John McCall = CGF.getContext().getTypeInfoInChars(baseType); 9537143325db76d6c3dabce82500f8cc7c93a941970John McCall 9547143325db76d6c3dabce82500f8cc7c93a941970John McCall CGBuilderTy &Builder = CGF.Builder; 9557143325db76d6c3dabce82500f8cc7c93a941970John McCall 9567143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *baseSizeInChars 9577143325db76d6c3dabce82500f8cc7c93a941970John McCall = llvm::ConstantInt::get(CGF.IntPtrTy, baseSizeAndAlign.first.getQuantity()); 9587143325db76d6c3dabce82500f8cc7c93a941970John McCall 9592acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *i8p = Builder.getInt8PtrTy(); 9607143325db76d6c3dabce82500f8cc7c93a941970John McCall 9617143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *begin = Builder.CreateBitCast(dest, i8p, "vla.begin"); 9627143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *end = Builder.CreateInBoundsGEP(dest, sizeInChars, "vla.end"); 9637143325db76d6c3dabce82500f8cc7c93a941970John McCall 9647143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock(); 9657143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *loopBB = CGF.createBasicBlock("vla-init.loop"); 9667143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::BasicBlock *contBB = CGF.createBasicBlock("vla-init.cont"); 9677143325db76d6c3dabce82500f8cc7c93a941970John McCall 9687143325db76d6c3dabce82500f8cc7c93a941970John McCall // Make a loop over the VLA. C99 guarantees that the VLA element 9697143325db76d6c3dabce82500f8cc7c93a941970John McCall // count must be nonzero. 9707143325db76d6c3dabce82500f8cc7c93a941970John McCall CGF.EmitBlock(loopBB); 9717143325db76d6c3dabce82500f8cc7c93a941970John McCall 972bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *cur = Builder.CreatePHI(i8p, 2, "vla.cur"); 9737143325db76d6c3dabce82500f8cc7c93a941970John McCall cur->addIncoming(begin, originBB); 9747143325db76d6c3dabce82500f8cc7c93a941970John McCall 9757143325db76d6c3dabce82500f8cc7c93a941970John McCall // memcpy the individual element bit-pattern. 9767143325db76d6c3dabce82500f8cc7c93a941970John McCall Builder.CreateMemCpy(cur, src, baseSizeInChars, 9777143325db76d6c3dabce82500f8cc7c93a941970John McCall baseSizeAndAlign.second.getQuantity(), 9787143325db76d6c3dabce82500f8cc7c93a941970John McCall /*volatile*/ false); 9797143325db76d6c3dabce82500f8cc7c93a941970John McCall 9807143325db76d6c3dabce82500f8cc7c93a941970John McCall // Go to the next element. 9817143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *next = Builder.CreateConstInBoundsGEP1_32(cur, 1, "vla.next"); 9827143325db76d6c3dabce82500f8cc7c93a941970John McCall 9837143325db76d6c3dabce82500f8cc7c93a941970John McCall // Leave if that's the end of the VLA. 9847143325db76d6c3dabce82500f8cc7c93a941970John McCall llvm::Value *done = Builder.CreateICmpEQ(next, end, "vla-init.isdone"); 9857143325db76d6c3dabce82500f8cc7c93a941970John McCall Builder.CreateCondBr(done, contBB, loopBB); 9867143325db76d6c3dabce82500f8cc7c93a941970John McCall cur->addIncoming(next, loopBB); 9877143325db76d6c3dabce82500f8cc7c93a941970John McCall 9887143325db76d6c3dabce82500f8cc7c93a941970John McCall CGF.EmitBlock(contBB); 9899dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman} 9907143325db76d6c3dabce82500f8cc7c93a941970John McCall 9911884eb0b5c55edda4893ddec45e7dbad79758782Anders Carlssonvoid 9921884eb0b5c55edda4893ddec45e7dbad79758782Anders CarlssonCodeGenFunction::EmitNullInitialization(llvm::Value *DestPtr, QualType Ty) { 9930d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson // Ignore empty classes in C++. 9947edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith if (getLangOpts().CPlusPlus) { 9950d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (const RecordType *RT = Ty->getAs<RecordType>()) { 9960d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty()) 9970d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson return; 9980d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson } 9990d7c583a4b4d0f57c6b69c66fd73babec4ef3799Anders Carlsson } 10009021718882441dd391a1960084580d3cd19c423aJohn McCall 10019021718882441dd391a1960084580d3cd19c423aJohn McCall // Cast the dest ptr to the appropriate i8 pointer type. 10029021718882441dd391a1960084580d3cd19c423aJohn McCall unsigned DestAS = 10039021718882441dd391a1960084580d3cd19c423aJohn McCall cast<llvm::PointerType>(DestPtr->getType())->getAddressSpace(); 10042acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *BP = Builder.getInt8PtrTy(DestAS); 10053d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson if (DestPtr->getType() != BP) 1006578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer DestPtr = Builder.CreateBitCast(DestPtr, BP); 10073d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 10083d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson // Get size and alignment info for this aggregate. 10099dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman std::pair<CharUnits, CharUnits> TypeInfo = 101079be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck getContext().getTypeInfoInChars(Ty); 101179be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck CharUnits Size = TypeInfo.first; 101279be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck CharUnits Align = TypeInfo.second; 10133d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 10145576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall llvm::Value *SizeVal; 10157143325db76d6c3dabce82500f8cc7c93a941970John McCall const VariableArrayType *vla; 10169021718882441dd391a1960084580d3cd19c423aJohn McCall 10175576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall // Don't bother emitting a zero-byte memset. 101879be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck if (Size.isZero()) { 10195576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall // But note that getTypeInfo returns 0 for a VLA. 10205576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall if (const VariableArrayType *vlaType = 10215576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall dyn_cast_or_null<VariableArrayType>( 10225576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall getContext().getAsArrayType(Ty))) { 1023bc8d40d85f3fa1e34569834916f18fecaa635152John McCall QualType eltType; 1024bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::Value *numElts; 1025bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::tie(numElts, eltType) = getVLASize(vlaType); 1026bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1027bc8d40d85f3fa1e34569834916f18fecaa635152John McCall SizeVal = numElts; 1028bc8d40d85f3fa1e34569834916f18fecaa635152John McCall CharUnits eltSize = getContext().getTypeSizeInChars(eltType); 1029bc8d40d85f3fa1e34569834916f18fecaa635152John McCall if (!eltSize.isOne()) 1030bc8d40d85f3fa1e34569834916f18fecaa635152John McCall SizeVal = Builder.CreateNUWMul(SizeVal, CGM.getSize(eltSize)); 10317143325db76d6c3dabce82500f8cc7c93a941970John McCall vla = vlaType; 10325576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } else { 10335576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall return; 10345576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } 10355576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } else { 1036bc8d40d85f3fa1e34569834916f18fecaa635152John McCall SizeVal = CGM.getSize(Size); 10377143325db76d6c3dabce82500f8cc7c93a941970John McCall vla = 0; 10385576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall } 10399021718882441dd391a1960084580d3cd19c423aJohn McCall 10409021718882441dd391a1960084580d3cd19c423aJohn McCall // If the type contains a pointer to data member we can't memset it to zero. 10419021718882441dd391a1960084580d3cd19c423aJohn McCall // Instead, create a null constant and copy it to the destination. 10427143325db76d6c3dabce82500f8cc7c93a941970John McCall // TODO: there are other patterns besides zero that we can usefully memset, 10437143325db76d6c3dabce82500f8cc7c93a941970John McCall // like -1, which happens to be the pattern used by member-pointers. 1044f16aa103d3afd42fbca2ab346f191bf745cec092John McCall if (!CGM.getTypes().isZeroInitializable(Ty)) { 10457143325db76d6c3dabce82500f8cc7c93a941970John McCall // For a VLA, emit a single element, then splat that over the VLA. 10467143325db76d6c3dabce82500f8cc7c93a941970John McCall if (vla) Ty = getContext().getBaseElementType(vla); 10475576d9b0a389f6f1f89bdcd37194f4e992b1fbcbJohn McCall 10489021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty); 10499021718882441dd391a1960084580d3cd19c423aJohn McCall 10509dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman llvm::GlobalVariable *NullVariable = 10519021718882441dd391a1960084580d3cd19c423aJohn McCall new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(), 10529dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman /*isConstant=*/true, 10539021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::GlobalVariable::PrivateLinkage, 10545f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner NullConstant, Twine()); 10559021718882441dd391a1960084580d3cd19c423aJohn McCall llvm::Value *SrcPtr = 10569021718882441dd391a1960084580d3cd19c423aJohn McCall Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()); 10579021718882441dd391a1960084580d3cd19c423aJohn McCall 10587143325db76d6c3dabce82500f8cc7c93a941970John McCall if (vla) return emitNonZeroVLAInit(*this, Ty, DestPtr, SrcPtr, SizeVal); 10597143325db76d6c3dabce82500f8cc7c93a941970John McCall 10609021718882441dd391a1960084580d3cd19c423aJohn McCall // Get and call the appropriate llvm.memcpy overload. 106179be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, Align.getQuantity(), false); 106288207c9ca218486b93ae7df14e9764cd0c2c3383Chris Lattner return; 10639dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman } 10649dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 10659021718882441dd391a1960084580d3cd19c423aJohn McCall // Otherwise, just memset the whole thing to zero. This is legal 10669021718882441dd391a1960084580d3cd19c423aJohn McCall // because in LLVM, all default initializers (other than the ones we just 10679021718882441dd391a1960084580d3cd19c423aJohn McCall // handled above) are guaranteed to have a bit pattern of all zeros. 10689dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal, 106979be76c0e360d9e9c44285c9838af02adc43e55fKen Dyck Align.getQuantity(), false); 10703d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson} 10713d8400d9a61aa4b63ff35e5cede405b32a41425eAnders Carlsson 1072ad8dcf4a9df0e24051dc31bf9e6f3cd138a34298Chris Lattnerllvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelDecl *L) { 1073d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Make sure that there is a block for the indirect goto. 1074d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch == 0) 1075d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner GetIndirectGotoBlock(); 10769dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 1077ff8e11579fc904aa4032d90d2be6ce1ac5fc9fe1John McCall llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock(); 10789dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 1079d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Make sure the indirect branch includes all of the address-taken blocks. 1080d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner IndirectBranch->addDestination(BB); 1081d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return llvm::BlockAddress::get(CurFn, BB); 10823d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner} 10831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10843d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattnerllvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() { 1085d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // If we already made the indirect branch for indirect goto, return its block. 1086d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner if (IndirectBranch) return IndirectBranch->getParent(); 10879dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 1088d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner CGBuilderTy TmpBuilder(createBasicBlock("indirectgoto")); 10899dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 10903d00fdc82fd550ae4bfbb2e700a1fc85bbd6d6fdChris Lattner // Create the PHI node that indirect gotos will add entries to. 1091bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, 0, 1092bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad "indirect.goto.dest"); 10939dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilseman 1094d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner // Create the indirect branch instruction. 1095d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal); 1096d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return IndirectBranch->getParent(); 10970ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar} 1098ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 1099bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall/// Computes the length of an array in elements, as well as the base 1100bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall/// element type and a properly-typed first element pointer. 1101bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCallllvm::Value *CodeGenFunction::emitArrayLength(const ArrayType *origArrayType, 1102bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall QualType &baseType, 1103bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall llvm::Value *&addr) { 1104bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall const ArrayType *arrayType = origArrayType; 1105bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1106bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // If it's a VLA, we have to load the stored size. Note that 1107bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // this is the size of the VLA in bytes, not its size in elements. 1108bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall llvm::Value *numVLAElements = 0; 1109bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall if (isa<VariableArrayType>(arrayType)) { 1110bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall numVLAElements = getVLASize(cast<VariableArrayType>(arrayType)).first; 1111bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1112bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // Walk into all VLAs. This doesn't require changes to addr, 1113bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // which has type T* where T is the first non-VLA element type. 1114bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall do { 1115bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall QualType elementType = arrayType->getElementType(); 1116bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall arrayType = getContext().getAsArrayType(elementType); 1117bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1118bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // If we only have VLA components, 'addr' requires no adjustment. 1119bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall if (!arrayType) { 1120bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall baseType = elementType; 1121bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall return numVLAElements; 1122bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall } 1123bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall } while (isa<VariableArrayType>(arrayType)); 1124bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1125bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // We get out here only if we find a constant array type 1126bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // inside the VLA. 1127bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall } 1128bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1129bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // We have some number of constant-length arrays, so addr should 1130bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // have LLVM type [M x [N x [...]]]*. Build a GEP that walks 1131bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // down to the first element of addr. 11325f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<llvm::Value*, 8> gepIndices; 1133bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1134bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // GEP down to the array type. 1135bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall llvm::ConstantInt *zero = Builder.getInt32(0); 1136bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall gepIndices.push_back(zero); 1137bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1138bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall uint64_t countFromCLAs = 1; 11391664d540d1524f0faffd2f839fccb56178975c60Richard Smith QualType eltType; 1140bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 11412acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::ArrayType *llvmArrayType = 11421664d540d1524f0faffd2f839fccb56178975c60Richard Smith dyn_cast<llvm::ArrayType>( 1143bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall cast<llvm::PointerType>(addr->getType())->getElementType()); 11441664d540d1524f0faffd2f839fccb56178975c60Richard Smith while (llvmArrayType) { 1145bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall assert(isa<ConstantArrayType>(arrayType)); 1146bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall assert(cast<ConstantArrayType>(arrayType)->getSize().getZExtValue() 1147bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall == llvmArrayType->getNumElements()); 1148bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1149bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall gepIndices.push_back(zero); 1150bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall countFromCLAs *= llvmArrayType->getNumElements(); 11511664d540d1524f0faffd2f839fccb56178975c60Richard Smith eltType = arrayType->getElementType(); 1152bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1153bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall llvmArrayType = 1154bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall dyn_cast<llvm::ArrayType>(llvmArrayType->getElementType()); 1155bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall arrayType = getContext().getAsArrayType(arrayType->getElementType()); 11561664d540d1524f0faffd2f839fccb56178975c60Richard Smith assert((!llvmArrayType || arrayType) && 11571664d540d1524f0faffd2f839fccb56178975c60Richard Smith "LLVM and Clang types are out-of-synch"); 1158bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall } 1159bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 11601664d540d1524f0faffd2f839fccb56178975c60Richard Smith if (arrayType) { 11611664d540d1524f0faffd2f839fccb56178975c60Richard Smith // From this point onwards, the Clang array type has been emitted 11621664d540d1524f0faffd2f839fccb56178975c60Richard Smith // as some other type (probably a packed struct). Compute the array 11631664d540d1524f0faffd2f839fccb56178975c60Richard Smith // size, and just emit the 'begin' expression as a bitcast. 11641664d540d1524f0faffd2f839fccb56178975c60Richard Smith while (arrayType) { 11651664d540d1524f0faffd2f839fccb56178975c60Richard Smith countFromCLAs *= 11661664d540d1524f0faffd2f839fccb56178975c60Richard Smith cast<ConstantArrayType>(arrayType)->getSize().getZExtValue(); 11671664d540d1524f0faffd2f839fccb56178975c60Richard Smith eltType = arrayType->getElementType(); 11681664d540d1524f0faffd2f839fccb56178975c60Richard Smith arrayType = getContext().getAsArrayType(eltType); 11691664d540d1524f0faffd2f839fccb56178975c60Richard Smith } 11701664d540d1524f0faffd2f839fccb56178975c60Richard Smith 1171956a5a17713deb1b5b27893303c4f308a1bd2a62Micah Villmow unsigned AddressSpace = addr->getType()->getPointerAddressSpace(); 11721664d540d1524f0faffd2f839fccb56178975c60Richard Smith llvm::Type *BaseType = ConvertType(eltType)->getPointerTo(AddressSpace); 11731664d540d1524f0faffd2f839fccb56178975c60Richard Smith addr = Builder.CreateBitCast(addr, BaseType, "array.begin"); 11741664d540d1524f0faffd2f839fccb56178975c60Richard Smith } else { 11751664d540d1524f0faffd2f839fccb56178975c60Richard Smith // Create the actual GEP. 11761664d540d1524f0faffd2f839fccb56178975c60Richard Smith addr = Builder.CreateInBoundsGEP(addr, gepIndices, "array.begin"); 11771664d540d1524f0faffd2f839fccb56178975c60Richard Smith } 1178bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 11791664d540d1524f0faffd2f839fccb56178975c60Richard Smith baseType = eltType; 1180bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1181bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall llvm::Value *numElements 1182bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall = llvm::ConstantInt::get(SizeTy, countFromCLAs); 1183bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1184bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall // If we had any VLA dimensions, factor them in. 1185bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall if (numVLAElements) 1186bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall numElements = Builder.CreateNUWMul(numVLAElements, numElements); 1187bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1188bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall return numElements; 1189bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall} 1190bdc4d80956c83a486e58d3df6bb524a1f66ff574John McCall 1191bc8d40d85f3fa1e34569834916f18fecaa635152John McCallstd::pair<llvm::Value*, QualType> 1192bc8d40d85f3fa1e34569834916f18fecaa635152John McCallCodeGenFunction::getVLASize(QualType type) { 1193bc8d40d85f3fa1e34569834916f18fecaa635152John McCall const VariableArrayType *vla = getContext().getAsVariableArrayType(type); 1194bc8d40d85f3fa1e34569834916f18fecaa635152John McCall assert(vla && "type was not a variable array type!"); 1195bc8d40d85f3fa1e34569834916f18fecaa635152John McCall return getVLASize(vla); 1196f666b7780d04186521adcaedb0e15dfa4d5e6933Anders Carlsson} 1197dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson 1198bc8d40d85f3fa1e34569834916f18fecaa635152John McCallstd::pair<llvm::Value*, QualType> 1199bc8d40d85f3fa1e34569834916f18fecaa635152John McCallCodeGenFunction::getVLASize(const VariableArrayType *type) { 1200bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // The number of elements so far; always size_t. 1201bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::Value *numElements = 0; 12021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1203bc8d40d85f3fa1e34569834916f18fecaa635152John McCall QualType elementType; 1204bc8d40d85f3fa1e34569834916f18fecaa635152John McCall do { 1205bc8d40d85f3fa1e34569834916f18fecaa635152John McCall elementType = type->getElementType(); 1206bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::Value *vlaSize = VLASizeMap[type->getSizeExpr()]; 1207bc8d40d85f3fa1e34569834916f18fecaa635152John McCall assert(vlaSize && "no size for VLA!"); 1208bc8d40d85f3fa1e34569834916f18fecaa635152John McCall assert(vlaSize->getType() == SizeTy); 12091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1210bc8d40d85f3fa1e34569834916f18fecaa635152John McCall if (!numElements) { 1211bc8d40d85f3fa1e34569834916f18fecaa635152John McCall numElements = vlaSize; 1212bc8d40d85f3fa1e34569834916f18fecaa635152John McCall } else { 1213bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // It's undefined behavior if this wraps around, so mark it that way. 1214930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith // FIXME: Teach -fcatch-undefined-behavior to trap this. 1215bc8d40d85f3fa1e34569834916f18fecaa635152John McCall numElements = Builder.CreateNUWMul(numElements, vlaSize); 1216bc8d40d85f3fa1e34569834916f18fecaa635152John McCall } 1217bc8d40d85f3fa1e34569834916f18fecaa635152John McCall } while ((type = getContext().getAsVariableArrayType(elementType))); 12181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1219bc8d40d85f3fa1e34569834916f18fecaa635152John McCall return std::pair<llvm::Value*,QualType>(numElements, elementType); 1220bc8d40d85f3fa1e34569834916f18fecaa635152John McCall} 12211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1222bc8d40d85f3fa1e34569834916f18fecaa635152John McCallvoid CodeGenFunction::EmitVariablyModifiedType(QualType type) { 1223bc8d40d85f3fa1e34569834916f18fecaa635152John McCall assert(type->isVariablyModifiedType() && 1224bc8d40d85f3fa1e34569834916f18fecaa635152John McCall "Must pass variably modified type to EmitVLASizes!"); 12251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1226bc8d40d85f3fa1e34569834916f18fecaa635152John McCall EnsureInsertPoint(); 12271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1228bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // We're going to walk down into the type and look for VLA 1229bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // expressions. 1230bc8d40d85f3fa1e34569834916f18fecaa635152John McCall do { 1231bc8d40d85f3fa1e34569834916f18fecaa635152John McCall assert(type->isVariablyModifiedType()); 1232bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1233bc8d40d85f3fa1e34569834916f18fecaa635152John McCall const Type *ty = type.getTypePtr(); 1234bc8d40d85f3fa1e34569834916f18fecaa635152John McCall switch (ty->getTypeClass()) { 123506284c1dc56caed19850bc3766c89f51763724c3Abramo Bagnara 1236bc8d40d85f3fa1e34569834916f18fecaa635152John McCall#define TYPE(Class, Base) 1237bc8d40d85f3fa1e34569834916f18fecaa635152John McCall#define ABSTRACT_TYPE(Class, Base) 123806284c1dc56caed19850bc3766c89f51763724c3Abramo Bagnara#define NON_CANONICAL_TYPE(Class, Base) 1239bc8d40d85f3fa1e34569834916f18fecaa635152John McCall#define DEPENDENT_TYPE(Class, Base) case Type::Class: 124006284c1dc56caed19850bc3766c89f51763724c3Abramo Bagnara#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) 1241bc8d40d85f3fa1e34569834916f18fecaa635152John McCall#include "clang/AST/TypeNodes.def" 124206284c1dc56caed19850bc3766c89f51763724c3Abramo Bagnara llvm_unreachable("unexpected dependent type!"); 1243bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1244bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // These types are never variably-modified. 1245bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::Builtin: 1246bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::Complex: 1247bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::Vector: 1248bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::ExtVector: 1249bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::Record: 1250bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::Enum: 12515ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::Elaborated: 12525ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::TemplateSpecialization: 1253bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::ObjCObject: 1254bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::ObjCInterface: 1255bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::ObjCObjectPointer: 1256bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm_unreachable("type class is never variably-modified!"); 1257bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1258bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::Pointer: 1259bc8d40d85f3fa1e34569834916f18fecaa635152John McCall type = cast<PointerType>(ty)->getPointeeType(); 1260bc8d40d85f3fa1e34569834916f18fecaa635152John McCall break; 1261bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1262bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::BlockPointer: 1263bc8d40d85f3fa1e34569834916f18fecaa635152John McCall type = cast<BlockPointerType>(ty)->getPointeeType(); 1264bc8d40d85f3fa1e34569834916f18fecaa635152John McCall break; 1265bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1266bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::LValueReference: 1267bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::RValueReference: 1268bc8d40d85f3fa1e34569834916f18fecaa635152John McCall type = cast<ReferenceType>(ty)->getPointeeType(); 1269bc8d40d85f3fa1e34569834916f18fecaa635152John McCall break; 1270bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1271bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::MemberPointer: 1272bc8d40d85f3fa1e34569834916f18fecaa635152John McCall type = cast<MemberPointerType>(ty)->getPointeeType(); 1273bc8d40d85f3fa1e34569834916f18fecaa635152John McCall break; 1274bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1275bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::ConstantArray: 1276bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::IncompleteArray: 1277bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // Losing element qualification here is fine. 1278bc8d40d85f3fa1e34569834916f18fecaa635152John McCall type = cast<ArrayType>(ty)->getElementType(); 1279bc8d40d85f3fa1e34569834916f18fecaa635152John McCall break; 1280bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1281bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::VariableArray: { 1282bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // Losing element qualification here is fine. 1283bc8d40d85f3fa1e34569834916f18fecaa635152John McCall const VariableArrayType *vat = cast<VariableArrayType>(ty); 1284bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1285bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // Unknown size indication requires no size computation. 1286bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // Otherwise, evaluate and record it. 1287bc8d40d85f3fa1e34569834916f18fecaa635152John McCall if (const Expr *size = vat->getSizeExpr()) { 1288bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // It's possible that we might have emitted this already, 1289bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // e.g. with a typedef and a pointer to it. 1290bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::Value *&entry = VLASizeMap[size]; 1291bc8d40d85f3fa1e34569834916f18fecaa635152John McCall if (!entry) { 1292930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith llvm::Value *Size = EmitScalarExpr(size); 1293930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith 1294930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith // C11 6.7.6.2p5: 1295930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith // If the size is an expression that is not an integer constant 1296930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith // expression [...] each time it is evaluated it shall have a value 1297930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith // greater than zero. 12984f45bc099f2665bc6e4bcbb169aa452390dbf3feWill Dietz if (SanOpts->VLABound && 1299d6396a681c9acbe56bc41bbc2bed2db45755bcd7Richard Smith size->getType()->isSignedIntegerType()) { 1300930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith llvm::Value *Zero = llvm::Constant::getNullValue(Size->getType()); 1301930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith llvm::Constant *StaticArgs[] = { 1302930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith EmitCheckSourceLocation(size->getLocStart()), 1303930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith EmitCheckTypeDescriptor(size->getType()) 1304930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith }; 1305930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith EmitCheck(Builder.CreateICmpSGT(Size, Zero), 1306ad95481b2769ad61f23afc5e2c31f11c66090657Will Dietz "vla_bound_not_positive", StaticArgs, Size, 1307ad95481b2769ad61f23afc5e2c31f11c66090657Will Dietz CRK_Recoverable); 1308930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith } 1309930c05c32eac171ef1a94fabf80aecb4e6e2c840Richard Smith 1310bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // Always zexting here would be wrong if it weren't 1311bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // undefined behavior to have a negative bound. 1312bf43f2fdfbd7c4f8cd1f1403765eca9e5dc6c8aeRichard Smith entry = Builder.CreateIntCast(Size, SizeTy, /*signed*/ false); 1313bc8d40d85f3fa1e34569834916f18fecaa635152John McCall } 1314bc8d40d85f3fa1e34569834916f18fecaa635152John McCall } 1315bc8d40d85f3fa1e34569834916f18fecaa635152John McCall type = vat->getElementType(); 1316bc8d40d85f3fa1e34569834916f18fecaa635152John McCall break; 1317fcdbb93749ed69aa9022437052c390522355ec3dAnders Carlsson } 13181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 131906284c1dc56caed19850bc3766c89f51763724c3Abramo Bagnara case Type::FunctionProto: 1320bc8d40d85f3fa1e34569834916f18fecaa635152John McCall case Type::FunctionNoProto: 1321bc8d40d85f3fa1e34569834916f18fecaa635152John McCall type = cast<FunctionType>(ty)->getResultType(); 1322bc8d40d85f3fa1e34569834916f18fecaa635152John McCall break; 1323b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman 13245ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::Paren: 13255ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::TypeOf: 13265ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::UnaryTransform: 13275ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::Attributed: 13285ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::SubstTemplateTypeParm: 13295ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara // Keep walking after single level desugaring. 13305ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara type = type.getSingleStepDesugaredType(getContext()); 13315ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara break; 13325ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara 13335ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::Typedef: 13345ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::Decltype: 13355ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::Auto: 13365ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara // Stop walking: nothing to do. 13375ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara return; 13385ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara 13395ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara case Type::TypeOfExpr: 13405ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara // Stop walking: emit typeof expression. 13415ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara EmitIgnoredExpr(cast<TypeOfExprType>(ty)->getUnderlyingExpr()); 13425ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara return; 13435ff53b27dfd918a5d9943cd008de51edc8cbec2cAbramo Bagnara 1344b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman case Type::Atomic: 1345b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman type = cast<AtomicType>(ty)->getValueType(); 1346b001de7458d17c17e6d8b8034c7cfcefd3b70c00Eli Friedman break; 1347bc8d40d85f3fa1e34569834916f18fecaa635152John McCall } 1348bc8d40d85f3fa1e34569834916f18fecaa635152John McCall } while (type->isVariablyModifiedType()); 1349dcc90d87e6430c643b4311ae5b0089535bca41f7Anders Carlsson} 13504fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman 13514fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedmanllvm::Value* CodeGenFunction::EmitVAListRef(const Expr* E) { 1352bc07a55b68342a230aafd8875cc7a26450dd3f64Dan Gohman if (getContext().getBuiltinVaListType()->isArrayType()) 13534fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman return EmitScalarExpr(E); 13544fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman return EmitLValue(E).getAddress(); 13554fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman} 13566ccc47698d0311ddabf32fa0f6db8e4f09ac96f8Anders Carlsson 13579dce4b3d9d14ba2be2aad5bd7fd8d381a0263c36Michael Ilsemanvoid CodeGenFunction::EmitDeclRefExprDbgValue(const DeclRefExpr *E, 1358189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall llvm::Constant *Init) { 135925c2c8fb9309050612009a6571e2660e75531348Devang Patel assert (Init && "Invalid DeclRefExpr initializer!"); 136025c2c8fb9309050612009a6571e2660e75531348Devang Patel if (CGDebugInfo *Dbg = getDebugInfo()) 13614cdad3151bfb2075c6bdbfe89fbb08f31a90a45bDouglas Gregor if (CGM.getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) 1362fd00eecad6fa5400cf37269d84361a0551d0e6d3Alexey Samsonov Dbg->EmitGlobalVariable(E->getDecl(), Init); 13638d308384a220c7dc81755c47cdcbdd87dac25d5bDevang Patel} 136456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 136556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCallCodeGenFunction::PeepholeProtection 136656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCallCodeGenFunction::protectFromPeepholes(RValue rvalue) { 136756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // At the moment, the only aggressive peephole we do in IR gen 136856ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // is trunc(zext) folding, but if we add more, we can easily 136956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // extend this protection. 137056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 137156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (!rvalue.isScalar()) return PeepholeProtection(); 137256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *value = rvalue.getScalarVal(); 137356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (!isa<llvm::ZExtInst>(value)) return PeepholeProtection(); 137456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 137556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // Just make an extra bitcast. 137656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall assert(HaveInsertPoint()); 137756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Instruction *inst = new llvm::BitCastInst(value, value->getType(), "", 137856ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Builder.GetInsertBlock()); 137956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 138056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall PeepholeProtection protection; 138156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall protection.Inst = inst; 138256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall return protection; 138356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall} 138456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 138556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCallvoid CodeGenFunction::unprotectFromPeepholes(PeepholeProtection protection) { 138656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (!protection.Inst) return; 138756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 138856ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // In theory, we could try to duplicate the peepholes now, but whatever. 138956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall protection.Inst->eraseFromParent(); 139056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall} 139177f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge 139277f68bb90af93b95045fb994e7cd68137adcc132Julien Lerougellvm::Value *CodeGenFunction::EmitAnnotationCall(llvm::Value *AnnotationFn, 139377f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge llvm::Value *AnnotatedVal, 1394cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko StringRef AnnotationStr, 139577f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge SourceLocation Location) { 139677f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge llvm::Value *Args[4] = { 139777f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge AnnotatedVal, 139877f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge Builder.CreateBitCast(CGM.EmitAnnotationString(AnnotationStr), Int8PtrTy), 139977f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge Builder.CreateBitCast(CGM.EmitAnnotationUnit(Location), Int8PtrTy), 140077f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge CGM.EmitAnnotationLineNo(Location) 140177f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge }; 140277f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge return Builder.CreateCall(AnnotationFn, Args); 140377f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge} 140477f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge 140577f68bb90af93b95045fb994e7cd68137adcc132Julien Lerougevoid CodeGenFunction::EmitVarAnnotations(const VarDecl *D, llvm::Value *V) { 140677f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute"); 140777f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge // FIXME We create a new bitcast for every annotation because that's what 140877f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge // llvm-gcc was doing. 140977f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge for (specific_attr_iterator<AnnotateAttr> 141077f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge ai = D->specific_attr_begin<AnnotateAttr>(), 141177f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai) 141277f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge EmitAnnotationCall(CGM.getIntrinsic(llvm::Intrinsic::var_annotation), 141377f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge Builder.CreateBitCast(V, CGM.Int8PtrTy, V->getName()), 141477f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge (*ai)->getAnnotation(), D->getLocation()); 141577f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge} 141677f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge 141777f68bb90af93b95045fb994e7cd68137adcc132Julien Lerougellvm::Value *CodeGenFunction::EmitFieldAnnotations(const FieldDecl *D, 141877f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge llvm::Value *V) { 141977f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute"); 142077f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge llvm::Type *VTy = V->getType(); 142177f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::ptr_annotation, 142277f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge CGM.Int8PtrTy); 142377f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge 142477f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge for (specific_attr_iterator<AnnotateAttr> 142577f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge ai = D->specific_attr_begin<AnnotateAttr>(), 142677f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai) { 142777f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge // FIXME Always emit the cast inst so we can differentiate between 142877f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge // annotation on the first field of a struct and annotation on the struct 142977f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge // itself. 143077f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge if (VTy != CGM.Int8PtrTy) 143177f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge V = Builder.Insert(new llvm::BitCastInst(V, CGM.Int8PtrTy)); 143277f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge V = EmitAnnotationCall(F, V, (*ai)->getAnnotation(), D->getLocation()); 143377f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge V = Builder.CreateBitCast(V, VTy); 143477f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge } 143577f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge 143677f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge return V; 143777f68bb90af93b95045fb994e7cd68137adcc132Julien Lerouge} 1438