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