contrib/llvm/tools/clang/lib/CodeGen/CodeGenFunction.cpp

   1 //===--- CodeGenFunction.cpp - Emit LLVM Code from ASTs for a Function ----===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This coordinates the per-function state used while generating code.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "CodeGenFunction.h"
  15 #include "CGBlocks.h"
  16 #include "CGCleanup.h"
  17 #include "CGCUDARuntime.h"
  18 #include "CGCXXABI.h"
  19 #include "CGDebugInfo.h"
  20 #include "CGOpenMPRuntime.h"
  21 #include "CodeGenModule.h"
  22 #include "CodeGenPGO.h"
  23 #include "TargetInfo.h"
  24 #include "clang/AST/ASTContext.h"
  25 #include "clang/AST/Decl.h"
  26 #include "clang/AST/DeclCXX.h"
  27 #include "clang/AST/StmtCXX.h"
  28 #include "clang/Basic/Builtins.h"
  29 #include "clang/Basic/TargetInfo.h"
  30 #include "clang/CodeGen/CGFunctionInfo.h"
  31 #include "clang/Frontend/CodeGenOptions.h"
  32 #include "clang/Sema/SemaDiagnostic.h"
  33 #include "llvm/IR/DataLayout.h"
  34 #include "llvm/IR/Intrinsics.h"
  35 #include "llvm/IR/MDBuilder.h"
  36 #include "llvm/IR/Operator.h"
  37 using namespace clang;
  38 using namespace CodeGen;
  39
  40 CodeGenFunction::CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext)
  41     : CodeGenTypeCache(cgm), CGM(cgm), Target(cgm.getTarget()),
  42       Builder(cgm, cgm.getModule().getContext(), llvm::ConstantFolder(),
  43               CGBuilderInserterTy(this)),
  44       CurFn(nullptr), ReturnValue(Address::invalid()),
  45       CapturedStmtInfo(nullptr),
  46       SanOpts(CGM.getLangOpts().Sanitize), IsSanitizerScope(false),
  47       CurFuncIsThunk(false), AutoreleaseResult(false), SawAsmBlock(false),
  48       IsOutlinedSEHHelper(false),
  49       BlockInfo(nullptr), BlockPointer(nullptr),
  50       LambdaThisCaptureField(nullptr), NormalCleanupDest(nullptr),
  51       NextCleanupDestIndex(1), FirstBlockInfo(nullptr), EHResumeBlock(nullptr),
  52       ExceptionSlot(nullptr), EHSelectorSlot(nullptr),
  53       DebugInfo(CGM.getModuleDebugInfo()),
  54       DisableDebugInfo(false), DidCallStackSave(false), IndirectBranch(nullptr),
  55       PGO(cgm), SwitchInsn(nullptr), SwitchWeights(nullptr),
  56       CaseRangeBlock(nullptr), UnreachableBlock(nullptr), NumReturnExprs(0),
  57       NumSimpleReturnExprs(0), CXXABIThisDecl(nullptr),
  58       CXXABIThisValue(nullptr), CXXThisValue(nullptr),
  59       CXXStructorImplicitParamDecl(nullptr),
  60       CXXStructorImplicitParamValue(nullptr), OutermostConditional(nullptr),
  61       CurLexicalScope(nullptr), TerminateLandingPad(nullptr),
  62       TerminateHandler(nullptr), TrapBB(nullptr) {
  63   if (!suppressNewContext)
  64     CGM.getCXXABI().getMangleContext().startNewFunction();
  65
  66   llvm::FastMathFlags FMF;
  67   if (CGM.getLangOpts().FastMath)
  68     FMF.setUnsafeAlgebra();
  69   if (CGM.getLangOpts().FiniteMathOnly) {
  70     FMF.setNoNaNs();
  71     FMF.setNoInfs();
  72   }
  73   if (CGM.getCodeGenOpts().NoNaNsFPMath) {
  74     FMF.setNoNaNs();
  75   }
  76   if (CGM.getCodeGenOpts().NoSignedZeros) {
  77     FMF.setNoSignedZeros();
  78   }
  79   if (CGM.getCodeGenOpts().ReciprocalMath) {
  80     FMF.setAllowReciprocal();
  81   }
  82   Builder.setFastMathFlags(FMF);
  83 }
  84
  85 CodeGenFunction::~CodeGenFunction() {
  86   assert(LifetimeExtendedCleanupStack.empty() && "failed to emit a cleanup");
  87
  88   // If there are any unclaimed block infos, go ahead and destroy them
  89   // now.  This can happen if IR-gen gets clever and skips evaluating
  90   // something.
  91   if (FirstBlockInfo)
  92     destroyBlockInfos(FirstBlockInfo);
  93
  94   if (getLangOpts().OpenMP) {
  95     CGM.getOpenMPRuntime().functionFinished(*this);
  96   }
  97 }
  98
  99 CharUnits CodeGenFunction::getNaturalPointeeTypeAlignment(QualType T,
 100                                                      AlignmentSource *Source) {
 101   return getNaturalTypeAlignment(T->getPointeeType(), Source,
 102                                  /*forPointee*/ true);
 103 }
 104
 105 CharUnits CodeGenFunction::getNaturalTypeAlignment(QualType T,
 106                                                    AlignmentSource *Source,
 107                                                    bool forPointeeType) {
 108   // Honor alignment typedef attributes even on incomplete types.
 109   // We also honor them straight for C++ class types, even as pointees;
 110   // there's an expressivity gap here.
 111   if (auto TT = T->getAs<TypedefType>()) {
 112     if (auto Align = TT->getDecl()->getMaxAlignment()) {
 113       if (Source) *Source = AlignmentSource::AttributedType;
 114       return getContext().toCharUnitsFromBits(Align);
 115     }
 116   }
 117
 118   if (Source) *Source = AlignmentSource::Type;
 119
 120   CharUnits Alignment;
 121   if (T->isIncompleteType()) {
 122     Alignment = CharUnits::One(); // Shouldn't be used, but pessimistic is best.
 123   } else {
 124     // For C++ class pointees, we don't know whether we're pointing at a
 125     // base or a complete object, so we generally need to use the
 126     // non-virtual alignment.
 127     const CXXRecordDecl *RD;
 128     if (forPointeeType && (RD = T->getAsCXXRecordDecl())) {
 129       Alignment = CGM.getClassPointerAlignment(RD);
 130     } else {
 131       Alignment = getContext().getTypeAlignInChars(T);
 132     }
 133
 134     // Cap to the global maximum type alignment unless the alignment
 135     // was somehow explicit on the type.
 136     if (unsigned MaxAlign = getLangOpts().MaxTypeAlign) {
 137       if (Alignment.getQuantity() > MaxAlign &&
 138           !getContext().isAlignmentRequired(T))
 139         Alignment = CharUnits::fromQuantity(MaxAlign);
 140     }
 141   }
 142   return Alignment;
 143 }
 144
 145 LValue CodeGenFunction::MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T) {
 146   AlignmentSource AlignSource;
 147   CharUnits Alignment = getNaturalTypeAlignment(T, &AlignSource);
 148   return LValue::MakeAddr(Address(V, Alignment), T, getContext(), AlignSource,
 149                           CGM.getTBAAInfo(T));
 150 }
 151
 152 /// Given a value of type T* that may not be to a complete object,
 153 /// construct an l-value with the natural pointee alignment of T.
 154 LValue
 155 CodeGenFunction::MakeNaturalAlignPointeeAddrLValue(llvm::Value *V, QualType T) {
 156   AlignmentSource AlignSource;
 157   CharUnits Align = getNaturalTypeAlignment(T, &AlignSource, /*pointee*/ true);
 158   return MakeAddrLValue(Address(V, Align), T, AlignSource);
 159 }
 160
 161
 162 llvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) {
 163   return CGM.getTypes().ConvertTypeForMem(T);
 164 }
 165
 166 llvm::Type *CodeGenFunction::ConvertType(QualType T) {
 167   return CGM.getTypes().ConvertType(T);
 168 }
 169
 170 TypeEvaluationKind CodeGenFunction::getEvaluationKind(QualType type) {
 171   type = type.getCanonicalType();
 172   while (true) {
 173     switch (type->getTypeClass()) {
 174 #define TYPE(name, parent)
 175 #define ABSTRACT_TYPE(name, parent)
 176 #define NON_CANONICAL_TYPE(name, parent) case Type::name:
 177 #define DEPENDENT_TYPE(name, parent) case Type::name:
 178 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(name, parent) case Type::name:
 179 #include "clang/AST/TypeNodes.def"
 180       llvm_unreachable("non-canonical or dependent type in IR-generation");
 181
 182     case Type::Auto:
 183       llvm_unreachable("undeduced auto type in IR-generation");
 184
 185     // Various scalar types.
 186     case Type::Builtin:
 187     case Type::Pointer:
 188     case Type::BlockPointer:
 189     case Type::LValueReference:
 190     case Type::RValueReference:
 191     case Type::MemberPointer:
 192     case Type::Vector:
 193     case Type::ExtVector:
 194     case Type::FunctionProto:
 195     case Type::FunctionNoProto:
 196     case Type::Enum:
 197     case Type::ObjCObjectPointer:
 198     case Type::Pipe:
 199       return TEK_Scalar;
 200
 201     // Complexes.
 202     case Type::Complex:
 203       return TEK_Complex;
 204
 205     // Arrays, records, and Objective-C objects.
 206     case Type::ConstantArray:
 207     case Type::IncompleteArray:
 208     case Type::VariableArray:
 209     case Type::Record:
 210     case Type::ObjCObject:
 211     case Type::ObjCInterface:
 212       return TEK_Aggregate;
 213
 214     // We operate on atomic values according to their underlying type.
 215     case Type::Atomic:
 216       type = cast<AtomicType>(type)->getValueType();
 217       continue;
 218     }
 219     llvm_unreachable("unknown type kind!");
 220   }
 221 }
 222
 223 llvm::DebugLoc CodeGenFunction::EmitReturnBlock() {
 224   // For cleanliness, we try to avoid emitting the return block for
 225   // simple cases.
 226   llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
 227
 228   if (CurBB) {
 229     assert(!CurBB->getTerminator() && "Unexpected terminated block.");
 230
 231     // We have a valid insert point, reuse it if it is empty or there are no
 232     // explicit jumps to the return block.
 233     if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) {
 234       ReturnBlock.getBlock()->replaceAllUsesWith(CurBB);
 235       delete ReturnBlock.getBlock();
 236     } else
 237       EmitBlock(ReturnBlock.getBlock());
 238     return llvm::DebugLoc();
 239   }
 240
 241   // Otherwise, if the return block is the target of a single direct
 242   // branch then we can just put the code in that block instead. This
 243   // cleans up functions which started with a unified return block.
 244   if (ReturnBlock.getBlock()->hasOneUse()) {
 245     llvm::BranchInst *BI =
 246       dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->user_begin());
 247     if (BI && BI->isUnconditional() &&
 248         BI->getSuccessor(0) == ReturnBlock.getBlock()) {
 249       // Record/return the DebugLoc of the simple 'return' expression to be used
 250       // later by the actual 'ret' instruction.
 251       llvm::DebugLoc Loc = BI->getDebugLoc();
 252       Builder.SetInsertPoint(BI->getParent());
 253       BI->eraseFromParent();
 254       delete ReturnBlock.getBlock();
 255       return Loc;
 256     }
 257   }
 258
 259   // FIXME: We are at an unreachable point, there is no reason to emit the block
 260   // unless it has uses. However, we still need a place to put the debug
 261   // region.end for now.
 262
 263   EmitBlock(ReturnBlock.getBlock());
 264   return llvm::DebugLoc();
 265 }
 266
 267 static void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) {
 268   if (!BB) return;
 269   if (!BB->use_empty())
 270     return CGF.CurFn->getBasicBlockList().push_back(BB);
 271   delete BB;
 272 }
 273
 274 void CodeGenFunction::FinishFunction(SourceLocation EndLoc) {
 275   assert(BreakContinueStack.empty() &&
 276          "mismatched push/pop in break/continue stack!");
 277
 278   bool OnlySimpleReturnStmts = NumSimpleReturnExprs > 0
 279     && NumSimpleReturnExprs == NumReturnExprs
 280     && ReturnBlock.getBlock()->use_empty();
 281   // Usually the return expression is evaluated before the cleanup
 282   // code.  If the function contains only a simple return statement,
 283   // such as a constant, the location before the cleanup code becomes
 284   // the last useful breakpoint in the function, because the simple
 285   // return expression will be evaluated after the cleanup code. To be
 286   // safe, set the debug location for cleanup code to the location of
 287   // the return statement.  Otherwise the cleanup code should be at the
 288   // end of the function's lexical scope.
 289   //
 290   // If there are multiple branches to the return block, the branch
 291   // instructions will get the location of the return statements and
 292   // all will be fine.
 293   if (CGDebugInfo *DI = getDebugInfo()) {
 294     if (OnlySimpleReturnStmts)
 295       DI->EmitLocation(Builder, LastStopPoint);
 296     else
 297       DI->EmitLocation(Builder, EndLoc);
 298   }
 299
 300   // Pop any cleanups that might have been associated with the
 301   // parameters.  Do this in whatever block we're currently in; it's
 302   // important to do this before we enter the return block or return
 303   // edges will be *really* confused.
 304   bool HasCleanups = EHStack.stable_begin() != PrologueCleanupDepth;
 305   bool HasOnlyLifetimeMarkers =
 306       HasCleanups && EHStack.containsOnlyLifetimeMarkers(PrologueCleanupDepth);
 307   bool EmitRetDbgLoc = !HasCleanups || HasOnlyLifetimeMarkers;
 308   if (HasCleanups) {
 309     // Make sure the line table doesn't jump back into the body for
 310     // the ret after it's been at EndLoc.
 311     if (CGDebugInfo *DI = getDebugInfo())
 312       if (OnlySimpleReturnStmts)
 313         DI->EmitLocation(Builder, EndLoc);
 314
 315     PopCleanupBlocks(PrologueCleanupDepth);
 316   }
 317
 318   // Emit function epilog (to return).
 319   llvm::DebugLoc Loc = EmitReturnBlock();
 320
 321   if (ShouldInstrumentFunction())
 322     EmitFunctionInstrumentation("__cyg_profile_func_exit");
 323
 324   // Emit debug descriptor for function end.
 325   if (CGDebugInfo *DI = getDebugInfo())
 326     DI->EmitFunctionEnd(Builder);
 327
 328   // Reset the debug location to that of the simple 'return' expression, if any
 329   // rather than that of the end of the function's scope '}'.
 330   ApplyDebugLocation AL(*this, Loc);
 331   EmitFunctionEpilog(*CurFnInfo, EmitRetDbgLoc, EndLoc);
 332   EmitEndEHSpec(CurCodeDecl);
 333
 334   assert(EHStack.empty() &&
 335          "did not remove all scopes from cleanup stack!");
 336
 337   // If someone did an indirect goto, emit the indirect goto block at the end of
 338   // the function.
 339   if (IndirectBranch) {
 340     EmitBlock(IndirectBranch->getParent());
 341     Builder.ClearInsertionPoint();
 342   }
 343
 344   // If some of our locals escaped, insert a call to llvm.localescape in the
 345   // entry block.
 346   if (!EscapedLocals.empty()) {
 347     // Invert the map from local to index into a simple vector. There should be
 348     // no holes.
 349     SmallVector<llvm::Value *, 4> EscapeArgs;
 350     EscapeArgs.resize(EscapedLocals.size());
 351     for (auto &Pair : EscapedLocals)
 352       EscapeArgs[Pair.second] = Pair.first;
 353     llvm::Function *FrameEscapeFn = llvm::Intrinsic::getDeclaration(
 354         &CGM.getModule(), llvm::Intrinsic::localescape);
 355     CGBuilderTy(*this, AllocaInsertPt).CreateCall(FrameEscapeFn, EscapeArgs);
 356   }
 357
 358   // Remove the AllocaInsertPt instruction, which is just a convenience for us.
 359   llvm::Instruction *Ptr = AllocaInsertPt;
 360   AllocaInsertPt = nullptr;
 361   Ptr->eraseFromParent();
 362
 363   // If someone took the address of a label but never did an indirect goto, we
 364   // made a zero entry PHI node, which is illegal, zap it now.
 365   if (IndirectBranch) {
 366     llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress());
 367     if (PN->getNumIncomingValues() == 0) {
 368       PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType()));
 369       PN->eraseFromParent();
 370     }
 371   }
 372
 373   EmitIfUsed(*this, EHResumeBlock);
 374   EmitIfUsed(*this, TerminateLandingPad);
 375   EmitIfUsed(*this, TerminateHandler);
 376   EmitIfUsed(*this, UnreachableBlock);
 377
 378   if (CGM.getCodeGenOpts().EmitDeclMetadata)
 379     EmitDeclMetadata();
 380
 381   for (SmallVectorImpl<std::pair<llvm::Instruction *, llvm::Value *> >::iterator
 382            I = DeferredReplacements.begin(),
 383            E = DeferredReplacements.end();
 384        I != E; ++I) {
 385     I->first->replaceAllUsesWith(I->second);
 386     I->first->eraseFromParent();
 387   }
 388 }
 389
 390 /// ShouldInstrumentFunction - Return true if the current function should be
 391 /// instrumented with __cyg_profile_func_* calls
 392 bool CodeGenFunction::ShouldInstrumentFunction() {
 393   if (!CGM.getCodeGenOpts().InstrumentFunctions)
 394     return false;
 395   if (!CurFuncDecl || CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>())
 396     return false;
 397   return true;
 398 }
 399
 400 /// EmitFunctionInstrumentation - Emit LLVM code to call the specified
 401 /// instrumentation function with the current function and the call site, if
 402 /// function instrumentation is enabled.
 403 void CodeGenFunction::EmitFunctionInstrumentation(const char *Fn) {
 404   // void __cyg_profile_func_{enter,exit} (void *this_fn, void *call_site);
 405   llvm::PointerType *PointerTy = Int8PtrTy;
 406   llvm::Type *ProfileFuncArgs[] = { PointerTy, PointerTy };
 407   llvm::FunctionType *FunctionTy =
 408     llvm::FunctionType::get(VoidTy, ProfileFuncArgs, false);
 409
 410   llvm::Constant *F = CGM.CreateRuntimeFunction(FunctionTy, Fn);
 411   llvm::CallInst *CallSite = Builder.CreateCall(
 412     CGM.getIntrinsic(llvm::Intrinsic::returnaddress),
 413     llvm::ConstantInt::get(Int32Ty, 0),
 414     "callsite");
 415
 416   llvm::Value *args[] = {
 417     llvm::ConstantExpr::getBitCast(CurFn, PointerTy),
 418     CallSite
 419   };
 420
 421   EmitNounwindRuntimeCall(F, args);
 422 }
 423
 424 void CodeGenFunction::EmitMCountInstrumentation() {
 425   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
 426
 427   llvm::Constant *MCountFn =
 428     CGM.CreateRuntimeFunction(FTy, getTarget().getMCountName());
 429   EmitNounwindRuntimeCall(MCountFn);
 430 }
 431
 432 // OpenCL v1.2 s5.6.4.6 allows the compiler to store kernel argument
 433 // information in the program executable. The argument information stored
 434 // includes the argument name, its type, the address and access qualifiers used.
 435 static void GenOpenCLArgMetadata(const FunctionDecl *FD, llvm::Function *Fn,
 436                                  CodeGenModule &CGM, llvm::LLVMContext &Context,
 437                                  SmallVector<llvm::Metadata *, 5> &kernelMDArgs,
 438                                  CGBuilderTy &Builder, ASTContext &ASTCtx) {
 439   // Create MDNodes that represent the kernel arg metadata.
 440   // Each MDNode is a list in the form of "key", N number of values which is
 441   // the same number of values as their are kernel arguments.
 442
 443   const PrintingPolicy &Policy = ASTCtx.getPrintingPolicy();
 444
 445   // MDNode for the kernel argument address space qualifiers.
 446   SmallVector<llvm::Metadata *, 8> addressQuals;
 447   addressQuals.push_back(llvm::MDString::get(Context, "kernel_arg_addr_space"));
 448
 449   // MDNode for the kernel argument access qualifiers (images only).
 450   SmallVector<llvm::Metadata *, 8> accessQuals;
 451   accessQuals.push_back(llvm::MDString::get(Context, "kernel_arg_access_qual"));
 452
 453   // MDNode for the kernel argument type names.
 454   SmallVector<llvm::Metadata *, 8> argTypeNames;
 455   argTypeNames.push_back(llvm::MDString::get(Context, "kernel_arg_type"));
 456
 457   // MDNode for the kernel argument base type names.
 458   SmallVector<llvm::Metadata *, 8> argBaseTypeNames;
 459   argBaseTypeNames.push_back(
 460       llvm::MDString::get(Context, "kernel_arg_base_type"));
 461
 462   // MDNode for the kernel argument type qualifiers.
 463   SmallVector<llvm::Metadata *, 8> argTypeQuals;
 464   argTypeQuals.push_back(llvm::MDString::get(Context, "kernel_arg_type_qual"));
 465
 466   // MDNode for the kernel argument names.
 467   SmallVector<llvm::Metadata *, 8> argNames;
 468   argNames.push_back(llvm::MDString::get(Context, "kernel_arg_name"));
 469
 470   for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) {
 471     const ParmVarDecl *parm = FD->getParamDecl(i);
 472     QualType ty = parm->getType();
 473     std::string typeQuals;
 474
 475     if (ty->isPointerType()) {
 476       QualType pointeeTy = ty->getPointeeType();
 477
 478       // Get address qualifier.
 479       addressQuals.push_back(llvm::ConstantAsMetadata::get(Builder.getInt32(
 480           ASTCtx.getTargetAddressSpace(pointeeTy.getAddressSpace()))));
 481
 482       // Get argument type name.
 483       std::string typeName =
 484           pointeeTy.getUnqualifiedType().getAsString(Policy) + "*";
 485
 486       // Turn "unsigned type" to "utype"
 487       std::string::size_type pos = typeName.find("unsigned");
 488       if (pointeeTy.isCanonical() && pos != std::string::npos)
 489         typeName.erase(pos+1, 8);
 490
 491       argTypeNames.push_back(llvm::MDString::get(Context, typeName));
 492
 493       std::string baseTypeName =
 494           pointeeTy.getUnqualifiedType().getCanonicalType().getAsString(
 495               Policy) +
 496           "*";
 497
 498       // Turn "unsigned type" to "utype"
 499       pos = baseTypeName.find("unsigned");
 500       if (pos != std::string::npos)
 501         baseTypeName.erase(pos+1, 8);
 502
 503       argBaseTypeNames.push_back(llvm::MDString::get(Context, baseTypeName));
 504
 505       // Get argument type qualifiers:
 506       if (ty.isRestrictQualified())
 507         typeQuals = "restrict";
 508       if (pointeeTy.isConstQualified() ||
 509           (pointeeTy.getAddressSpace() == LangAS::opencl_constant))
 510         typeQuals += typeQuals.empty() ? "const" : " const";
 511       if (pointeeTy.isVolatileQualified())
 512         typeQuals += typeQuals.empty() ? "volatile" : " volatile";
 513     } else {
 514       uint32_t AddrSpc = 0;
 515       bool isPipe = ty->isPipeType();
 516       if (ty->isImageType() || isPipe)
 517         AddrSpc =
 518           CGM.getContext().getTargetAddressSpace(LangAS::opencl_global);
 519
 520       addressQuals.push_back(
 521           llvm::ConstantAsMetadata::get(Builder.getInt32(AddrSpc)));
 522
 523       // Get argument type name.
 524       std::string typeName;
 525       if (isPipe)
 526         typeName = cast<PipeType>(ty)->getElementType().getAsString(Policy);
 527       else
 528         typeName = ty.getUnqualifiedType().getAsString(Policy);
 529
 530       // Turn "unsigned type" to "utype"
 531       std::string::size_type pos = typeName.find("unsigned");
 532       if (ty.isCanonical() && pos != std::string::npos)
 533         typeName.erase(pos+1, 8);
 534
 535       argTypeNames.push_back(llvm::MDString::get(Context, typeName));
 536
 537       std::string baseTypeName;
 538       if (isPipe)
 539         baseTypeName =
 540           cast<PipeType>(ty)->getElementType().getCanonicalType().getAsString(Policy);
 541       else
 542         baseTypeName =
 543           ty.getUnqualifiedType().getCanonicalType().getAsString(Policy);
 544
 545       // Turn "unsigned type" to "utype"
 546       pos = baseTypeName.find("unsigned");
 547       if (pos != std::string::npos)
 548         baseTypeName.erase(pos+1, 8);
 549
 550       argBaseTypeNames.push_back(llvm::MDString::get(Context, baseTypeName));
 551
 552       // Get argument type qualifiers:
 553       if (ty.isConstQualified())
 554         typeQuals = "const";
 555       if (ty.isVolatileQualified())
 556         typeQuals += typeQuals.empty() ? "volatile" : " volatile";
 557       if (isPipe)
 558         typeQuals = "pipe";
 559     }
 560
 561     argTypeQuals.push_back(llvm::MDString::get(Context, typeQuals));
 562
 563     // Get image and pipe access qualifier:
 564     // FIXME: now image and pipe share the same access qualifier maybe we can
 565     // refine it to OpenCL access qualifier and also handle write_read
 566     if (ty->isImageType()|| ty->isPipeType()) {
 567       const OpenCLImageAccessAttr *A = parm->getAttr<OpenCLImageAccessAttr>();
 568       if (A && A->isWriteOnly())
 569         accessQuals.push_back(llvm::MDString::get(Context, "write_only"));
 570       else
 571         accessQuals.push_back(llvm::MDString::get(Context, "read_only"));
 572       // FIXME: what about read_write?
 573     } else
 574       accessQuals.push_back(llvm::MDString::get(Context, "none"));
 575
 576     // Get argument name.
 577     argNames.push_back(llvm::MDString::get(Context, parm->getName()));
 578   }
 579
 580   kernelMDArgs.push_back(llvm::MDNode::get(Context, addressQuals));
 581   kernelMDArgs.push_back(llvm::MDNode::get(Context, accessQuals));
 582   kernelMDArgs.push_back(llvm::MDNode::get(Context, argTypeNames));
 583   kernelMDArgs.push_back(llvm::MDNode::get(Context, argBaseTypeNames));
 584   kernelMDArgs.push_back(llvm::MDNode::get(Context, argTypeQuals));
 585   if (CGM.getCodeGenOpts().EmitOpenCLArgMetadata)
 586     kernelMDArgs.push_back(llvm::MDNode::get(Context, argNames));
 587 }
 588
 589 void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,
 590                                                llvm::Function *Fn)
 591 {
 592   if (!FD->hasAttr<OpenCLKernelAttr>())
 593     return;
 594
 595   llvm::LLVMContext &Context = getLLVMContext();
 596
 597   SmallVector<llvm::Metadata *, 5> kernelMDArgs;
 598   kernelMDArgs.push_back(llvm::ConstantAsMetadata::get(Fn));
 599
 600   GenOpenCLArgMetadata(FD, Fn, CGM, Context, kernelMDArgs, Builder,
 601                        getContext());
 602
 603   if (const VecTypeHintAttr *A = FD->getAttr<VecTypeHintAttr>()) {
 604     QualType hintQTy = A->getTypeHint();
 605     const ExtVectorType *hintEltQTy = hintQTy->getAs<ExtVectorType>();
 606     bool isSignedInteger =
 607         hintQTy->isSignedIntegerType() ||
 608         (hintEltQTy && hintEltQTy->getElementType()->isSignedIntegerType());
 609     llvm::Metadata *attrMDArgs[] = {
 610         llvm::MDString::get(Context, "vec_type_hint"),
 611         llvm::ConstantAsMetadata::get(llvm::UndefValue::get(
 612             CGM.getTypes().ConvertType(A->getTypeHint()))),
 613         llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
 614             llvm::IntegerType::get(Context, 32),
 615             llvm::APInt(32, (uint64_t)(isSignedInteger ? 1 : 0))))};
 616     kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs));
 617   }
 618
 619   if (const WorkGroupSizeHintAttr *A = FD->getAttr<WorkGroupSizeHintAttr>()) {
 620     llvm::Metadata *attrMDArgs[] = {
 621         llvm::MDString::get(Context, "work_group_size_hint"),
 622         llvm::ConstantAsMetadata::get(Builder.getInt32(A->getXDim())),
 623         llvm::ConstantAsMetadata::get(Builder.getInt32(A->getYDim())),
 624         llvm::ConstantAsMetadata::get(Builder.getInt32(A->getZDim()))};
 625     kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs));
 626   }
 627
 628   if (const ReqdWorkGroupSizeAttr *A = FD->getAttr<ReqdWorkGroupSizeAttr>()) {
 629     llvm::Metadata *attrMDArgs[] = {
 630         llvm::MDString::get(Context, "reqd_work_group_size"),
 631         llvm::ConstantAsMetadata::get(Builder.getInt32(A->getXDim())),
 632         llvm::ConstantAsMetadata::get(Builder.getInt32(A->getYDim())),
 633         llvm::ConstantAsMetadata::get(Builder.getInt32(A->getZDim()))};
 634     kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs));
 635   }
 636
 637   llvm::MDNode *kernelMDNode = llvm::MDNode::get(Context, kernelMDArgs);
 638   llvm::NamedMDNode *OpenCLKernelMetadata =
 639     CGM.getModule().getOrInsertNamedMetadata("opencl.kernels");
 640   OpenCLKernelMetadata->addOperand(kernelMDNode);
 641 }
 642
 643 /// Determine whether the function F ends with a return stmt.
 644 static bool endsWithReturn(const Decl* F) {
 645   const Stmt *Body = nullptr;
 646   if (auto *FD = dyn_cast_or_null<FunctionDecl>(F))
 647     Body = FD->getBody();
 648   else if (auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(F))
 649     Body = OMD->getBody();
 650
 651   if (auto *CS = dyn_cast_or_null<CompoundStmt>(Body)) {
 652     auto LastStmt = CS->body_rbegin();
 653     if (LastStmt != CS->body_rend())
 654       return isa<ReturnStmt>(*LastStmt);
 655   }
 656   return false;
 657 }
 658
 659 void CodeGenFunction::StartFunction(GlobalDecl GD,
 660                                     QualType RetTy,
 661                                     llvm::Function *Fn,
 662                                     const CGFunctionInfo &FnInfo,
 663                                     const FunctionArgList &Args,
 664                                     SourceLocation Loc,
 665                                     SourceLocation StartLoc) {
 666   assert(!CurFn &&
 667          "Do not use a CodeGenFunction object for more than one function");
 668
 669   const Decl *D = GD.getDecl();
 670
 671   DidCallStackSave = false;
 672   CurCodeDecl = D;
 673   CurFuncDecl = (D ? D->getNonClosureContext() : nullptr);
 674   FnRetTy = RetTy;
 675   CurFn = Fn;
 676   CurFnInfo = &FnInfo;
 677   assert(CurFn->isDeclaration() && "Function already has body?");
 678
 679   if (CGM.isInSanitizerBlacklist(Fn, Loc))
 680     SanOpts.clear();
 681
 682   if (D) {
 683     // Apply the no_sanitize* attributes to SanOpts.
 684     for (auto Attr : D->specific_attrs<NoSanitizeAttr>())
 685       SanOpts.Mask &= ~Attr->getMask();
 686   }
 687
 688   // Apply sanitizer attributes to the function.
 689   if (SanOpts.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress))
 690     Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
 691   if (SanOpts.has(SanitizerKind::Thread))
 692     Fn->addFnAttr(llvm::Attribute::SanitizeThread);
 693   if (SanOpts.has(SanitizerKind::Memory))
 694     Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
 695   if (SanOpts.has(SanitizerKind::SafeStack))
 696     Fn->addFnAttr(llvm::Attribute::SafeStack);
 697
 698   // Pass inline keyword to optimizer if it appears explicitly on any
 699   // declaration. Also, in the case of -fno-inline attach NoInline
 700   // attribute to all function that are not marked AlwaysInline.
 701   if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
 702     if (!CGM.getCodeGenOpts().NoInline) {
 703       for (auto RI : FD->redecls())
 704         if (RI->isInlineSpecified()) {
 705           Fn->addFnAttr(llvm::Attribute::InlineHint);
 706           break;
 707         }
 708     } else if (!FD->hasAttr<AlwaysInlineAttr>())
 709       Fn->addFnAttr(llvm::Attribute::NoInline);
 710   }
 711
 712   if (getLangOpts().OpenCL) {
 713     // Add metadata for a kernel function.
 714     if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
 715       EmitOpenCLKernelMetadata(FD, Fn);
 716   }
 717
 718   // If we are checking function types, emit a function type signature as
 719   // prologue data.
 720   if (getLangOpts().CPlusPlus && SanOpts.has(SanitizerKind::Function)) {
 721     if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
 722       if (llvm::Constant *PrologueSig =
 723               CGM.getTargetCodeGenInfo().getUBSanFunctionSignature(CGM)) {
 724         llvm::Constant *FTRTTIConst =
 725             CGM.GetAddrOfRTTIDescriptor(FD->getType(), /*ForEH=*/true);
 726         llvm::Constant *PrologueStructElems[] = { PrologueSig, FTRTTIConst };
 727         llvm::Constant *PrologueStructConst =
 728             llvm::ConstantStruct::getAnon(PrologueStructElems, /*Packed=*/true);
 729         Fn->setPrologueData(PrologueStructConst);
 730       }
 731     }
 732   }
 733
 734   // If we're in C++ mode and the function name is "main", it is guaranteed
 735   // to be norecurse by the standard (3.6.1.3 "The function main shall not be
 736   // used within a program").
 737   if (getLangOpts().CPlusPlus)
 738     if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
 739       if (FD->isMain())
 740         Fn->addFnAttr(llvm::Attribute::NoRecurse);
 741
 742   llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn);
 743
 744   // Create a marker to make it easy to insert allocas into the entryblock
 745   // later.  Don't create this with the builder, because we don't want it
 746   // folded.
 747   llvm::Value *Undef = llvm::UndefValue::get(Int32Ty);
 748   AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "", EntryBB);
 749   if (Builder.isNamePreserving())
 750     AllocaInsertPt->setName("allocapt");
 751
 752   ReturnBlock = getJumpDestInCurrentScope("return");
 753
 754   Builder.SetInsertPoint(EntryBB);
 755
 756   // Emit subprogram debug descriptor.
 757   if (CGDebugInfo *DI = getDebugInfo()) {
 758     SmallVector<QualType, 16> ArgTypes;
 759     for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
 760          i != e; ++i) {
 761       ArgTypes.push_back((*i)->getType());
 762     }
 763
 764     QualType FnType =
 765       getContext().getFunctionType(RetTy, ArgTypes,
 766                                    FunctionProtoType::ExtProtoInfo());
 767     DI->EmitFunctionStart(GD, Loc, StartLoc, FnType, CurFn, Builder);
 768   }
 769
 770   if (ShouldInstrumentFunction())
 771     EmitFunctionInstrumentation("__cyg_profile_func_enter");
 772
 773   if (CGM.getCodeGenOpts().InstrumentForProfiling)
 774     EmitMCountInstrumentation();
 775
 776   if (RetTy->isVoidType()) {
 777     // Void type; nothing to return.
 778     ReturnValue = Address::invalid();
 779
 780     // Count the implicit return.
 781     if (!endsWithReturn(D))
 782       ++NumReturnExprs;
 783   } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect &&
 784              !hasScalarEvaluationKind(CurFnInfo->getReturnType())) {
 785     // Indirect aggregate return; emit returned value directly into sret slot.
 786     // This reduces code size, and affects correctness in C++.
 787     auto AI = CurFn->arg_begin();
 788     if (CurFnInfo->getReturnInfo().isSRetAfterThis())
 789       ++AI;
 790     ReturnValue = Address(&*AI, CurFnInfo->getReturnInfo().getIndirectAlign());
 791   } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::InAlloca &&
 792              !hasScalarEvaluationKind(CurFnInfo->getReturnType())) {
 793     // Load the sret pointer from the argument struct and return into that.
 794     unsigned Idx = CurFnInfo->getReturnInfo().getInAllocaFieldIndex();
 795     llvm::Function::arg_iterator EI = CurFn->arg_end();
 796     --EI;
 797     llvm::Value *Addr = Builder.CreateStructGEP(nullptr, &*EI, Idx);
 798     Addr = Builder.CreateAlignedLoad(Addr, getPointerAlign(), "agg.result");
 799     ReturnValue = Address(Addr, getNaturalTypeAlignment(RetTy));
 800   } else {
 801     ReturnValue = CreateIRTemp(RetTy, "retval");
 802
 803     // Tell the epilog emitter to autorelease the result.  We do this
 804     // now so that various specialized functions can suppress it
 805     // during their IR-generation.
 806     if (getLangOpts().ObjCAutoRefCount &&
 807         !CurFnInfo->isReturnsRetained() &&
 808         RetTy->isObjCRetainableType())
 809       AutoreleaseResult = true;
 810   }
 811
 812   EmitStartEHSpec(CurCodeDecl);
 813
 814   PrologueCleanupDepth = EHStack.stable_begin();
 815   EmitFunctionProlog(*CurFnInfo, CurFn, Args);
 816
 817   if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) {
 818     CGM.getCXXABI().EmitInstanceFunctionProlog(*this);
 819     const CXXMethodDecl *MD = cast<CXXMethodDecl>(D);
 820     if (MD->getParent()->isLambda() &&
 821         MD->getOverloadedOperator() == OO_Call) {
 822       // We're in a lambda; figure out the captures.
 823       MD->getParent()->getCaptureFields(LambdaCaptureFields,
 824                                         LambdaThisCaptureField);
 825       if (LambdaThisCaptureField) {
 826         // If this lambda captures this, load it.
 827         LValue ThisLValue = EmitLValueForLambdaField(LambdaThisCaptureField);
 828         CXXThisValue = EmitLoadOfLValue(ThisLValue,
 829                                         SourceLocation()).getScalarVal();
 830       }
 831       for (auto *FD : MD->getParent()->fields()) {
 832         if (FD->hasCapturedVLAType()) {
 833           auto *ExprArg = EmitLoadOfLValue(EmitLValueForLambdaField(FD),
 834                                            SourceLocation()).getScalarVal();
 835           auto VAT = FD->getCapturedVLAType();
 836           VLASizeMap[VAT->getSizeExpr()] = ExprArg;
 837         }
 838       }
 839     } else {
 840       // Not in a lambda; just use 'this' from the method.
 841       // FIXME: Should we generate a new load for each use of 'this'?  The
 842       // fast register allocator would be happier...
 843       CXXThisValue = CXXABIThisValue;
 844     }
 845   }
 846
 847   // If any of the arguments have a variably modified type, make sure to
 848   // emit the type size.
 849   for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
 850        i != e; ++i) {
 851     const VarDecl *VD = *i;
 852
 853     // Dig out the type as written from ParmVarDecls; it's unclear whether
 854     // the standard (C99 6.9.1p10) requires this, but we're following the
 855     // precedent set by gcc.
 856     QualType Ty;
 857     if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD))
 858       Ty = PVD->getOriginalType();
 859     else
 860       Ty = VD->getType();
 861
 862     if (Ty->isVariablyModifiedType())
 863       EmitVariablyModifiedType(Ty);
 864   }
 865   // Emit a location at the end of the prologue.
 866   if (CGDebugInfo *DI = getDebugInfo())
 867     DI->EmitLocation(Builder, StartLoc);
 868 }
 869
 870 void CodeGenFunction::EmitFunctionBody(FunctionArgList &Args,
 871                                        const Stmt *Body) {
 872   incrementProfileCounter(Body);
 873   if (const CompoundStmt *S = dyn_cast<CompoundStmt>(Body))
 874     EmitCompoundStmtWithoutScope(*S);
 875   else
 876     EmitStmt(Body);
 877 }
 878
 879 /// When instrumenting to collect profile data, the counts for some blocks
 880 /// such as switch cases need to not include the fall-through counts, so
 881 /// emit a branch around the instrumentation code. When not instrumenting,
 882 /// this just calls EmitBlock().
 883 void CodeGenFunction::EmitBlockWithFallThrough(llvm::BasicBlock *BB,
 884                                                const Stmt *S) {
 885   llvm::BasicBlock *SkipCountBB = nullptr;
 886   if (HaveInsertPoint() && CGM.getCodeGenOpts().ProfileInstrGenerate) {
 887     // When instrumenting for profiling, the fallthrough to certain
 888     // statements needs to skip over the instrumentation code so that we
 889     // get an accurate count.
 890     SkipCountBB = createBasicBlock("skipcount");
 891     EmitBranch(SkipCountBB);
 892   }
 893   EmitBlock(BB);
 894   uint64_t CurrentCount = getCurrentProfileCount();
 895   incrementProfileCounter(S);
 896   setCurrentProfileCount(getCurrentProfileCount() + CurrentCount);
 897   if (SkipCountBB)
 898     EmitBlock(SkipCountBB);
 899 }
 900
 901 /// Tries to mark the given function nounwind based on the
 902 /// non-existence of any throwing calls within it.  We believe this is
 903 /// lightweight enough to do at -O0.
 904 static void TryMarkNoThrow(llvm::Function *F) {
 905   // LLVM treats 'nounwind' on a function as part of the type, so we
 906   // can't do this on functions that can be overwritten.
 907   if (F->mayBeOverridden()) return;
 908
 909   for (llvm::BasicBlock &BB : *F)
 910     for (llvm::Instruction &I : BB)
 911       if (I.mayThrow())
 912         return;
 913
 914   F->setDoesNotThrow();
 915 }
 916
 917 void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn,
 918                                    const CGFunctionInfo &FnInfo) {
 919   const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
 920
 921   // Check if we should generate debug info for this function.
 922   if (FD->hasAttr<NoDebugAttr>())
 923     DebugInfo = nullptr; // disable debug info indefinitely for this function
 924
 925   FunctionArgList Args;
 926   QualType ResTy = FD->getReturnType();
 927
 928   CurGD = GD;
 929   const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
 930   if (MD && MD->isInstance()) {
 931     if (CGM.getCXXABI().HasThisReturn(GD))
 932       ResTy = MD->getThisType(getContext());
 933     else if (CGM.getCXXABI().hasMostDerivedReturn(GD))
 934       ResTy = CGM.getContext().VoidPtrTy;
 935     CGM.getCXXABI().buildThisParam(*this, Args);
 936   }
 937
 938   for (auto *Param : FD->params()) {
 939     Args.push_back(Param);
 940     if (!Param->hasAttr<PassObjectSizeAttr>())
 941       continue;
 942
 943     IdentifierInfo *NoID = nullptr;
 944     auto *Implicit = ImplicitParamDecl::Create(
 945         getContext(), Param->getDeclContext(), Param->getLocation(), NoID,
 946         getContext().getSizeType());
 947     SizeArguments[Param] = Implicit;
 948     Args.push_back(Implicit);
 949   }
 950
 951   if (MD && (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)))
 952     CGM.getCXXABI().addImplicitStructorParams(*this, ResTy, Args);
 953
 954   SourceRange BodyRange;
 955   if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange();
 956   CurEHLocation = BodyRange.getEnd();
 957
 958   // Use the location of the start of the function to determine where
 959   // the function definition is located. By default use the location
 960   // of the declaration as the location for the subprogram. A function
 961   // may lack a declaration in the source code if it is created by code
 962   // gen. (examples: _GLOBAL__I_a, __cxx_global_array_dtor, thunk).
 963   SourceLocation Loc = FD->getLocation();
 964
 965   // If this is a function specialization then use the pattern body
 966   // as the location for the function.
 967   if (const FunctionDecl *SpecDecl = FD->getTemplateInstantiationPattern())
 968     if (SpecDecl->hasBody(SpecDecl))
 969       Loc = SpecDecl->getLocation();
 970
 971   // Emit the standard function prologue.
 972   StartFunction(GD, ResTy, Fn, FnInfo, Args, Loc, BodyRange.getBegin());
 973
 974   // Generate the body of the function.
 975   PGO.assignRegionCounters(GD, CurFn);
 976   if (isa<CXXDestructorDecl>(FD))
 977     EmitDestructorBody(Args);
 978   else if (isa<CXXConstructorDecl>(FD))
 979     EmitConstructorBody(Args);
 980   else if (getLangOpts().CUDA &&
 981            !getLangOpts().CUDAIsDevice &&
 982            FD->hasAttr<CUDAGlobalAttr>())
 983     CGM.getCUDARuntime().emitDeviceStub(*this, Args);
 984   else if (isa<CXXConversionDecl>(FD) &&
 985            cast<CXXConversionDecl>(FD)->isLambdaToBlockPointerConversion()) {
 986     // The lambda conversion to block pointer is special; the semantics can't be
 987     // expressed in the AST, so IRGen needs to special-case it.
 988     EmitLambdaToBlockPointerBody(Args);
 989   } else if (isa<CXXMethodDecl>(FD) &&
 990              cast<CXXMethodDecl>(FD)->isLambdaStaticInvoker()) {
 991     // The lambda static invoker function is special, because it forwards or
 992     // clones the body of the function call operator (but is actually static).
 993     EmitLambdaStaticInvokeFunction(cast<CXXMethodDecl>(FD));
 994   } else if (FD->isDefaulted() && isa<CXXMethodDecl>(FD) &&
 995              (cast<CXXMethodDecl>(FD)->isCopyAssignmentOperator() ||
 996               cast<CXXMethodDecl>(FD)->isMoveAssignmentOperator())) {
 997     // Implicit copy-assignment gets the same special treatment as implicit
 998     // copy-constructors.
 999     emitImplicitAssignmentOperatorBody(Args);
1000   } else if (Stmt *Body = FD->getBody()) {
1001     EmitFunctionBody(Args, Body);
1002   } else
1003     llvm_unreachable("no definition for emitted function");
1004
1005   // C++11 [stmt.return]p2:
1006   //   Flowing off the end of a function [...] results in undefined behavior in
1007   //   a value-returning function.
1008   // C11 6.9.1p12:
1009   //   If the '}' that terminates a function is reached, and the value of the
1010   //   function call is used by the caller, the behavior is undefined.
1011   if (getLangOpts().CPlusPlus && !FD->hasImplicitReturnZero() && !SawAsmBlock &&
1012       !FD->getReturnType()->isVoidType() && Builder.GetInsertBlock()) {
1013     if (SanOpts.has(SanitizerKind::Return)) {
1014       SanitizerScope SanScope(this);
1015       llvm::Value *IsFalse = Builder.getFalse();
1016       EmitCheck(std::make_pair(IsFalse, SanitizerKind::Return),
1017                 "missing_return", EmitCheckSourceLocation(FD->getLocation()),
1018                 None);
1019     } else if (CGM.getCodeGenOpts().OptimizationLevel == 0) {
1020       EmitTrapCall(llvm::Intrinsic::trap);
1021     }
1022     Builder.CreateUnreachable();
1023     Builder.ClearInsertionPoint();
1024   }
1025
1026   // Emit the standard function epilogue.
1027   FinishFunction(BodyRange.getEnd());
1028
1029   // If we haven't marked the function nothrow through other means, do
1030   // a quick pass now to see if we can.
1031   if (!CurFn->doesNotThrow())
1032     TryMarkNoThrow(CurFn);
1033 }
1034
1035 /// ContainsLabel - Return true if the statement contains a label in it.  If
1036 /// this statement is not executed normally, it not containing a label means
1037 /// that we can just remove the code.
1038 bool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) {
1039   // Null statement, not a label!
1040   if (!S) return false;
1041
1042   // If this is a label, we have to emit the code, consider something like:
1043   // if (0) {  ...  foo:  bar(); }  goto foo;
1044   //
1045   // TODO: If anyone cared, we could track __label__'s, since we know that you
1046   // can't jump to one from outside their declared region.
1047   if (isa<LabelStmt>(S))
1048     return true;
1049
1050   // If this is a case/default statement, and we haven't seen a switch, we have
1051   // to emit the code.
1052   if (isa<SwitchCase>(S) && !IgnoreCaseStmts)
1053     return true;
1054
1055   // If this is a switch statement, we want to ignore cases below it.
1056   if (isa<SwitchStmt>(S))
1057     IgnoreCaseStmts = true;
1058
1059   // Scan subexpressions for verboten labels.
1060   for (const Stmt *SubStmt : S->children())
1061     if (ContainsLabel(SubStmt, IgnoreCaseStmts))
1062       return true;
1063
1064   return false;
1065 }
1066
1067 /// containsBreak - Return true if the statement contains a break out of it.
1068 /// If the statement (recursively) contains a switch or loop with a break
1069 /// inside of it, this is fine.
1070 bool CodeGenFunction::containsBreak(const Stmt *S) {
1071   // Null statement, not a label!
1072   if (!S) return false;
1073
1074   // If this is a switch or loop that defines its own break scope, then we can
1075   // include it and anything inside of it.
1076   if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || isa<DoStmt>(S) ||
1077       isa<ForStmt>(S))
1078     return false;
1079
1080   if (isa<BreakStmt>(S))
1081     return true;
1082
1083   // Scan subexpressions for verboten breaks.
1084   for (const Stmt *SubStmt : S->children())
1085     if (containsBreak(SubStmt))
1086       return true;
1087
1088   return false;
1089 }
1090
1091
1092 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
1093 /// to a constant, or if it does but contains a label, return false.  If it
1094 /// constant folds return true and set the boolean result in Result.
1095 bool CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond,
1096                                                    bool &ResultBool) {
1097   llvm::APSInt ResultInt;
1098   if (!ConstantFoldsToSimpleInteger(Cond, ResultInt))
1099     return false;
1100
1101   ResultBool = ResultInt.getBoolValue();
1102   return true;
1103 }
1104
1105 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
1106 /// to a constant, or if it does but contains a label, return false.  If it
1107 /// constant folds return true and set the folded value.
1108 bool CodeGenFunction::
1109 ConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APSInt &ResultInt) {
1110   // FIXME: Rename and handle conversion of other evaluatable things
1111   // to bool.
1112   llvm::APSInt Int;
1113   if (!Cond->EvaluateAsInt(Int, getContext()))
1114     return false;  // Not foldable, not integer or not fully evaluatable.
1115
1116   if (CodeGenFunction::ContainsLabel(Cond))
1117     return false;  // Contains a label.
1118
1119   ResultInt = Int;
1120   return true;
1121 }
1122
1123
1124
1125 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if
1126 /// statement) to the specified blocks.  Based on the condition, this might try
1127 /// to simplify the codegen of the conditional based on the branch.
1128 ///
1129 void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond,
1130                                            llvm::BasicBlock *TrueBlock,
1131                                            llvm::BasicBlock *FalseBlock,
1132                                            uint64_t TrueCount) {
1133   Cond = Cond->IgnoreParens();
1134
1135   if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) {
1136
1137     // Handle X && Y in a condition.
1138     if (CondBOp->getOpcode() == BO_LAnd) {
1139       // If we have "1 && X", simplify the code.  "0 && X" would have constant
1140       // folded if the case was simple enough.
1141       bool ConstantBool = false;
1142       if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) &&
1143           ConstantBool) {
1144         // br(1 && X) -> br(X).
1145         incrementProfileCounter(CondBOp);
1146         return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock,
1147                                     TrueCount);
1148       }
1149
1150       // If we have "X && 1", simplify the code to use an uncond branch.
1151       // "X && 0" would have been constant folded to 0.
1152       if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) &&
1153           ConstantBool) {
1154         // br(X && 1) -> br(X).
1155         return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock,
1156                                     TrueCount);
1157       }
1158
1159       // Emit the LHS as a conditional.  If the LHS conditional is false, we
1160       // want to jump to the FalseBlock.
1161       llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true");
1162       // The counter tells us how often we evaluate RHS, and all of TrueCount
1163       // can be propagated to that branch.
1164       uint64_t RHSCount = getProfileCount(CondBOp->getRHS());
1165
1166       ConditionalEvaluation eval(*this);
1167       {
1168         ApplyDebugLocation DL(*this, Cond);
1169         EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock, RHSCount);
1170         EmitBlock(LHSTrue);
1171       }
1172
1173       incrementProfileCounter(CondBOp);
1174       setCurrentProfileCount(getProfileCount(CondBOp->getRHS()));
1175
1176       // Any temporaries created here are conditional.
1177       eval.begin(*this);
1178       EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock, TrueCount);
1179       eval.end(*this);
1180
1181       return;
1182     }
1183
1184     if (CondBOp->getOpcode() == BO_LOr) {
1185       // If we have "0 || X", simplify the code.  "1 || X" would have constant
1186       // folded if the case was simple enough.
1187       bool ConstantBool = false;
1188       if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) &&
1189           !ConstantBool) {
1190         // br(0 || X) -> br(X).
1191         incrementProfileCounter(CondBOp);
1192         return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock,
1193                                     TrueCount);
1194       }
1195
1196       // If we have "X || 0", simplify the code to use an uncond branch.
1197       // "X || 1" would have been constant folded to 1.
1198       if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) &&
1199           !ConstantBool) {
1200         // br(X || 0) -> br(X).
1201         return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock,
1202                                     TrueCount);
1203       }
1204
1205       // Emit the LHS as a conditional.  If the LHS conditional is true, we
1206       // want to jump to the TrueBlock.
1207       llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false");
1208       // We have the count for entry to the RHS and for the whole expression
1209       // being true, so we can divy up True count between the short circuit and
1210       // the RHS.
1211       uint64_t LHSCount =
1212           getCurrentProfileCount() - getProfileCount(CondBOp->getRHS());
1213       uint64_t RHSCount = TrueCount - LHSCount;
1214
1215       ConditionalEvaluation eval(*this);
1216       {
1217         ApplyDebugLocation DL(*this, Cond);
1218         EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse, LHSCount);
1219         EmitBlock(LHSFalse);
1220       }
1221
1222       incrementProfileCounter(CondBOp);
1223       setCurrentProfileCount(getProfileCount(CondBOp->getRHS()));
1224
1225       // Any temporaries created here are conditional.
1226       eval.begin(*this);
1227       EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock, RHSCount);
1228
1229       eval.end(*this);
1230
1231       return;
1232     }
1233   }
1234
1235   if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) {
1236     // br(!x, t, f) -> br(x, f, t)
1237     if (CondUOp->getOpcode() == UO_LNot) {
1238       // Negate the count.
1239       uint64_t FalseCount = getCurrentProfileCount() - TrueCount;
1240       // Negate the condition and swap the destination blocks.
1241       return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock,
1242                                   FalseCount);
1243     }
1244   }
1245
1246   if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) {
1247     // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f))
1248     llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true");
1249     llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false");
1250
1251     ConditionalEvaluation cond(*this);
1252     EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock,
1253                          getProfileCount(CondOp));
1254
1255     // When computing PGO branch weights, we only know the overall count for
1256     // the true block. This code is essentially doing tail duplication of the
1257     // naive code-gen, introducing new edges for which counts are not
1258     // available. Divide the counts proportionally between the LHS and RHS of
1259     // the conditional operator.
1260     uint64_t LHSScaledTrueCount = 0;
1261     if (TrueCount) {
1262       double LHSRatio =
1263           getProfileCount(CondOp) / (double)getCurrentProfileCount();
1264       LHSScaledTrueCount = TrueCount * LHSRatio;
1265     }
1266
1267     cond.begin(*this);
1268     EmitBlock(LHSBlock);
1269     incrementProfileCounter(CondOp);
1270     {
1271       ApplyDebugLocation DL(*this, Cond);
1272       EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock,
1273                            LHSScaledTrueCount);
1274     }
1275     cond.end(*this);
1276
1277     cond.begin(*this);
1278     EmitBlock(RHSBlock);
1279     EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock,
1280                          TrueCount - LHSScaledTrueCount);
1281     cond.end(*this);
1282
1283     return;
1284   }
1285
1286   if (const CXXThrowExpr *Throw = dyn_cast<CXXThrowExpr>(Cond)) {
1287     // Conditional operator handling can give us a throw expression as a
1288     // condition for a case like:
1289     //   br(c ? throw x : y, t, f) -> br(c, br(throw x, t, f), br(y, t, f)
1290     // Fold this to:
1291     //   br(c, throw x, br(y, t, f))
1292     EmitCXXThrowExpr(Throw, /*KeepInsertionPoint*/false);
1293     return;
1294   }
1295
1296   // If the branch has a condition wrapped by __builtin_unpredictable,
1297   // create metadata that specifies that the branch is unpredictable.
1298   // Don't bother if not optimizing because that metadata would not be used.
1299   llvm::MDNode *Unpredictable = nullptr;
1300   if (CGM.getCodeGenOpts().OptimizationLevel != 0) {
1301     if (const CallExpr *Call = dyn_cast<CallExpr>(Cond)) {
1302       const Decl *TargetDecl = Call->getCalleeDecl();
1303       if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl)) {
1304         if (FD->getBuiltinID() == Builtin::BI__builtin_unpredictable) {
1305           llvm::MDBuilder MDHelper(getLLVMContext());
1306           Unpredictable = MDHelper.createUnpredictable();
1307         }
1308       }
1309     }
1310   }
1311
1312   // Create branch weights based on the number of times we get here and the
1313   // number of times the condition should be true.
1314   uint64_t CurrentCount = std::max(getCurrentProfileCount(), TrueCount);
1315   llvm::MDNode *Weights =
1316       createProfileWeights(TrueCount, CurrentCount - TrueCount);
1317
1318   // Emit the code with the fully general case.
1319   llvm::Value *CondV;
1320   {
1321     ApplyDebugLocation DL(*this, Cond);
1322     CondV = EvaluateExprAsBool(Cond);
1323   }
1324   Builder.CreateCondBr(CondV, TrueBlock, FalseBlock, Weights, Unpredictable);
1325 }
1326
1327 /// ErrorUnsupported - Print out an error that codegen doesn't support the
1328 /// specified stmt yet.
1329 void CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type) {
1330   CGM.ErrorUnsupported(S, Type);
1331 }
1332
1333 /// emitNonZeroVLAInit - Emit the "zero" initialization of a
1334 /// variable-length array whose elements have a non-zero bit-pattern.
1335 ///
1336 /// \param baseType the inner-most element type of the array
1337 /// \param src - a char* pointing to the bit-pattern for a single
1338 /// base element of the array
1339 /// \param sizeInChars - the total size of the VLA, in chars
1340 static void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType,
1341                                Address dest, Address src,
1342                                llvm::Value *sizeInChars) {
1343   CGBuilderTy &Builder = CGF.Builder;
1344
1345   CharUnits baseSize = CGF.getContext().getTypeSizeInChars(baseType);
1346   llvm::Value *baseSizeInChars
1347     = llvm::ConstantInt::get(CGF.IntPtrTy, baseSize.getQuantity());
1348
1349   Address begin =
1350     Builder.CreateElementBitCast(dest, CGF.Int8Ty, "vla.begin");
1351   llvm::Value *end =
1352     Builder.CreateInBoundsGEP(begin.getPointer(), sizeInChars, "vla.end");
1353
1354   llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock();
1355   llvm::BasicBlock *loopBB = CGF.createBasicBlock("vla-init.loop");
1356   llvm::BasicBlock *contBB = CGF.createBasicBlock("vla-init.cont");
1357
1358   // Make a loop over the VLA.  C99 guarantees that the VLA element
1359   // count must be nonzero.
1360   CGF.EmitBlock(loopBB);
1361
1362   llvm::PHINode *cur = Builder.CreatePHI(begin.getType(), 2, "vla.cur");
1363   cur->addIncoming(begin.getPointer(), originBB);
1364
1365   CharUnits curAlign =
1366     dest.getAlignment().alignmentOfArrayElement(baseSize);
1367
1368   // memcpy the individual element bit-pattern.
1369   Builder.CreateMemCpy(Address(cur, curAlign), src, baseSizeInChars,
1370                        /*volatile*/ false);
1371
1372   // Go to the next element.
1373   llvm::Value *next =
1374     Builder.CreateInBoundsGEP(CGF.Int8Ty, cur, baseSizeInChars, "vla.next");
1375
1376   // Leave if that's the end of the VLA.
1377   llvm::Value *done = Builder.CreateICmpEQ(next, end, "vla-init.isdone");
1378   Builder.CreateCondBr(done, contBB, loopBB);
1379   cur->addIncoming(next, loopBB);
1380
1381   CGF.EmitBlock(contBB);
1382 }
1383
1384 void
1385 CodeGenFunction::EmitNullInitialization(Address DestPtr, QualType Ty) {
1386   // Ignore empty classes in C++.
1387   if (getLangOpts().CPlusPlus) {
1388     if (const RecordType *RT = Ty->getAs<RecordType>()) {
1389       if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty())
1390         return;
1391     }
1392   }
1393
1394   // Cast the dest ptr to the appropriate i8 pointer type.
1395   if (DestPtr.getElementType() != Int8Ty)
1396     DestPtr = Builder.CreateElementBitCast(DestPtr, Int8Ty);
1397
1398   // Get size and alignment info for this aggregate.
1399   CharUnits size = getContext().getTypeSizeInChars(Ty);
1400
1401   llvm::Value *SizeVal;
1402   const VariableArrayType *vla;
1403
1404   // Don't bother emitting a zero-byte memset.
1405   if (size.isZero()) {
1406     // But note that getTypeInfo returns 0 for a VLA.
1407     if (const VariableArrayType *vlaType =
1408           dyn_cast_or_null<VariableArrayType>(
1409                                           getContext().getAsArrayType(Ty))) {
1410       QualType eltType;
1411       llvm::Value *numElts;
1412       std::tie(numElts, eltType) = getVLASize(vlaType);
1413
1414       SizeVal = numElts;
1415       CharUnits eltSize = getContext().getTypeSizeInChars(eltType);
1416       if (!eltSize.isOne())
1417         SizeVal = Builder.CreateNUWMul(SizeVal, CGM.getSize(eltSize));
1418       vla = vlaType;
1419     } else {
1420       return;
1421     }
1422   } else {
1423     SizeVal = CGM.getSize(size);
1424     vla = nullptr;
1425   }
1426
1427   // If the type contains a pointer to data member we can't memset it to zero.
1428   // Instead, create a null constant and copy it to the destination.
1429   // TODO: there are other patterns besides zero that we can usefully memset,
1430   // like -1, which happens to be the pattern used by member-pointers.
1431   if (!CGM.getTypes().isZeroInitializable(Ty)) {
1432     // For a VLA, emit a single element, then splat that over the VLA.
1433     if (vla) Ty = getContext().getBaseElementType(vla);
1434
1435     llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty);
1436
1437     llvm::GlobalVariable *NullVariable =
1438       new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(),
1439                                /*isConstant=*/true,
1440                                llvm::GlobalVariable::PrivateLinkage,
1441                                NullConstant, Twine());
1442     CharUnits NullAlign = DestPtr.getAlignment();
1443     NullVariable->setAlignment(NullAlign.getQuantity());
1444     Address SrcPtr(Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()),
1445                    NullAlign);
1446
1447     if (vla) return emitNonZeroVLAInit(*this, Ty, DestPtr, SrcPtr, SizeVal);
1448
1449     // Get and call the appropriate llvm.memcpy overload.
1450     Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, false);
1451     return;
1452   }
1453
1454   // Otherwise, just memset the whole thing to zero.  This is legal
1455   // because in LLVM, all default initializers (other than the ones we just
1456   // handled above) are guaranteed to have a bit pattern of all zeros.
1457   Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal, false);
1458 }
1459
1460 llvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelDecl *L) {
1461   // Make sure that there is a block for the indirect goto.
1462   if (!IndirectBranch)
1463     GetIndirectGotoBlock();
1464
1465   llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock();
1466
1467   // Make sure the indirect branch includes all of the address-taken blocks.
1468   IndirectBranch->addDestination(BB);
1469   return llvm::BlockAddress::get(CurFn, BB);
1470 }
1471
1472 llvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() {
1473   // If we already made the indirect branch for indirect goto, return its block.
1474   if (IndirectBranch) return IndirectBranch->getParent();
1475
1476   CGBuilderTy TmpBuilder(*this, createBasicBlock("indirectgoto"));
1477
1478   // Create the PHI node that indirect gotos will add entries to.
1479   llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, 0,
1480                                               "indirect.goto.dest");
1481
1482   // Create the indirect branch instruction.
1483   IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal);
1484   return IndirectBranch->getParent();
1485 }
1486
1487 /// Computes the length of an array in elements, as well as the base
1488 /// element type and a properly-typed first element pointer.
1489 llvm::Value *CodeGenFunction::emitArrayLength(const ArrayType *origArrayType,
1490                                               QualType &baseType,
1491                                               Address &addr) {
1492   const ArrayType *arrayType = origArrayType;
1493
1494   // If it's a VLA, we have to load the stored size.  Note that
1495   // this is the size of the VLA in bytes, not its size in elements.
1496   llvm::Value *numVLAElements = nullptr;
1497   if (isa<VariableArrayType>(arrayType)) {
1498     numVLAElements = getVLASize(cast<VariableArrayType>(arrayType)).first;
1499
1500     // Walk into all VLAs.  This doesn't require changes to addr,
1501     // which has type T* where T is the first non-VLA element type.
1502     do {
1503       QualType elementType = arrayType->getElementType();
1504       arrayType = getContext().getAsArrayType(elementType);
1505
1506       // If we only have VLA components, 'addr' requires no adjustment.
1507       if (!arrayType) {
1508         baseType = elementType;
1509         return numVLAElements;
1510       }
1511     } while (isa<VariableArrayType>(arrayType));
1512
1513     // We get out here only if we find a constant array type
1514     // inside the VLA.
1515   }
1516
1517   // We have some number of constant-length arrays, so addr should
1518   // have LLVM type [M x [N x [...]]]*.  Build a GEP that walks
1519   // down to the first element of addr.
1520   SmallVector<llvm::Value*, 8> gepIndices;
1521
1522   // GEP down to the array type.
1523   llvm::ConstantInt *zero = Builder.getInt32(0);
1524   gepIndices.push_back(zero);
1525
1526   uint64_t countFromCLAs = 1;
1527   QualType eltType;
1528
1529   llvm::ArrayType *llvmArrayType =
1530     dyn_cast<llvm::ArrayType>(addr.getElementType());
1531   while (llvmArrayType) {
1532     assert(isa<ConstantArrayType>(arrayType));
1533     assert(cast<ConstantArrayType>(arrayType)->getSize().getZExtValue()
1534              == llvmArrayType->getNumElements());
1535
1536     gepIndices.push_back(zero);
1537     countFromCLAs *= llvmArrayType->getNumElements();
1538     eltType = arrayType->getElementType();
1539
1540     llvmArrayType =
1541       dyn_cast<llvm::ArrayType>(llvmArrayType->getElementType());
1542     arrayType = getContext().getAsArrayType(arrayType->getElementType());
1543     assert((!llvmArrayType || arrayType) &&
1544            "LLVM and Clang types are out-of-synch");
1545   }
1546
1547   if (arrayType) {
1548     // From this point onwards, the Clang array type has been emitted
1549     // as some other type (probably a packed struct). Compute the array
1550     // size, and just emit the 'begin' expression as a bitcast.
1551     while (arrayType) {
1552       countFromCLAs *=
1553           cast<ConstantArrayType>(arrayType)->getSize().getZExtValue();
1554       eltType = arrayType->getElementType();
1555       arrayType = getContext().getAsArrayType(eltType);
1556     }
1557
1558     llvm::Type *baseType = ConvertType(eltType);
1559     addr = Builder.CreateElementBitCast(addr, baseType, "array.begin");
1560   } else {
1561     // Create the actual GEP.
1562     addr = Address(Builder.CreateInBoundsGEP(addr.getPointer(),
1563                                              gepIndices, "array.begin"),
1564                    addr.getAlignment());
1565   }
1566
1567   baseType = eltType;
1568
1569   llvm::Value *numElements
1570     = llvm::ConstantInt::get(SizeTy, countFromCLAs);
1571
1572   // If we had any VLA dimensions, factor them in.
1573   if (numVLAElements)
1574     numElements = Builder.CreateNUWMul(numVLAElements, numElements);
1575
1576   return numElements;
1577 }
1578
1579 std::pair<llvm::Value*, QualType>
1580 CodeGenFunction::getVLASize(QualType type) {
1581   const VariableArrayType *vla = getContext().getAsVariableArrayType(type);
1582   assert(vla && "type was not a variable array type!");
1583   return getVLASize(vla);
1584 }
1585
1586 std::pair<llvm::Value*, QualType>
1587 CodeGenFunction::getVLASize(const VariableArrayType *type) {
1588   // The number of elements so far; always size_t.
1589   llvm::Value *numElements = nullptr;
1590
1591   QualType elementType;
1592   do {
1593     elementType = type->getElementType();
1594     llvm::Value *vlaSize = VLASizeMap[type->getSizeExpr()];
1595     assert(vlaSize && "no size for VLA!");
1596     assert(vlaSize->getType() == SizeTy);
1597
1598     if (!numElements) {
1599       numElements = vlaSize;
1600     } else {
1601       // It's undefined behavior if this wraps around, so mark it that way.
1602       // FIXME: Teach -fsanitize=undefined to trap this.
1603       numElements = Builder.CreateNUWMul(numElements, vlaSize);
1604     }
1605   } while ((type = getContext().getAsVariableArrayType(elementType)));
1606
1607   return std::pair<llvm::Value*,QualType>(numElements, elementType);
1608 }
1609
1610 void CodeGenFunction::EmitVariablyModifiedType(QualType type) {
1611   assert(type->isVariablyModifiedType() &&
1612          "Must pass variably modified type to EmitVLASizes!");
1613
1614   EnsureInsertPoint();
1615
1616   // We're going to walk down into the type and look for VLA
1617   // expressions.
1618   do {
1619     assert(type->isVariablyModifiedType());
1620
1621     const Type *ty = type.getTypePtr();
1622     switch (ty->getTypeClass()) {
1623
1624 #define TYPE(Class, Base)
1625 #define ABSTRACT_TYPE(Class, Base)
1626 #define NON_CANONICAL_TYPE(Class, Base)
1627 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
1628 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
1629 #include "clang/AST/TypeNodes.def"
1630       llvm_unreachable("unexpected dependent type!");
1631
1632     // These types are never variably-modified.
1633     case Type::Builtin:
1634     case Type::Complex:
1635     case Type::Vector:
1636     case Type::ExtVector:
1637     case Type::Record:
1638     case Type::Enum:
1639     case Type::Elaborated:
1640     case Type::TemplateSpecialization:
1641     case Type::ObjCObject:
1642     case Type::ObjCInterface:
1643     case Type::ObjCObjectPointer:
1644       llvm_unreachable("type class is never variably-modified!");
1645
1646     case Type::Adjusted:
1647       type = cast<AdjustedType>(ty)->getAdjustedType();
1648       break;
1649
1650     case Type::Decayed:
1651       type = cast<DecayedType>(ty)->getPointeeType();
1652       break;
1653
1654     case Type::Pointer:
1655       type = cast<PointerType>(ty)->getPointeeType();
1656       break;
1657
1658     case Type::BlockPointer:
1659       type = cast<BlockPointerType>(ty)->getPointeeType();
1660       break;
1661
1662     case Type::LValueReference:
1663     case Type::RValueReference:
1664       type = cast<ReferenceType>(ty)->getPointeeType();
1665       break;
1666
1667     case Type::MemberPointer:
1668       type = cast<MemberPointerType>(ty)->getPointeeType();
1669       break;
1670
1671     case Type::ConstantArray:
1672     case Type::IncompleteArray:
1673       // Losing element qualification here is fine.
1674       type = cast<ArrayType>(ty)->getElementType();
1675       break;
1676
1677     case Type::VariableArray: {
1678       // Losing element qualification here is fine.
1679       const VariableArrayType *vat = cast<VariableArrayType>(ty);
1680
1681       // Unknown size indication requires no size computation.
1682       // Otherwise, evaluate and record it.
1683       if (const Expr *size = vat->getSizeExpr()) {
1684         // It's possible that we might have emitted this already,
1685         // e.g. with a typedef and a pointer to it.
1686         llvm::Value *&entry = VLASizeMap[size];
1687         if (!entry) {
1688           llvm::Value *Size = EmitScalarExpr(size);
1689
1690           // C11 6.7.6.2p5:
1691           //   If the size is an expression that is not an integer constant
1692           //   expression [...] each time it is evaluated it shall have a value
1693           //   greater than zero.
1694           if (SanOpts.has(SanitizerKind::VLABound) &&
1695               size->getType()->isSignedIntegerType()) {
1696             SanitizerScope SanScope(this);
1697             llvm::Value *Zero = llvm::Constant::getNullValue(Size->getType());
1698             llvm::Constant *StaticArgs[] = {
1699               EmitCheckSourceLocation(size->getLocStart()),
1700               EmitCheckTypeDescriptor(size->getType())
1701             };
1702             EmitCheck(std::make_pair(Builder.CreateICmpSGT(Size, Zero),
1703                                      SanitizerKind::VLABound),
1704                       "vla_bound_not_positive", StaticArgs, Size);
1705           }
1706
1707           // Always zexting here would be wrong if it weren't
1708           // undefined behavior to have a negative bound.
1709           entry = Builder.CreateIntCast(Size, SizeTy, /*signed*/ false);
1710         }
1711       }
1712       type = vat->getElementType();
1713       break;
1714     }
1715
1716     case Type::FunctionProto:
1717     case Type::FunctionNoProto:
1718       type = cast<FunctionType>(ty)->getReturnType();
1719       break;
1720
1721     case Type::Paren:
1722     case Type::TypeOf:
1723     case Type::UnaryTransform:
1724     case Type::Attributed:
1725     case Type::SubstTemplateTypeParm:
1726     case Type::PackExpansion:
1727       // Keep walking after single level desugaring.
1728       type = type.getSingleStepDesugaredType(getContext());
1729       break;
1730
1731     case Type::Typedef:
1732     case Type::Decltype:
1733     case Type::Auto:
1734       // Stop walking: nothing to do.
1735       return;
1736
1737     case Type::TypeOfExpr:
1738       // Stop walking: emit typeof expression.
1739       EmitIgnoredExpr(cast<TypeOfExprType>(ty)->getUnderlyingExpr());
1740       return;
1741
1742     case Type::Atomic:
1743       type = cast<AtomicType>(ty)->getValueType();
1744       break;
1745
1746     case Type::Pipe:
1747       type = cast<PipeType>(ty)->getElementType();
1748       break;
1749     }
1750   } while (type->isVariablyModifiedType());
1751 }
1752
1753 Address CodeGenFunction::EmitVAListRef(const Expr* E) {
1754   if (getContext().getBuiltinVaListType()->isArrayType())
1755     return EmitPointerWithAlignment(E);
1756   return EmitLValue(E).getAddress();
1757 }
1758
1759 Address CodeGenFunction::EmitMSVAListRef(const Expr *E) {
1760   return EmitLValue(E).getAddress();
1761 }
1762
1763 void CodeGenFunction::EmitDeclRefExprDbgValue(const DeclRefExpr *E,
1764                                               llvm::Constant *Init) {
1765   assert (Init && "Invalid DeclRefExpr initializer!");
1766   if (CGDebugInfo *Dbg = getDebugInfo())
1767     if (CGM.getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
1768       Dbg->EmitGlobalVariable(E->getDecl(), Init);
1769 }
1770
1771 CodeGenFunction::PeepholeProtection
1772 CodeGenFunction::protectFromPeepholes(RValue rvalue) {
1773   // At the moment, the only aggressive peephole we do in IR gen
1774   // is trunc(zext) folding, but if we add more, we can easily
1775   // extend this protection.
1776
1777   if (!rvalue.isScalar()) return PeepholeProtection();
1778   llvm::Value *value = rvalue.getScalarVal();
1779   if (!isa<llvm::ZExtInst>(value)) return PeepholeProtection();
1780
1781   // Just make an extra bitcast.
1782   assert(HaveInsertPoint());
1783   llvm::Instruction *inst = new llvm::BitCastInst(value, value->getType(), "",
1784                                                   Builder.GetInsertBlock());
1785
1786   PeepholeProtection protection;
1787   protection.Inst = inst;
1788   return protection;
1789 }
1790
1791 void CodeGenFunction::unprotectFromPeepholes(PeepholeProtection protection) {
1792   if (!protection.Inst) return;
1793
1794   // In theory, we could try to duplicate the peepholes now, but whatever.
1795   protection.Inst->eraseFromParent();
1796 }
1797
1798 llvm::Value *CodeGenFunction::EmitAnnotationCall(llvm::Value *AnnotationFn,
1799                                                  llvm::Value *AnnotatedVal,
1800                                                  StringRef AnnotationStr,
1801                                                  SourceLocation Location) {
1802   llvm::Value *Args[4] = {
1803     AnnotatedVal,
1804     Builder.CreateBitCast(CGM.EmitAnnotationString(AnnotationStr), Int8PtrTy),
1805     Builder.CreateBitCast(CGM.EmitAnnotationUnit(Location), Int8PtrTy),
1806     CGM.EmitAnnotationLineNo(Location)
1807   };
1808   return Builder.CreateCall(AnnotationFn, Args);
1809 }
1810
1811 void CodeGenFunction::EmitVarAnnotations(const VarDecl *D, llvm::Value *V) {
1812   assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
1813   // FIXME We create a new bitcast for every annotation because that's what
1814   // llvm-gcc was doing.
1815   for (const auto *I : D->specific_attrs<AnnotateAttr>())
1816     EmitAnnotationCall(CGM.getIntrinsic(llvm::Intrinsic::var_annotation),
1817                        Builder.CreateBitCast(V, CGM.Int8PtrTy, V->getName()),
1818                        I->getAnnotation(), D->getLocation());
1819 }
1820
1821 Address CodeGenFunction::EmitFieldAnnotations(const FieldDecl *D,
1822                                               Address Addr) {
1823   assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
1824   llvm::Value *V = Addr.getPointer();
1825   llvm::Type *VTy = V->getType();
1826   llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::ptr_annotation,
1827                                     CGM.Int8PtrTy);
1828
1829   for (const auto *I : D->specific_attrs<AnnotateAttr>()) {
1830     // FIXME Always emit the cast inst so we can differentiate between
1831     // annotation on the first field of a struct and annotation on the struct
1832     // itself.
1833     if (VTy != CGM.Int8PtrTy)
1834       V = Builder.Insert(new llvm::BitCastInst(V, CGM.Int8PtrTy));
1835     V = EmitAnnotationCall(F, V, I->getAnnotation(), D->getLocation());
1836     V = Builder.CreateBitCast(V, VTy);
1837   }
1838
1839   return Address(V, Addr.getAlignment());
1840 }
1841
1842 CodeGenFunction::CGCapturedStmtInfo::~CGCapturedStmtInfo() { }
1843
1844 CodeGenFunction::SanitizerScope::SanitizerScope(CodeGenFunction *CGF)
1845     : CGF(CGF) {
1846   assert(!CGF->IsSanitizerScope);
1847   CGF->IsSanitizerScope = true;
1848 }
1849
1850 CodeGenFunction::SanitizerScope::~SanitizerScope() {
1851   CGF->IsSanitizerScope = false;
1852 }
1853
1854 void CodeGenFunction::InsertHelper(llvm::Instruction *I,
1855                                    const llvm::Twine &Name,
1856                                    llvm::BasicBlock *BB,
1857                                    llvm::BasicBlock::iterator InsertPt) const {
1858   LoopStack.InsertHelper(I);
1859   if (IsSanitizerScope)
1860     CGM.getSanitizerMetadata()->disableSanitizerForInstruction(I);
1861 }
1862
1863 template <bool PreserveNames>
1864 void CGBuilderInserter<PreserveNames>::InsertHelper(
1865     llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB,
1866     llvm::BasicBlock::iterator InsertPt) const {
1867   llvm::IRBuilderDefaultInserter<PreserveNames>::InsertHelper(I, Name, BB,
1868                                                               InsertPt);
1869   if (CGF)
1870     CGF->InsertHelper(I, Name, BB, InsertPt);
1871 }
1872
1873 #ifdef NDEBUG
1874 #define PreserveNames false
1875 #else
1876 #define PreserveNames true
1877 #endif
1878 template void CGBuilderInserter<PreserveNames>::InsertHelper(
1879     llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB,
1880     llvm::BasicBlock::iterator InsertPt) const;
1881 #undef PreserveNames
1882
1883 static bool hasRequiredFeatures(const SmallVectorImpl<StringRef> &ReqFeatures,
1884                                 CodeGenModule &CGM, const FunctionDecl *FD,
1885                                 std::string &FirstMissing) {
1886   // If there aren't any required features listed then go ahead and return.
1887   if (ReqFeatures.empty())
1888     return false;
1889
1890   // Now build up the set of caller features and verify that all the required
1891   // features are there.
1892   llvm::StringMap<bool> CallerFeatureMap;
1893   CGM.getFunctionFeatureMap(CallerFeatureMap, FD);
1894
1895   // If we have at least one of the features in the feature list return
1896   // true, otherwise return false.
1897   return std::all_of(
1898       ReqFeatures.begin(), ReqFeatures.end(), [&](StringRef Feature) {
1899         SmallVector<StringRef, 1> OrFeatures;
1900         Feature.split(OrFeatures, "|");
1901         return std::any_of(OrFeatures.begin(), OrFeatures.end(),
1902                            [&](StringRef Feature) {
1903                              if (!CallerFeatureMap.lookup(Feature)) {
1904                                FirstMissing = Feature.str();
1905                                return false;
1906                              }
1907                              return true;
1908                            });
1909       });
1910 }
1911
1912 // Emits an error if we don't have a valid set of target features for the
1913 // called function.
1914 void CodeGenFunction::checkTargetFeatures(const CallExpr *E,
1915                                           const FunctionDecl *TargetDecl) {
1916   // Early exit if this is an indirect call.
1917   if (!TargetDecl)
1918     return;
1919
1920   // Get the current enclosing function if it exists. If it doesn't
1921   // we can't check the target features anyhow.
1922   const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurFuncDecl);
1923   if (!FD)
1924     return;
1925
1926   // Grab the required features for the call. For a builtin this is listed in
1927   // the td file with the default cpu, for an always_inline function this is any
1928   // listed cpu and any listed features.
1929   unsigned BuiltinID = TargetDecl->getBuiltinID();
1930   std::string MissingFeature;
1931   if (BuiltinID) {
1932     SmallVector<StringRef, 1> ReqFeatures;
1933     const char *FeatureList =
1934         CGM.getContext().BuiltinInfo.getRequiredFeatures(BuiltinID);
1935     // Return if the builtin doesn't have any required features.
1936     if (!FeatureList || StringRef(FeatureList) == "")
1937       return;
1938     StringRef(FeatureList).split(ReqFeatures, ",");
1939     if (!hasRequiredFeatures(ReqFeatures, CGM, FD, MissingFeature))
1940       CGM.getDiags().Report(E->getLocStart(), diag::err_builtin_needs_feature)
1941           << TargetDecl->getDeclName()
1942           << CGM.getContext().BuiltinInfo.getRequiredFeatures(BuiltinID);
1943
1944   } else if (TargetDecl->hasAttr<TargetAttr>()) {
1945     // Get the required features for the callee.
1946     SmallVector<StringRef, 1> ReqFeatures;
1947     llvm::StringMap<bool> CalleeFeatureMap;
1948     CGM.getFunctionFeatureMap(CalleeFeatureMap, TargetDecl);
1949     for (const auto &F : CalleeFeatureMap) {
1950       // Only positive features are "required".
1951       if (F.getValue())
1952         ReqFeatures.push_back(F.getKey());
1953     }
1954     if (!hasRequiredFeatures(ReqFeatures, CGM, FD, MissingFeature))
1955       CGM.getDiags().Report(E->getLocStart(), diag::err_function_needs_feature)
1956           << FD->getDeclName() << TargetDecl->getDeclName() << MissingFeature;
1957   }
1958 }