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