CodeGenFunction.cpp revision 263508
1107120Sjulian//===--- CodeGenFunction.cpp - Emit LLVM Code from ASTs for a Function ----===// 2107120Sjulian// 3139823Simp// The LLVM Compiler Infrastructure 4139823Simp// 5139823Simp// This file is distributed under the University of Illinois Open Source 6107120Sjulian// License. See LICENSE.TXT for details. 7107120Sjulian// 8107120Sjulian//===----------------------------------------------------------------------===// 9107120Sjulian// 10107120Sjulian// This coordinates the per-function state used while generating code. 11107120Sjulian// 12107120Sjulian//===----------------------------------------------------------------------===// 13107120Sjulian 14107120Sjulian#include "CodeGenFunction.h" 15107120Sjulian#include "CGCUDARuntime.h" 16107120Sjulian#include "CGCXXABI.h" 17107120Sjulian#include "CGDebugInfo.h" 18107120Sjulian#include "CodeGenModule.h" 19107120Sjulian#include "TargetInfo.h" 20107120Sjulian#include "clang/AST/ASTContext.h" 21107120Sjulian#include "clang/AST/Decl.h" 22107120Sjulian#include "clang/AST/DeclCXX.h" 23107120Sjulian#include "clang/AST/StmtCXX.h" 24107120Sjulian#include "clang/Basic/OpenCL.h" 25107120Sjulian#include "clang/Basic/TargetInfo.h" 26107120Sjulian#include "clang/CodeGen/CGFunctionInfo.h" 27107120Sjulian#include "clang/Frontend/CodeGenOptions.h" 28107120Sjulian#include "llvm/IR/DataLayout.h" 29107120Sjulian#include "llvm/IR/Intrinsics.h" 30114878Sjulian#include "llvm/IR/MDBuilder.h" 31107120Sjulian#include "llvm/IR/Operator.h" 32107120Sjulianusing namespace clang; 33107120Sjulianusing namespace CodeGen; 34107120Sjulian 35107120SjulianCodeGenFunction::CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext) 36107120Sjulian : CodeGenTypeCache(cgm), CGM(cgm), Target(cgm.getTarget()), 37107120Sjulian Builder(cgm.getModule().getContext()), CapturedStmtInfo(0), 38107120Sjulian SanitizePerformTypeCheck(CGM.getSanOpts().Null | 39107120Sjulian CGM.getSanOpts().Alignment | 40107120Sjulian CGM.getSanOpts().ObjectSize | 41122634Semax CGM.getSanOpts().Vptr), 42107120Sjulian SanOpts(&CGM.getSanOpts()), AutoreleaseResult(false), BlockInfo(0), 43107120Sjulian BlockPointer(0), LambdaThisCaptureField(0), NormalCleanupDest(0), 44107120Sjulian NextCleanupDestIndex(1), FirstBlockInfo(0), EHResumeBlock(0), 45107120Sjulian ExceptionSlot(0), EHSelectorSlot(0), DebugInfo(CGM.getModuleDebugInfo()), 46107120Sjulian DisableDebugInfo(false), DidCallStackSave(false), IndirectBranch(0), 47107120Sjulian SwitchInsn(0), CaseRangeBlock(0), UnreachableBlock(0), NumReturnExprs(0), 48107120Sjulian NumSimpleReturnExprs(0), CXXABIThisDecl(0), CXXABIThisValue(0), 49107120Sjulian CXXThisValue(0), CXXDefaultInitExprThis(0), 50107120Sjulian CXXStructorImplicitParamDecl(0), CXXStructorImplicitParamValue(0), 51107120Sjulian OutermostConditional(0), CurLexicalScope(0), TerminateLandingPad(0), 52107120Sjulian TerminateHandler(0), TrapBB(0) { 53107120Sjulian if (!suppressNewContext) 54107120Sjulian CGM.getCXXABI().getMangleContext().startNewFunction(); 55107120Sjulian 56107120Sjulian llvm::FastMathFlags FMF; 57107120Sjulian if (CGM.getLangOpts().FastMath) 58107120Sjulian FMF.setUnsafeAlgebra(); 59107120Sjulian if (CGM.getLangOpts().FiniteMathOnly) { 60107120Sjulian FMF.setNoNaNs(); 61107120Sjulian FMF.setNoInfs(); 62107120Sjulian } 63107120Sjulian Builder.SetFastMathFlags(FMF); 64107120Sjulian} 65107120Sjulian 66107120SjulianCodeGenFunction::~CodeGenFunction() { 67107120Sjulian assert(LifetimeExtendedCleanupStack.empty() && "failed to emit a cleanup"); 68107120Sjulian 69107120Sjulian // If there are any unclaimed block infos, go ahead and destroy them 70107120Sjulian // now. This can happen if IR-gen gets clever and skips evaluating 71107120Sjulian // something. 72107120Sjulian if (FirstBlockInfo) 73107120Sjulian destroyBlockInfos(FirstBlockInfo); 74107120Sjulian} 75107120Sjulian 76107120Sjulian 77107120Sjulianllvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) { 78107120Sjulian return CGM.getTypes().ConvertTypeForMem(T); 79107120Sjulian} 80107120Sjulian 81107120Sjulianllvm::Type *CodeGenFunction::ConvertType(QualType T) { 82107120Sjulian return CGM.getTypes().ConvertType(T); 83107120Sjulian} 84107120Sjulian 85107120SjulianTypeEvaluationKind CodeGenFunction::getEvaluationKind(QualType type) { 86107120Sjulian type = type.getCanonicalType(); 87107120Sjulian while (true) { 88107120Sjulian switch (type->getTypeClass()) { 89107120Sjulian#define TYPE(name, parent) 90107120Sjulian#define ABSTRACT_TYPE(name, parent) 91107120Sjulian#define NON_CANONICAL_TYPE(name, parent) case Type::name: 92107120Sjulian#define DEPENDENT_TYPE(name, parent) case Type::name: 93107120Sjulian#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(name, parent) case Type::name: 94107120Sjulian#include "clang/AST/TypeNodes.def" 95107120Sjulian llvm_unreachable("non-canonical or dependent type in IR-generation"); 96107120Sjulian 97107120Sjulian case Type::Auto: 98107120Sjulian llvm_unreachable("undeduced auto type in IR-generation"); 99107120Sjulian 100107120Sjulian // Various scalar types. 101107120Sjulian case Type::Builtin: 102107120Sjulian case Type::Pointer: 103107120Sjulian case Type::BlockPointer: 104107120Sjulian case Type::LValueReference: 105107120Sjulian case Type::RValueReference: 106107120Sjulian case Type::MemberPointer: 107107120Sjulian case Type::Vector: 108107120Sjulian case Type::ExtVector: 109107120Sjulian case Type::FunctionProto: 110107120Sjulian case Type::FunctionNoProto: 111107120Sjulian case Type::Enum: 112107120Sjulian case Type::ObjCObjectPointer: 113107120Sjulian return TEK_Scalar; 114107120Sjulian 115107120Sjulian // Complexes. 116107120Sjulian case Type::Complex: 117107120Sjulian return TEK_Complex; 118107120Sjulian 119107120Sjulian // Arrays, records, and Objective-C objects. 120107120Sjulian case Type::ConstantArray: 121107120Sjulian case Type::IncompleteArray: 122107120Sjulian case Type::VariableArray: 123107120Sjulian case Type::Record: 124107120Sjulian case Type::ObjCObject: 125107120Sjulian case Type::ObjCInterface: 126107120Sjulian return TEK_Aggregate; 127107120Sjulian 128107120Sjulian // We operate on atomic values according to their underlying type. 129107120Sjulian case Type::Atomic: 130107120Sjulian type = cast<AtomicType>(type)->getValueType(); 131107120Sjulian continue; 132107120Sjulian } 133107120Sjulian llvm_unreachable("unknown type kind!"); 134107120Sjulian } 135107120Sjulian} 136107120Sjulian 137107120Sjulianvoid CodeGenFunction::EmitReturnBlock() { 138107120Sjulian // For cleanliness, we try to avoid emitting the return block for 139107120Sjulian // simple cases. 140107120Sjulian llvm::BasicBlock *CurBB = Builder.GetInsertBlock(); 141107120Sjulian 142107120Sjulian if (CurBB) { 143107120Sjulian assert(!CurBB->getTerminator() && "Unexpected terminated block."); 144107120Sjulian 145107120Sjulian // We have a valid insert point, reuse it if it is empty or there are no 146107120Sjulian // explicit jumps to the return block. 147107120Sjulian if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) { 148107120Sjulian ReturnBlock.getBlock()->replaceAllUsesWith(CurBB); 149107120Sjulian delete ReturnBlock.getBlock(); 150107120Sjulian } else 151107120Sjulian EmitBlock(ReturnBlock.getBlock()); 152107120Sjulian return; 153107120Sjulian } 154107120Sjulian 155107120Sjulian // Otherwise, if the return block is the target of a single direct 156107120Sjulian // branch then we can just put the code in that block instead. This 157107120Sjulian // cleans up functions which started with a unified return block. 158107120Sjulian if (ReturnBlock.getBlock()->hasOneUse()) { 159107120Sjulian llvm::BranchInst *BI = 160107120Sjulian dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->use_begin()); 161107120Sjulian if (BI && BI->isUnconditional() && 162107120Sjulian BI->getSuccessor(0) == ReturnBlock.getBlock()) { 163107120Sjulian // Reset insertion point, including debug location, and delete the 164107120Sjulian // branch. This is really subtle and only works because the next change 165107120Sjulian // in location will hit the caching in CGDebugInfo::EmitLocation and not 166107120Sjulian // override this. 167107120Sjulian Builder.SetCurrentDebugLocation(BI->getDebugLoc()); 168107120Sjulian Builder.SetInsertPoint(BI->getParent()); 169107120Sjulian BI->eraseFromParent(); 170107120Sjulian delete ReturnBlock.getBlock(); 171107120Sjulian return; 172107120Sjulian } 173107120Sjulian } 174107120Sjulian 175107120Sjulian // FIXME: We are at an unreachable point, there is no reason to emit the block 176107120Sjulian // unless it has uses. However, we still need a place to put the debug 177107120Sjulian // region.end for now. 178107120Sjulian 179107120Sjulian EmitBlock(ReturnBlock.getBlock()); 180107120Sjulian} 181107120Sjulian 182107120Sjulianstatic void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) { 183107120Sjulian if (!BB) return; 184107120Sjulian if (!BB->use_empty()) 185107120Sjulian return CGF.CurFn->getBasicBlockList().push_back(BB); 186107120Sjulian delete BB; 187107120Sjulian} 188107120Sjulian 189107120Sjulianvoid CodeGenFunction::FinishFunction(SourceLocation EndLoc) { 190107120Sjulian assert(BreakContinueStack.empty() && 191107120Sjulian "mismatched push/pop in break/continue stack!"); 192107120Sjulian 193107120Sjulian bool OnlySimpleReturnStmts = NumSimpleReturnExprs > 0 194107120Sjulian && NumSimpleReturnExprs == NumReturnExprs 195107120Sjulian && ReturnBlock.getBlock()->use_empty(); 196107120Sjulian // Usually the return expression is evaluated before the cleanup 197107120Sjulian // code. If the function contains only a simple return statement, 198107120Sjulian // such as a constant, the location before the cleanup code becomes 199107120Sjulian // the last useful breakpoint in the function, because the simple 200107120Sjulian // return expression will be evaluated after the cleanup code. To be 201114878Sjulian // safe, set the debug location for cleanup code to the location of 202114878Sjulian // the return statement. Otherwise the cleanup code should be at the 203114878Sjulian // end of the function's lexical scope. 204114878Sjulian // 205114878Sjulian // If there are multiple branches to the return block, the branch 206114878Sjulian // instructions will get the location of the return statements and 207114878Sjulian // all will be fine. 208114878Sjulian if (CGDebugInfo *DI = getDebugInfo()) { 209114878Sjulian if (OnlySimpleReturnStmts) 210114878Sjulian DI->EmitLocation(Builder, LastStopPoint); 211114878Sjulian else 212114878Sjulian DI->EmitLocation(Builder, EndLoc); 213114878Sjulian } 214114878Sjulian 215107120Sjulian // Pop any cleanups that might have been associated with the 216107120Sjulian // parameters. Do this in whatever block we're currently in; it's 217107120Sjulian // important to do this before we enter the return block or return 218107120Sjulian // edges will be *really* confused. 219107120Sjulian bool EmitRetDbgLoc = true; 220 if (EHStack.stable_begin() != PrologueCleanupDepth) { 221 PopCleanupBlocks(PrologueCleanupDepth); 222 223 // Make sure the line table doesn't jump back into the body for 224 // the ret after it's been at EndLoc. 225 EmitRetDbgLoc = false; 226 227 if (CGDebugInfo *DI = getDebugInfo()) 228 if (OnlySimpleReturnStmts) 229 DI->EmitLocation(Builder, EndLoc); 230 } 231 232 // Emit function epilog (to return). 233 EmitReturnBlock(); 234 235 if (ShouldInstrumentFunction()) 236 EmitFunctionInstrumentation("__cyg_profile_func_exit"); 237 238 // Emit debug descriptor for function end. 239 if (CGDebugInfo *DI = getDebugInfo()) { 240 DI->EmitFunctionEnd(Builder); 241 } 242 243 EmitFunctionEpilog(*CurFnInfo, EmitRetDbgLoc, EndLoc); 244 EmitEndEHSpec(CurCodeDecl); 245 246 assert(EHStack.empty() && 247 "did not remove all scopes from cleanup stack!"); 248 249 // If someone did an indirect goto, emit the indirect goto block at the end of 250 // the function. 251 if (IndirectBranch) { 252 EmitBlock(IndirectBranch->getParent()); 253 Builder.ClearInsertionPoint(); 254 } 255 256 // Remove the AllocaInsertPt instruction, which is just a convenience for us. 257 llvm::Instruction *Ptr = AllocaInsertPt; 258 AllocaInsertPt = 0; 259 Ptr->eraseFromParent(); 260 261 // If someone took the address of a label but never did an indirect goto, we 262 // made a zero entry PHI node, which is illegal, zap it now. 263 if (IndirectBranch) { 264 llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress()); 265 if (PN->getNumIncomingValues() == 0) { 266 PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType())); 267 PN->eraseFromParent(); 268 } 269 } 270 271 EmitIfUsed(*this, EHResumeBlock); 272 EmitIfUsed(*this, TerminateLandingPad); 273 EmitIfUsed(*this, TerminateHandler); 274 EmitIfUsed(*this, UnreachableBlock); 275 276 if (CGM.getCodeGenOpts().EmitDeclMetadata) 277 EmitDeclMetadata(); 278} 279 280/// ShouldInstrumentFunction - Return true if the current function should be 281/// instrumented with __cyg_profile_func_* calls 282bool CodeGenFunction::ShouldInstrumentFunction() { 283 if (!CGM.getCodeGenOpts().InstrumentFunctions) 284 return false; 285 if (!CurFuncDecl || CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>()) 286 return false; 287 return true; 288} 289 290/// EmitFunctionInstrumentation - Emit LLVM code to call the specified 291/// instrumentation function with the current function and the call site, if 292/// function instrumentation is enabled. 293void CodeGenFunction::EmitFunctionInstrumentation(const char *Fn) { 294 // void __cyg_profile_func_{enter,exit} (void *this_fn, void *call_site); 295 llvm::PointerType *PointerTy = Int8PtrTy; 296 llvm::Type *ProfileFuncArgs[] = { PointerTy, PointerTy }; 297 llvm::FunctionType *FunctionTy = 298 llvm::FunctionType::get(VoidTy, ProfileFuncArgs, false); 299 300 llvm::Constant *F = CGM.CreateRuntimeFunction(FunctionTy, Fn); 301 llvm::CallInst *CallSite = Builder.CreateCall( 302 CGM.getIntrinsic(llvm::Intrinsic::returnaddress), 303 llvm::ConstantInt::get(Int32Ty, 0), 304 "callsite"); 305 306 llvm::Value *args[] = { 307 llvm::ConstantExpr::getBitCast(CurFn, PointerTy), 308 CallSite 309 }; 310 311 EmitNounwindRuntimeCall(F, args); 312} 313 314void CodeGenFunction::EmitMCountInstrumentation() { 315 llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false); 316 317 llvm::Constant *MCountFn = 318 CGM.CreateRuntimeFunction(FTy, getTarget().getMCountName()); 319 EmitNounwindRuntimeCall(MCountFn); 320} 321 322// OpenCL v1.2 s5.6.4.6 allows the compiler to store kernel argument 323// information in the program executable. The argument information stored 324// includes the argument name, its type, the address and access qualifiers used. 325static void GenOpenCLArgMetadata(const FunctionDecl *FD, llvm::Function *Fn, 326 CodeGenModule &CGM,llvm::LLVMContext &Context, 327 SmallVector <llvm::Value*, 5> &kernelMDArgs, 328 CGBuilderTy& Builder, ASTContext &ASTCtx) { 329 // Create MDNodes that represent the kernel arg metadata. 330 // Each MDNode is a list in the form of "key", N number of values which is 331 // the same number of values as their are kernel arguments. 332 333 // MDNode for the kernel argument address space qualifiers. 334 SmallVector<llvm::Value*, 8> addressQuals; 335 addressQuals.push_back(llvm::MDString::get(Context, "kernel_arg_addr_space")); 336 337 // MDNode for the kernel argument access qualifiers (images only). 338 SmallVector<llvm::Value*, 8> accessQuals; 339 accessQuals.push_back(llvm::MDString::get(Context, "kernel_arg_access_qual")); 340 341 // MDNode for the kernel argument type names. 342 SmallVector<llvm::Value*, 8> argTypeNames; 343 argTypeNames.push_back(llvm::MDString::get(Context, "kernel_arg_type")); 344 345 // MDNode for the kernel argument type qualifiers. 346 SmallVector<llvm::Value*, 8> argTypeQuals; 347 argTypeQuals.push_back(llvm::MDString::get(Context, "kernel_arg_type_qual")); 348 349 // MDNode for the kernel argument names. 350 SmallVector<llvm::Value*, 8> argNames; 351 argNames.push_back(llvm::MDString::get(Context, "kernel_arg_name")); 352 353 for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) { 354 const ParmVarDecl *parm = FD->getParamDecl(i); 355 QualType ty = parm->getType(); 356 std::string typeQuals; 357 358 if (ty->isPointerType()) { 359 QualType pointeeTy = ty->getPointeeType(); 360 361 // Get address qualifier. 362 addressQuals.push_back(Builder.getInt32(ASTCtx.getTargetAddressSpace( 363 pointeeTy.getAddressSpace()))); 364 365 // Get argument type name. 366 std::string typeName = pointeeTy.getUnqualifiedType().getAsString() + "*"; 367 368 // Turn "unsigned type" to "utype" 369 std::string::size_type pos = typeName.find("unsigned"); 370 if (pos != std::string::npos) 371 typeName.erase(pos+1, 8); 372 373 argTypeNames.push_back(llvm::MDString::get(Context, typeName)); 374 375 // Get argument type qualifiers: 376 if (ty.isRestrictQualified()) 377 typeQuals = "restrict"; 378 if (pointeeTy.isConstQualified() || 379 (pointeeTy.getAddressSpace() == LangAS::opencl_constant)) 380 typeQuals += typeQuals.empty() ? "const" : " const"; 381 if (pointeeTy.isVolatileQualified()) 382 typeQuals += typeQuals.empty() ? "volatile" : " volatile"; 383 } else { 384 addressQuals.push_back(Builder.getInt32(0)); 385 386 // Get argument type name. 387 std::string typeName = ty.getUnqualifiedType().getAsString(); 388 389 // Turn "unsigned type" to "utype" 390 std::string::size_type pos = typeName.find("unsigned"); 391 if (pos != std::string::npos) 392 typeName.erase(pos+1, 8); 393 394 argTypeNames.push_back(llvm::MDString::get(Context, typeName)); 395 396 // Get argument type qualifiers: 397 if (ty.isConstQualified()) 398 typeQuals = "const"; 399 if (ty.isVolatileQualified()) 400 typeQuals += typeQuals.empty() ? "volatile" : " volatile"; 401 } 402 403 argTypeQuals.push_back(llvm::MDString::get(Context, typeQuals)); 404 405 // Get image access qualifier: 406 if (ty->isImageType()) { 407 if (parm->hasAttr<OpenCLImageAccessAttr>() && 408 parm->getAttr<OpenCLImageAccessAttr>()->getAccess() == CLIA_write_only) 409 accessQuals.push_back(llvm::MDString::get(Context, "write_only")); 410 else 411 accessQuals.push_back(llvm::MDString::get(Context, "read_only")); 412 } else 413 accessQuals.push_back(llvm::MDString::get(Context, "none")); 414 415 // Get argument name. 416 argNames.push_back(llvm::MDString::get(Context, parm->getName())); 417 } 418 419 kernelMDArgs.push_back(llvm::MDNode::get(Context, addressQuals)); 420 kernelMDArgs.push_back(llvm::MDNode::get(Context, accessQuals)); 421 kernelMDArgs.push_back(llvm::MDNode::get(Context, argTypeNames)); 422 kernelMDArgs.push_back(llvm::MDNode::get(Context, argTypeQuals)); 423 kernelMDArgs.push_back(llvm::MDNode::get(Context, argNames)); 424} 425 426void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD, 427 llvm::Function *Fn) 428{ 429 if (!FD->hasAttr<OpenCLKernelAttr>()) 430 return; 431 432 llvm::LLVMContext &Context = getLLVMContext(); 433 434 SmallVector <llvm::Value*, 5> kernelMDArgs; 435 kernelMDArgs.push_back(Fn); 436 437 if (CGM.getCodeGenOpts().EmitOpenCLArgMetadata) 438 GenOpenCLArgMetadata(FD, Fn, CGM, Context, kernelMDArgs, 439 Builder, getContext()); 440 441 if (FD->hasAttr<VecTypeHintAttr>()) { 442 VecTypeHintAttr *attr = FD->getAttr<VecTypeHintAttr>(); 443 QualType hintQTy = attr->getTypeHint(); 444 const ExtVectorType *hintEltQTy = hintQTy->getAs<ExtVectorType>(); 445 bool isSignedInteger = 446 hintQTy->isSignedIntegerType() || 447 (hintEltQTy && hintEltQTy->getElementType()->isSignedIntegerType()); 448 llvm::Value *attrMDArgs[] = { 449 llvm::MDString::get(Context, "vec_type_hint"), 450 llvm::UndefValue::get(CGM.getTypes().ConvertType(attr->getTypeHint())), 451 llvm::ConstantInt::get( 452 llvm::IntegerType::get(Context, 32), 453 llvm::APInt(32, (uint64_t)(isSignedInteger ? 1 : 0))) 454 }; 455 kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs)); 456 } 457 458 if (FD->hasAttr<WorkGroupSizeHintAttr>()) { 459 WorkGroupSizeHintAttr *attr = FD->getAttr<WorkGroupSizeHintAttr>(); 460 llvm::Value *attrMDArgs[] = { 461 llvm::MDString::get(Context, "work_group_size_hint"), 462 Builder.getInt32(attr->getXDim()), 463 Builder.getInt32(attr->getYDim()), 464 Builder.getInt32(attr->getZDim()) 465 }; 466 kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs)); 467 } 468 469 if (FD->hasAttr<ReqdWorkGroupSizeAttr>()) { 470 ReqdWorkGroupSizeAttr *attr = FD->getAttr<ReqdWorkGroupSizeAttr>(); 471 llvm::Value *attrMDArgs[] = { 472 llvm::MDString::get(Context, "reqd_work_group_size"), 473 Builder.getInt32(attr->getXDim()), 474 Builder.getInt32(attr->getYDim()), 475 Builder.getInt32(attr->getZDim()) 476 }; 477 kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs)); 478 } 479 480 llvm::MDNode *kernelMDNode = llvm::MDNode::get(Context, kernelMDArgs); 481 llvm::NamedMDNode *OpenCLKernelMetadata = 482 CGM.getModule().getOrInsertNamedMetadata("opencl.kernels"); 483 OpenCLKernelMetadata->addOperand(kernelMDNode); 484} 485 486void CodeGenFunction::StartFunction(GlobalDecl GD, 487 QualType RetTy, 488 llvm::Function *Fn, 489 const CGFunctionInfo &FnInfo, 490 const FunctionArgList &Args, 491 SourceLocation StartLoc) { 492 const Decl *D = GD.getDecl(); 493 494 DidCallStackSave = false; 495 CurCodeDecl = D; 496 CurFuncDecl = (D ? D->getNonClosureContext() : 0); 497 FnRetTy = RetTy; 498 CurFn = Fn; 499 CurFnInfo = &FnInfo; 500 assert(CurFn->isDeclaration() && "Function already has body?"); 501 502 if (CGM.getSanitizerBlacklist().isIn(*Fn)) { 503 SanOpts = &SanitizerOptions::Disabled; 504 SanitizePerformTypeCheck = false; 505 } 506 507 // Pass inline keyword to optimizer if it appears explicitly on any 508 // declaration. 509 if (!CGM.getCodeGenOpts().NoInline) 510 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) 511 for (FunctionDecl::redecl_iterator RI = FD->redecls_begin(), 512 RE = FD->redecls_end(); RI != RE; ++RI) 513 if (RI->isInlineSpecified()) { 514 Fn->addFnAttr(llvm::Attribute::InlineHint); 515 break; 516 } 517 518 if (getLangOpts().OpenCL) { 519 // Add metadata for a kernel function. 520 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) 521 EmitOpenCLKernelMetadata(FD, Fn); 522 } 523 524 // If we are checking function types, emit a function type signature as 525 // prefix data. 526 if (getLangOpts().CPlusPlus && SanOpts->Function) { 527 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) { 528 if (llvm::Constant *PrefixSig = 529 CGM.getTargetCodeGenInfo().getUBSanFunctionSignature(CGM)) { 530 llvm::Constant *FTRTTIConst = 531 CGM.GetAddrOfRTTIDescriptor(FD->getType(), /*ForEH=*/true); 532 llvm::Constant *PrefixStructElems[] = { PrefixSig, FTRTTIConst }; 533 llvm::Constant *PrefixStructConst = 534 llvm::ConstantStruct::getAnon(PrefixStructElems, /*Packed=*/true); 535 Fn->setPrefixData(PrefixStructConst); 536 } 537 } 538 } 539 540 llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn); 541 542 // Create a marker to make it easy to insert allocas into the entryblock 543 // later. Don't create this with the builder, because we don't want it 544 // folded. 545 llvm::Value *Undef = llvm::UndefValue::get(Int32Ty); 546 AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "", EntryBB); 547 if (Builder.isNamePreserving()) 548 AllocaInsertPt->setName("allocapt"); 549 550 ReturnBlock = getJumpDestInCurrentScope("return"); 551 552 Builder.SetInsertPoint(EntryBB); 553 554 // Emit subprogram debug descriptor. 555 if (CGDebugInfo *DI = getDebugInfo()) { 556 SmallVector<QualType, 16> ArgTypes; 557 for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); 558 i != e; ++i) { 559 ArgTypes.push_back((*i)->getType()); 560 } 561 562 QualType FnType = 563 getContext().getFunctionType(RetTy, ArgTypes, 564 FunctionProtoType::ExtProtoInfo()); 565 566 DI->setLocation(StartLoc); 567 DI->EmitFunctionStart(GD, FnType, CurFn, Builder); 568 } 569 570 if (ShouldInstrumentFunction()) 571 EmitFunctionInstrumentation("__cyg_profile_func_enter"); 572 573 if (CGM.getCodeGenOpts().InstrumentForProfiling) 574 EmitMCountInstrumentation(); 575 576 if (RetTy->isVoidType()) { 577 // Void type; nothing to return. 578 ReturnValue = 0; 579 } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect && 580 !hasScalarEvaluationKind(CurFnInfo->getReturnType())) { 581 // Indirect aggregate return; emit returned value directly into sret slot. 582 // This reduces code size, and affects correctness in C++. 583 ReturnValue = CurFn->arg_begin(); 584 } else { 585 ReturnValue = CreateIRTemp(RetTy, "retval"); 586 587 // Tell the epilog emitter to autorelease the result. We do this 588 // now so that various specialized functions can suppress it 589 // during their IR-generation. 590 if (getLangOpts().ObjCAutoRefCount && 591 !CurFnInfo->isReturnsRetained() && 592 RetTy->isObjCRetainableType()) 593 AutoreleaseResult = true; 594 } 595 596 EmitStartEHSpec(CurCodeDecl); 597 598 PrologueCleanupDepth = EHStack.stable_begin(); 599 EmitFunctionProlog(*CurFnInfo, CurFn, Args); 600 601 if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) { 602 CGM.getCXXABI().EmitInstanceFunctionProlog(*this); 603 const CXXMethodDecl *MD = cast<CXXMethodDecl>(D); 604 if (MD->getParent()->isLambda() && 605 MD->getOverloadedOperator() == OO_Call) { 606 // We're in a lambda; figure out the captures. 607 MD->getParent()->getCaptureFields(LambdaCaptureFields, 608 LambdaThisCaptureField); 609 if (LambdaThisCaptureField) { 610 // If this lambda captures this, load it. 611 LValue ThisLValue = EmitLValueForLambdaField(LambdaThisCaptureField); 612 CXXThisValue = EmitLoadOfLValue(ThisLValue, 613 SourceLocation()).getScalarVal(); 614 } 615 } else { 616 // Not in a lambda; just use 'this' from the method. 617 // FIXME: Should we generate a new load for each use of 'this'? The 618 // fast register allocator would be happier... 619 CXXThisValue = CXXABIThisValue; 620 } 621 } 622 623 // If any of the arguments have a variably modified type, make sure to 624 // emit the type size. 625 for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end(); 626 i != e; ++i) { 627 const VarDecl *VD = *i; 628 629 // Dig out the type as written from ParmVarDecls; it's unclear whether 630 // the standard (C99 6.9.1p10) requires this, but we're following the 631 // precedent set by gcc. 632 QualType Ty; 633 if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD)) 634 Ty = PVD->getOriginalType(); 635 else 636 Ty = VD->getType(); 637 638 if (Ty->isVariablyModifiedType()) 639 EmitVariablyModifiedType(Ty); 640 } 641 // Emit a location at the end of the prologue. 642 if (CGDebugInfo *DI = getDebugInfo()) 643 DI->EmitLocation(Builder, StartLoc); 644} 645 646void CodeGenFunction::EmitFunctionBody(FunctionArgList &Args, 647 const Stmt *Body) { 648 if (const CompoundStmt *S = dyn_cast<CompoundStmt>(Body)) 649 EmitCompoundStmtWithoutScope(*S); 650 else 651 EmitStmt(Body); 652} 653 654/// Tries to mark the given function nounwind based on the 655/// non-existence of any throwing calls within it. We believe this is 656/// lightweight enough to do at -O0. 657static void TryMarkNoThrow(llvm::Function *F) { 658 // LLVM treats 'nounwind' on a function as part of the type, so we 659 // can't do this on functions that can be overwritten. 660 if (F->mayBeOverridden()) return; 661 662 for (llvm::Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI) 663 for (llvm::BasicBlock::iterator 664 BI = FI->begin(), BE = FI->end(); BI != BE; ++BI) 665 if (llvm::CallInst *Call = dyn_cast<llvm::CallInst>(&*BI)) { 666 if (!Call->doesNotThrow()) 667 return; 668 } else if (isa<llvm::ResumeInst>(&*BI)) { 669 return; 670 } 671 F->setDoesNotThrow(); 672} 673 674static void EmitSizedDeallocationFunction(CodeGenFunction &CGF, 675 const FunctionDecl *UnsizedDealloc) { 676 // This is a weak discardable definition of the sized deallocation function. 677 CGF.CurFn->setLinkage(llvm::Function::LinkOnceAnyLinkage); 678 679 // Call the unsized deallocation function and forward the first argument 680 // unchanged. 681 llvm::Constant *Unsized = CGF.CGM.GetAddrOfFunction(UnsizedDealloc); 682 CGF.Builder.CreateCall(Unsized, &*CGF.CurFn->arg_begin()); 683} 684 685void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn, 686 const CGFunctionInfo &FnInfo) { 687 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl()); 688 689 // Check if we should generate debug info for this function. 690 if (FD->hasAttr<NoDebugAttr>()) 691 DebugInfo = NULL; // disable debug info indefinitely for this function 692 693 FunctionArgList Args; 694 QualType ResTy = FD->getResultType(); 695 696 CurGD = GD; 697 const CXXMethodDecl *MD; 698 if ((MD = dyn_cast<CXXMethodDecl>(FD)) && MD->isInstance()) { 699 if (CGM.getCXXABI().HasThisReturn(GD)) 700 ResTy = MD->getThisType(getContext()); 701 CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResTy, Args); 702 } 703 704 for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) 705 Args.push_back(FD->getParamDecl(i)); 706 707 SourceRange BodyRange; 708 if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange(); 709 CurEHLocation = BodyRange.getEnd(); 710 711 // Emit the standard function prologue. 712 StartFunction(GD, ResTy, Fn, FnInfo, Args, BodyRange.getBegin()); 713 714 // Generate the body of the function. 715 if (isa<CXXDestructorDecl>(FD)) 716 EmitDestructorBody(Args); 717 else if (isa<CXXConstructorDecl>(FD)) 718 EmitConstructorBody(Args); 719 else if (getLangOpts().CUDA && 720 !CGM.getCodeGenOpts().CUDAIsDevice && 721 FD->hasAttr<CUDAGlobalAttr>()) 722 CGM.getCUDARuntime().EmitDeviceStubBody(*this, Args); 723 else if (isa<CXXConversionDecl>(FD) && 724 cast<CXXConversionDecl>(FD)->isLambdaToBlockPointerConversion()) { 725 // The lambda conversion to block pointer is special; the semantics can't be 726 // expressed in the AST, so IRGen needs to special-case it. 727 EmitLambdaToBlockPointerBody(Args); 728 } else if (isa<CXXMethodDecl>(FD) && 729 cast<CXXMethodDecl>(FD)->isLambdaStaticInvoker()) { 730 // The lambda static invoker function is special, because it forwards or 731 // clones the body of the function call operator (but is actually static). 732 EmitLambdaStaticInvokeFunction(cast<CXXMethodDecl>(FD)); 733 } else if (FD->isDefaulted() && isa<CXXMethodDecl>(FD) && 734 (cast<CXXMethodDecl>(FD)->isCopyAssignmentOperator() || 735 cast<CXXMethodDecl>(FD)->isMoveAssignmentOperator())) { 736 // Implicit copy-assignment gets the same special treatment as implicit 737 // copy-constructors. 738 emitImplicitAssignmentOperatorBody(Args); 739 } else if (Stmt *Body = FD->getBody()) { 740 EmitFunctionBody(Args, Body); 741 } else if (FunctionDecl *UnsizedDealloc = 742 FD->getCorrespondingUnsizedGlobalDeallocationFunction()) { 743 // Global sized deallocation functions get an implicit weak definition if 744 // they don't have an explicit definition. 745 EmitSizedDeallocationFunction(*this, UnsizedDealloc); 746 } else 747 llvm_unreachable("no definition for emitted function"); 748 749 // C++11 [stmt.return]p2: 750 // Flowing off the end of a function [...] results in undefined behavior in 751 // a value-returning function. 752 // C11 6.9.1p12: 753 // If the '}' that terminates a function is reached, and the value of the 754 // function call is used by the caller, the behavior is undefined. 755 if (getLangOpts().CPlusPlus && !FD->hasImplicitReturnZero() && 756 !FD->getResultType()->isVoidType() && Builder.GetInsertBlock()) { 757 if (SanOpts->Return) 758 EmitCheck(Builder.getFalse(), "missing_return", 759 EmitCheckSourceLocation(FD->getLocation()), 760 ArrayRef<llvm::Value *>(), CRK_Unrecoverable); 761 else if (CGM.getCodeGenOpts().OptimizationLevel == 0) 762 Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::trap)); 763 Builder.CreateUnreachable(); 764 Builder.ClearInsertionPoint(); 765 } 766 767 // Emit the standard function epilogue. 768 FinishFunction(BodyRange.getEnd()); 769 770 // If we haven't marked the function nothrow through other means, do 771 // a quick pass now to see if we can. 772 if (!CurFn->doesNotThrow()) 773 TryMarkNoThrow(CurFn); 774} 775 776/// ContainsLabel - Return true if the statement contains a label in it. If 777/// this statement is not executed normally, it not containing a label means 778/// that we can just remove the code. 779bool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) { 780 // Null statement, not a label! 781 if (S == 0) return false; 782 783 // If this is a label, we have to emit the code, consider something like: 784 // if (0) { ... foo: bar(); } goto foo; 785 // 786 // TODO: If anyone cared, we could track __label__'s, since we know that you 787 // can't jump to one from outside their declared region. 788 if (isa<LabelStmt>(S)) 789 return true; 790 791 // If this is a case/default statement, and we haven't seen a switch, we have 792 // to emit the code. 793 if (isa<SwitchCase>(S) && !IgnoreCaseStmts) 794 return true; 795 796 // If this is a switch statement, we want to ignore cases below it. 797 if (isa<SwitchStmt>(S)) 798 IgnoreCaseStmts = true; 799 800 // Scan subexpressions for verboten labels. 801 for (Stmt::const_child_range I = S->children(); I; ++I) 802 if (ContainsLabel(*I, IgnoreCaseStmts)) 803 return true; 804 805 return false; 806} 807 808/// containsBreak - Return true if the statement contains a break out of it. 809/// If the statement (recursively) contains a switch or loop with a break 810/// inside of it, this is fine. 811bool CodeGenFunction::containsBreak(const Stmt *S) { 812 // Null statement, not a label! 813 if (S == 0) return false; 814 815 // If this is a switch or loop that defines its own break scope, then we can 816 // include it and anything inside of it. 817 if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || isa<DoStmt>(S) || 818 isa<ForStmt>(S)) 819 return false; 820 821 if (isa<BreakStmt>(S)) 822 return true; 823 824 // Scan subexpressions for verboten breaks. 825 for (Stmt::const_child_range I = S->children(); I; ++I) 826 if (containsBreak(*I)) 827 return true; 828 829 return false; 830} 831 832 833/// ConstantFoldsToSimpleInteger - If the specified expression does not fold 834/// to a constant, or if it does but contains a label, return false. If it 835/// constant folds return true and set the boolean result in Result. 836bool CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond, 837 bool &ResultBool) { 838 llvm::APSInt ResultInt; 839 if (!ConstantFoldsToSimpleInteger(Cond, ResultInt)) 840 return false; 841 842 ResultBool = ResultInt.getBoolValue(); 843 return true; 844} 845 846/// ConstantFoldsToSimpleInteger - If the specified expression does not fold 847/// to a constant, or if it does but contains a label, return false. If it 848/// constant folds return true and set the folded value. 849bool CodeGenFunction:: 850ConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APSInt &ResultInt) { 851 // FIXME: Rename and handle conversion of other evaluatable things 852 // to bool. 853 llvm::APSInt Int; 854 if (!Cond->EvaluateAsInt(Int, getContext())) 855 return false; // Not foldable, not integer or not fully evaluatable. 856 857 if (CodeGenFunction::ContainsLabel(Cond)) 858 return false; // Contains a label. 859 860 ResultInt = Int; 861 return true; 862} 863 864 865 866/// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if 867/// statement) to the specified blocks. Based on the condition, this might try 868/// to simplify the codegen of the conditional based on the branch. 869/// 870void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond, 871 llvm::BasicBlock *TrueBlock, 872 llvm::BasicBlock *FalseBlock) { 873 Cond = Cond->IgnoreParens(); 874 875 if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) { 876 // Handle X && Y in a condition. 877 if (CondBOp->getOpcode() == BO_LAnd) { 878 // If we have "1 && X", simplify the code. "0 && X" would have constant 879 // folded if the case was simple enough. 880 bool ConstantBool = false; 881 if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) && 882 ConstantBool) { 883 // br(1 && X) -> br(X). 884 return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 885 } 886 887 // If we have "X && 1", simplify the code to use an uncond branch. 888 // "X && 0" would have been constant folded to 0. 889 if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) && 890 ConstantBool) { 891 // br(X && 1) -> br(X). 892 return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 893 } 894 895 // Emit the LHS as a conditional. If the LHS conditional is false, we 896 // want to jump to the FalseBlock. 897 llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true"); 898 899 ConditionalEvaluation eval(*this); 900 EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock); 901 EmitBlock(LHSTrue); 902 903 // Any temporaries created here are conditional. 904 eval.begin(*this); 905 EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 906 eval.end(*this); 907 908 return; 909 } 910 911 if (CondBOp->getOpcode() == BO_LOr) { 912 // If we have "0 || X", simplify the code. "1 || X" would have constant 913 // folded if the case was simple enough. 914 bool ConstantBool = false; 915 if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) && 916 !ConstantBool) { 917 // br(0 || X) -> br(X). 918 return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 919 } 920 921 // If we have "X || 0", simplify the code to use an uncond branch. 922 // "X || 1" would have been constant folded to 1. 923 if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) && 924 !ConstantBool) { 925 // br(X || 0) -> br(X). 926 return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock); 927 } 928 929 // Emit the LHS as a conditional. If the LHS conditional is true, we 930 // want to jump to the TrueBlock. 931 llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false"); 932 933 ConditionalEvaluation eval(*this); 934 EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse); 935 EmitBlock(LHSFalse); 936 937 // Any temporaries created here are conditional. 938 eval.begin(*this); 939 EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock); 940 eval.end(*this); 941 942 return; 943 } 944 } 945 946 if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) { 947 // br(!x, t, f) -> br(x, f, t) 948 if (CondUOp->getOpcode() == UO_LNot) 949 return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock); 950 } 951 952 if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) { 953 // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f)) 954 llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true"); 955 llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false"); 956 957 ConditionalEvaluation cond(*this); 958 EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock); 959 960 cond.begin(*this); 961 EmitBlock(LHSBlock); 962 EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock); 963 cond.end(*this); 964 965 cond.begin(*this); 966 EmitBlock(RHSBlock); 967 EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock); 968 cond.end(*this); 969 970 return; 971 } 972 973 if (const CXXThrowExpr *Throw = dyn_cast<CXXThrowExpr>(Cond)) { 974 // Conditional operator handling can give us a throw expression as a 975 // condition for a case like: 976 // br(c ? throw x : y, t, f) -> br(c, br(throw x, t, f), br(y, t, f) 977 // Fold this to: 978 // br(c, throw x, br(y, t, f)) 979 EmitCXXThrowExpr(Throw, /*KeepInsertionPoint*/false); 980 return; 981 } 982 983 // Emit the code with the fully general case. 984 llvm::Value *CondV = EvaluateExprAsBool(Cond); 985 Builder.CreateCondBr(CondV, TrueBlock, FalseBlock); 986} 987 988/// ErrorUnsupported - Print out an error that codegen doesn't support the 989/// specified stmt yet. 990void CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type) { 991 CGM.ErrorUnsupported(S, Type); 992} 993 994/// emitNonZeroVLAInit - Emit the "zero" initialization of a 995/// variable-length array whose elements have a non-zero bit-pattern. 996/// 997/// \param baseType the inner-most element type of the array 998/// \param src - a char* pointing to the bit-pattern for a single 999/// base element of the array 1000/// \param sizeInChars - the total size of the VLA, in chars 1001static void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType, 1002 llvm::Value *dest, llvm::Value *src, 1003 llvm::Value *sizeInChars) { 1004 std::pair<CharUnits,CharUnits> baseSizeAndAlign 1005 = CGF.getContext().getTypeInfoInChars(baseType); 1006 1007 CGBuilderTy &Builder = CGF.Builder; 1008 1009 llvm::Value *baseSizeInChars 1010 = llvm::ConstantInt::get(CGF.IntPtrTy, baseSizeAndAlign.first.getQuantity()); 1011 1012 llvm::Type *i8p = Builder.getInt8PtrTy(); 1013 1014 llvm::Value *begin = Builder.CreateBitCast(dest, i8p, "vla.begin"); 1015 llvm::Value *end = Builder.CreateInBoundsGEP(dest, sizeInChars, "vla.end"); 1016 1017 llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock(); 1018 llvm::BasicBlock *loopBB = CGF.createBasicBlock("vla-init.loop"); 1019 llvm::BasicBlock *contBB = CGF.createBasicBlock("vla-init.cont"); 1020 1021 // Make a loop over the VLA. C99 guarantees that the VLA element 1022 // count must be nonzero. 1023 CGF.EmitBlock(loopBB); 1024 1025 llvm::PHINode *cur = Builder.CreatePHI(i8p, 2, "vla.cur"); 1026 cur->addIncoming(begin, originBB); 1027 1028 // memcpy the individual element bit-pattern. 1029 Builder.CreateMemCpy(cur, src, baseSizeInChars, 1030 baseSizeAndAlign.second.getQuantity(), 1031 /*volatile*/ false); 1032 1033 // Go to the next element. 1034 llvm::Value *next = Builder.CreateConstInBoundsGEP1_32(cur, 1, "vla.next"); 1035 1036 // Leave if that's the end of the VLA. 1037 llvm::Value *done = Builder.CreateICmpEQ(next, end, "vla-init.isdone"); 1038 Builder.CreateCondBr(done, contBB, loopBB); 1039 cur->addIncoming(next, loopBB); 1040 1041 CGF.EmitBlock(contBB); 1042} 1043 1044void 1045CodeGenFunction::EmitNullInitialization(llvm::Value *DestPtr, QualType Ty) { 1046 // Ignore empty classes in C++. 1047 if (getLangOpts().CPlusPlus) { 1048 if (const RecordType *RT = Ty->getAs<RecordType>()) { 1049 if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty()) 1050 return; 1051 } 1052 } 1053 1054 // Cast the dest ptr to the appropriate i8 pointer type. 1055 unsigned DestAS = 1056 cast<llvm::PointerType>(DestPtr->getType())->getAddressSpace(); 1057 llvm::Type *BP = Builder.getInt8PtrTy(DestAS); 1058 if (DestPtr->getType() != BP) 1059 DestPtr = Builder.CreateBitCast(DestPtr, BP); 1060 1061 // Get size and alignment info for this aggregate. 1062 std::pair<CharUnits, CharUnits> TypeInfo = 1063 getContext().getTypeInfoInChars(Ty); 1064 CharUnits Size = TypeInfo.first; 1065 CharUnits Align = TypeInfo.second; 1066 1067 llvm::Value *SizeVal; 1068 const VariableArrayType *vla; 1069 1070 // Don't bother emitting a zero-byte memset. 1071 if (Size.isZero()) { 1072 // But note that getTypeInfo returns 0 for a VLA. 1073 if (const VariableArrayType *vlaType = 1074 dyn_cast_or_null<VariableArrayType>( 1075 getContext().getAsArrayType(Ty))) { 1076 QualType eltType; 1077 llvm::Value *numElts; 1078 llvm::tie(numElts, eltType) = getVLASize(vlaType); 1079 1080 SizeVal = numElts; 1081 CharUnits eltSize = getContext().getTypeSizeInChars(eltType); 1082 if (!eltSize.isOne()) 1083 SizeVal = Builder.CreateNUWMul(SizeVal, CGM.getSize(eltSize)); 1084 vla = vlaType; 1085 } else { 1086 return; 1087 } 1088 } else { 1089 SizeVal = CGM.getSize(Size); 1090 vla = 0; 1091 } 1092 1093 // If the type contains a pointer to data member we can't memset it to zero. 1094 // Instead, create a null constant and copy it to the destination. 1095 // TODO: there are other patterns besides zero that we can usefully memset, 1096 // like -1, which happens to be the pattern used by member-pointers. 1097 if (!CGM.getTypes().isZeroInitializable(Ty)) { 1098 // For a VLA, emit a single element, then splat that over the VLA. 1099 if (vla) Ty = getContext().getBaseElementType(vla); 1100 1101 llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty); 1102 1103 llvm::GlobalVariable *NullVariable = 1104 new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(), 1105 /*isConstant=*/true, 1106 llvm::GlobalVariable::PrivateLinkage, 1107 NullConstant, Twine()); 1108 llvm::Value *SrcPtr = 1109 Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()); 1110 1111 if (vla) return emitNonZeroVLAInit(*this, Ty, DestPtr, SrcPtr, SizeVal); 1112 1113 // Get and call the appropriate llvm.memcpy overload. 1114 Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, Align.getQuantity(), false); 1115 return; 1116 } 1117 1118 // Otherwise, just memset the whole thing to zero. This is legal 1119 // because in LLVM, all default initializers (other than the ones we just 1120 // handled above) are guaranteed to have a bit pattern of all zeros. 1121 Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal, 1122 Align.getQuantity(), false); 1123} 1124 1125llvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelDecl *L) { 1126 // Make sure that there is a block for the indirect goto. 1127 if (IndirectBranch == 0) 1128 GetIndirectGotoBlock(); 1129 1130 llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock(); 1131 1132 // Make sure the indirect branch includes all of the address-taken blocks. 1133 IndirectBranch->addDestination(BB); 1134 return llvm::BlockAddress::get(CurFn, BB); 1135} 1136 1137llvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() { 1138 // If we already made the indirect branch for indirect goto, return its block. 1139 if (IndirectBranch) return IndirectBranch->getParent(); 1140 1141 CGBuilderTy TmpBuilder(createBasicBlock("indirectgoto")); 1142 1143 // Create the PHI node that indirect gotos will add entries to. 1144 llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, 0, 1145 "indirect.goto.dest"); 1146 1147 // Create the indirect branch instruction. 1148 IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal); 1149 return IndirectBranch->getParent(); 1150} 1151 1152/// Computes the length of an array in elements, as well as the base 1153/// element type and a properly-typed first element pointer. 1154llvm::Value *CodeGenFunction::emitArrayLength(const ArrayType *origArrayType, 1155 QualType &baseType, 1156 llvm::Value *&addr) { 1157 const ArrayType *arrayType = origArrayType; 1158 1159 // If it's a VLA, we have to load the stored size. Note that 1160 // this is the size of the VLA in bytes, not its size in elements. 1161 llvm::Value *numVLAElements = 0; 1162 if (isa<VariableArrayType>(arrayType)) { 1163 numVLAElements = getVLASize(cast<VariableArrayType>(arrayType)).first; 1164 1165 // Walk into all VLAs. This doesn't require changes to addr, 1166 // which has type T* where T is the first non-VLA element type. 1167 do { 1168 QualType elementType = arrayType->getElementType(); 1169 arrayType = getContext().getAsArrayType(elementType); 1170 1171 // If we only have VLA components, 'addr' requires no adjustment. 1172 if (!arrayType) { 1173 baseType = elementType; 1174 return numVLAElements; 1175 } 1176 } while (isa<VariableArrayType>(arrayType)); 1177 1178 // We get out here only if we find a constant array type 1179 // inside the VLA. 1180 } 1181 1182 // We have some number of constant-length arrays, so addr should 1183 // have LLVM type [M x [N x [...]]]*. Build a GEP that walks 1184 // down to the first element of addr. 1185 SmallVector<llvm::Value*, 8> gepIndices; 1186 1187 // GEP down to the array type. 1188 llvm::ConstantInt *zero = Builder.getInt32(0); 1189 gepIndices.push_back(zero); 1190 1191 uint64_t countFromCLAs = 1; 1192 QualType eltType; 1193 1194 llvm::ArrayType *llvmArrayType = 1195 dyn_cast<llvm::ArrayType>( 1196 cast<llvm::PointerType>(addr->getType())->getElementType()); 1197 while (llvmArrayType) { 1198 assert(isa<ConstantArrayType>(arrayType)); 1199 assert(cast<ConstantArrayType>(arrayType)->getSize().getZExtValue() 1200 == llvmArrayType->getNumElements()); 1201 1202 gepIndices.push_back(zero); 1203 countFromCLAs *= llvmArrayType->getNumElements(); 1204 eltType = arrayType->getElementType(); 1205 1206 llvmArrayType = 1207 dyn_cast<llvm::ArrayType>(llvmArrayType->getElementType()); 1208 arrayType = getContext().getAsArrayType(arrayType->getElementType()); 1209 assert((!llvmArrayType || arrayType) && 1210 "LLVM and Clang types are out-of-synch"); 1211 } 1212 1213 if (arrayType) { 1214 // From this point onwards, the Clang array type has been emitted 1215 // as some other type (probably a packed struct). Compute the array 1216 // size, and just emit the 'begin' expression as a bitcast. 1217 while (arrayType) { 1218 countFromCLAs *= 1219 cast<ConstantArrayType>(arrayType)->getSize().getZExtValue(); 1220 eltType = arrayType->getElementType(); 1221 arrayType = getContext().getAsArrayType(eltType); 1222 } 1223 1224 unsigned AddressSpace = addr->getType()->getPointerAddressSpace(); 1225 llvm::Type *BaseType = ConvertType(eltType)->getPointerTo(AddressSpace); 1226 addr = Builder.CreateBitCast(addr, BaseType, "array.begin"); 1227 } else { 1228 // Create the actual GEP. 1229 addr = Builder.CreateInBoundsGEP(addr, gepIndices, "array.begin"); 1230 } 1231 1232 baseType = eltType; 1233 1234 llvm::Value *numElements 1235 = llvm::ConstantInt::get(SizeTy, countFromCLAs); 1236 1237 // If we had any VLA dimensions, factor them in. 1238 if (numVLAElements) 1239 numElements = Builder.CreateNUWMul(numVLAElements, numElements); 1240 1241 return numElements; 1242} 1243 1244std::pair<llvm::Value*, QualType> 1245CodeGenFunction::getVLASize(QualType type) { 1246 const VariableArrayType *vla = getContext().getAsVariableArrayType(type); 1247 assert(vla && "type was not a variable array type!"); 1248 return getVLASize(vla); 1249} 1250 1251std::pair<llvm::Value*, QualType> 1252CodeGenFunction::getVLASize(const VariableArrayType *type) { 1253 // The number of elements so far; always size_t. 1254 llvm::Value *numElements = 0; 1255 1256 QualType elementType; 1257 do { 1258 elementType = type->getElementType(); 1259 llvm::Value *vlaSize = VLASizeMap[type->getSizeExpr()]; 1260 assert(vlaSize && "no size for VLA!"); 1261 assert(vlaSize->getType() == SizeTy); 1262 1263 if (!numElements) { 1264 numElements = vlaSize; 1265 } else { 1266 // It's undefined behavior if this wraps around, so mark it that way. 1267 // FIXME: Teach -fcatch-undefined-behavior to trap this. 1268 numElements = Builder.CreateNUWMul(numElements, vlaSize); 1269 } 1270 } while ((type = getContext().getAsVariableArrayType(elementType))); 1271 1272 return std::pair<llvm::Value*,QualType>(numElements, elementType); 1273} 1274 1275void CodeGenFunction::EmitVariablyModifiedType(QualType type) { 1276 assert(type->isVariablyModifiedType() && 1277 "Must pass variably modified type to EmitVLASizes!"); 1278 1279 EnsureInsertPoint(); 1280 1281 // We're going to walk down into the type and look for VLA 1282 // expressions. 1283 do { 1284 assert(type->isVariablyModifiedType()); 1285 1286 const Type *ty = type.getTypePtr(); 1287 switch (ty->getTypeClass()) { 1288 1289#define TYPE(Class, Base) 1290#define ABSTRACT_TYPE(Class, Base) 1291#define NON_CANONICAL_TYPE(Class, Base) 1292#define DEPENDENT_TYPE(Class, Base) case Type::Class: 1293#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) 1294#include "clang/AST/TypeNodes.def" 1295 llvm_unreachable("unexpected dependent type!"); 1296 1297 // These types are never variably-modified. 1298 case Type::Builtin: 1299 case Type::Complex: 1300 case Type::Vector: 1301 case Type::ExtVector: 1302 case Type::Record: 1303 case Type::Enum: 1304 case Type::Elaborated: 1305 case Type::TemplateSpecialization: 1306 case Type::ObjCObject: 1307 case Type::ObjCInterface: 1308 case Type::ObjCObjectPointer: 1309 llvm_unreachable("type class is never variably-modified!"); 1310 1311 case Type::Decayed: 1312 type = cast<DecayedType>(ty)->getPointeeType(); 1313 break; 1314 1315 case Type::Pointer: 1316 type = cast<PointerType>(ty)->getPointeeType(); 1317 break; 1318 1319 case Type::BlockPointer: 1320 type = cast<BlockPointerType>(ty)->getPointeeType(); 1321 break; 1322 1323 case Type::LValueReference: 1324 case Type::RValueReference: 1325 type = cast<ReferenceType>(ty)->getPointeeType(); 1326 break; 1327 1328 case Type::MemberPointer: 1329 type = cast<MemberPointerType>(ty)->getPointeeType(); 1330 break; 1331 1332 case Type::ConstantArray: 1333 case Type::IncompleteArray: 1334 // Losing element qualification here is fine. 1335 type = cast<ArrayType>(ty)->getElementType(); 1336 break; 1337 1338 case Type::VariableArray: { 1339 // Losing element qualification here is fine. 1340 const VariableArrayType *vat = cast<VariableArrayType>(ty); 1341 1342 // Unknown size indication requires no size computation. 1343 // Otherwise, evaluate and record it. 1344 if (const Expr *size = vat->getSizeExpr()) { 1345 // It's possible that we might have emitted this already, 1346 // e.g. with a typedef and a pointer to it. 1347 llvm::Value *&entry = VLASizeMap[size]; 1348 if (!entry) { 1349 llvm::Value *Size = EmitScalarExpr(size); 1350 1351 // C11 6.7.6.2p5: 1352 // If the size is an expression that is not an integer constant 1353 // expression [...] each time it is evaluated it shall have a value 1354 // greater than zero. 1355 if (SanOpts->VLABound && 1356 size->getType()->isSignedIntegerType()) { 1357 llvm::Value *Zero = llvm::Constant::getNullValue(Size->getType()); 1358 llvm::Constant *StaticArgs[] = { 1359 EmitCheckSourceLocation(size->getLocStart()), 1360 EmitCheckTypeDescriptor(size->getType()) 1361 }; 1362 EmitCheck(Builder.CreateICmpSGT(Size, Zero), 1363 "vla_bound_not_positive", StaticArgs, Size, 1364 CRK_Recoverable); 1365 } 1366 1367 // Always zexting here would be wrong if it weren't 1368 // undefined behavior to have a negative bound. 1369 entry = Builder.CreateIntCast(Size, SizeTy, /*signed*/ false); 1370 } 1371 } 1372 type = vat->getElementType(); 1373 break; 1374 } 1375 1376 case Type::FunctionProto: 1377 case Type::FunctionNoProto: 1378 type = cast<FunctionType>(ty)->getResultType(); 1379 break; 1380 1381 case Type::Paren: 1382 case Type::TypeOf: 1383 case Type::UnaryTransform: 1384 case Type::Attributed: 1385 case Type::SubstTemplateTypeParm: 1386 case Type::PackExpansion: 1387 // Keep walking after single level desugaring. 1388 type = type.getSingleStepDesugaredType(getContext()); 1389 break; 1390 1391 case Type::Typedef: 1392 case Type::Decltype: 1393 case Type::Auto: 1394 // Stop walking: nothing to do. 1395 return; 1396 1397 case Type::TypeOfExpr: 1398 // Stop walking: emit typeof expression. 1399 EmitIgnoredExpr(cast<TypeOfExprType>(ty)->getUnderlyingExpr()); 1400 return; 1401 1402 case Type::Atomic: 1403 type = cast<AtomicType>(ty)->getValueType(); 1404 break; 1405 } 1406 } while (type->isVariablyModifiedType()); 1407} 1408 1409llvm::Value* CodeGenFunction::EmitVAListRef(const Expr* E) { 1410 if (getContext().getBuiltinVaListType()->isArrayType()) 1411 return EmitScalarExpr(E); 1412 return EmitLValue(E).getAddress(); 1413} 1414 1415void CodeGenFunction::EmitDeclRefExprDbgValue(const DeclRefExpr *E, 1416 llvm::Constant *Init) { 1417 assert (Init && "Invalid DeclRefExpr initializer!"); 1418 if (CGDebugInfo *Dbg = getDebugInfo()) 1419 if (CGM.getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) 1420 Dbg->EmitGlobalVariable(E->getDecl(), Init); 1421} 1422 1423CodeGenFunction::PeepholeProtection 1424CodeGenFunction::protectFromPeepholes(RValue rvalue) { 1425 // At the moment, the only aggressive peephole we do in IR gen 1426 // is trunc(zext) folding, but if we add more, we can easily 1427 // extend this protection. 1428 1429 if (!rvalue.isScalar()) return PeepholeProtection(); 1430 llvm::Value *value = rvalue.getScalarVal(); 1431 if (!isa<llvm::ZExtInst>(value)) return PeepholeProtection(); 1432 1433 // Just make an extra bitcast. 1434 assert(HaveInsertPoint()); 1435 llvm::Instruction *inst = new llvm::BitCastInst(value, value->getType(), "", 1436 Builder.GetInsertBlock()); 1437 1438 PeepholeProtection protection; 1439 protection.Inst = inst; 1440 return protection; 1441} 1442 1443void CodeGenFunction::unprotectFromPeepholes(PeepholeProtection protection) { 1444 if (!protection.Inst) return; 1445 1446 // In theory, we could try to duplicate the peepholes now, but whatever. 1447 protection.Inst->eraseFromParent(); 1448} 1449 1450llvm::Value *CodeGenFunction::EmitAnnotationCall(llvm::Value *AnnotationFn, 1451 llvm::Value *AnnotatedVal, 1452 StringRef AnnotationStr, 1453 SourceLocation Location) { 1454 llvm::Value *Args[4] = { 1455 AnnotatedVal, 1456 Builder.CreateBitCast(CGM.EmitAnnotationString(AnnotationStr), Int8PtrTy), 1457 Builder.CreateBitCast(CGM.EmitAnnotationUnit(Location), Int8PtrTy), 1458 CGM.EmitAnnotationLineNo(Location) 1459 }; 1460 return Builder.CreateCall(AnnotationFn, Args); 1461} 1462 1463void CodeGenFunction::EmitVarAnnotations(const VarDecl *D, llvm::Value *V) { 1464 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute"); 1465 // FIXME We create a new bitcast for every annotation because that's what 1466 // llvm-gcc was doing. 1467 for (specific_attr_iterator<AnnotateAttr> 1468 ai = D->specific_attr_begin<AnnotateAttr>(), 1469 ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai) 1470 EmitAnnotationCall(CGM.getIntrinsic(llvm::Intrinsic::var_annotation), 1471 Builder.CreateBitCast(V, CGM.Int8PtrTy, V->getName()), 1472 (*ai)->getAnnotation(), D->getLocation()); 1473} 1474 1475llvm::Value *CodeGenFunction::EmitFieldAnnotations(const FieldDecl *D, 1476 llvm::Value *V) { 1477 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute"); 1478 llvm::Type *VTy = V->getType(); 1479 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::ptr_annotation, 1480 CGM.Int8PtrTy); 1481 1482 for (specific_attr_iterator<AnnotateAttr> 1483 ai = D->specific_attr_begin<AnnotateAttr>(), 1484 ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai) { 1485 // FIXME Always emit the cast inst so we can differentiate between 1486 // annotation on the first field of a struct and annotation on the struct 1487 // itself. 1488 if (VTy != CGM.Int8PtrTy) 1489 V = Builder.Insert(new llvm::BitCastInst(V, CGM.Int8PtrTy)); 1490 V = EmitAnnotationCall(F, V, (*ai)->getAnnotation(), D->getLocation()); 1491 V = Builder.CreateBitCast(V, VTy); 1492 } 1493 1494 return V; 1495} 1496 1497CodeGenFunction::CGCapturedStmtInfo::~CGCapturedStmtInfo() { } 1498