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