xref: /freebsd/contrib/llvm-project/clang/lib/CodeGen/CodeGenFunction.cpp (revision 833a452e9f082a7982a31c21f0da437dbbe0a39d)
1 //===--- CodeGenFunction.cpp - Emit LLVM Code from ASTs for a Function ----===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This coordinates the per-function state used while generating code.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "CodeGenFunction.h"
14 #include "CGBlocks.h"
15 #include "CGCUDARuntime.h"
16 #include "CGCXXABI.h"
17 #include "CGCleanup.h"
18 #include "CGDebugInfo.h"
19 #include "CGOpenMPRuntime.h"
20 #include "CodeGenModule.h"
21 #include "CodeGenPGO.h"
22 #include "TargetInfo.h"
23 #include "clang/AST/ASTContext.h"
24 #include "clang/AST/ASTLambda.h"
25 #include "clang/AST/Attr.h"
26 #include "clang/AST/Decl.h"
27 #include "clang/AST/DeclCXX.h"
28 #include "clang/AST/Expr.h"
29 #include "clang/AST/StmtCXX.h"
30 #include "clang/AST/StmtObjC.h"
31 #include "clang/Basic/Builtins.h"
32 #include "clang/Basic/CodeGenOptions.h"
33 #include "clang/Basic/TargetInfo.h"
34 #include "clang/CodeGen/CGFunctionInfo.h"
35 #include "clang/Frontend/FrontendDiagnostic.h"
36 #include "llvm/ADT/ArrayRef.h"
37 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
38 #include "llvm/IR/DataLayout.h"
39 #include "llvm/IR/Dominators.h"
40 #include "llvm/IR/FPEnv.h"
41 #include "llvm/IR/IntrinsicInst.h"
42 #include "llvm/IR/Intrinsics.h"
43 #include "llvm/IR/MDBuilder.h"
44 #include "llvm/IR/Operator.h"
45 #include "llvm/Support/CRC.h"
46 #include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
47 #include "llvm/Transforms/Utils/PromoteMemToReg.h"
48 using namespace clang;
49 using namespace CodeGen;
50 
51 /// shouldEmitLifetimeMarkers - Decide whether we need emit the life-time
52 /// markers.
53 static bool shouldEmitLifetimeMarkers(const CodeGenOptions &CGOpts,
54                                       const LangOptions &LangOpts) {
55   if (CGOpts.DisableLifetimeMarkers)
56     return false;
57 
58   // Sanitizers may use markers.
59   if (CGOpts.SanitizeAddressUseAfterScope ||
60       LangOpts.Sanitize.has(SanitizerKind::HWAddress) ||
61       LangOpts.Sanitize.has(SanitizerKind::Memory))
62     return true;
63 
64   // For now, only in optimized builds.
65   return CGOpts.OptimizationLevel != 0;
66 }
67 
68 CodeGenFunction::CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext)
69     : CodeGenTypeCache(cgm), CGM(cgm), Target(cgm.getTarget()),
70       Builder(cgm, cgm.getModule().getContext(), llvm::ConstantFolder(),
71               CGBuilderInserterTy(this)),
72       SanOpts(CGM.getLangOpts().Sanitize), CurFPFeatures(CGM.getLangOpts()),
73       DebugInfo(CGM.getModuleDebugInfo()), PGO(cgm),
74       ShouldEmitLifetimeMarkers(
75           shouldEmitLifetimeMarkers(CGM.getCodeGenOpts(), CGM.getLangOpts())) {
76   if (!suppressNewContext)
77     CGM.getCXXABI().getMangleContext().startNewFunction();
78   EHStack.setCGF(this);
79 
80   SetFastMathFlags(CurFPFeatures);
81   SetFPModel();
82 }
83 
84 CodeGenFunction::~CodeGenFunction() {
85   assert(LifetimeExtendedCleanupStack.empty() && "failed to emit a cleanup");
86 
87   if (getLangOpts().OpenMP && CurFn)
88     CGM.getOpenMPRuntime().functionFinished(*this);
89 
90   // If we have an OpenMPIRBuilder we want to finalize functions (incl.
91   // outlining etc) at some point. Doing it once the function codegen is done
92   // seems to be a reasonable spot. We do it here, as opposed to the deletion
93   // time of the CodeGenModule, because we have to ensure the IR has not yet
94   // been "emitted" to the outside, thus, modifications are still sensible.
95   if (CGM.getLangOpts().OpenMPIRBuilder && CurFn)
96     CGM.getOpenMPRuntime().getOMPBuilder().finalize(CurFn);
97 }
98 
99 // Map the LangOption for exception behavior into
100 // the corresponding enum in the IR.
101 llvm::fp::ExceptionBehavior
102 clang::ToConstrainedExceptMD(LangOptions::FPExceptionModeKind Kind) {
103 
104   switch (Kind) {
105   case LangOptions::FPE_Ignore:  return llvm::fp::ebIgnore;
106   case LangOptions::FPE_MayTrap: return llvm::fp::ebMayTrap;
107   case LangOptions::FPE_Strict:  return llvm::fp::ebStrict;
108   }
109   llvm_unreachable("Unsupported FP Exception Behavior");
110 }
111 
112 void CodeGenFunction::SetFPModel() {
113   llvm::RoundingMode RM = getLangOpts().getFPRoundingMode();
114   auto fpExceptionBehavior = ToConstrainedExceptMD(
115                                getLangOpts().getFPExceptionMode());
116 
117   Builder.setDefaultConstrainedRounding(RM);
118   Builder.setDefaultConstrainedExcept(fpExceptionBehavior);
119   Builder.setIsFPConstrained(fpExceptionBehavior != llvm::fp::ebIgnore ||
120                              RM != llvm::RoundingMode::NearestTiesToEven);
121 }
122 
123 void CodeGenFunction::SetFastMathFlags(FPOptions FPFeatures) {
124   llvm::FastMathFlags FMF;
125   FMF.setAllowReassoc(FPFeatures.getAllowFPReassociate());
126   FMF.setNoNaNs(FPFeatures.getNoHonorNaNs());
127   FMF.setNoInfs(FPFeatures.getNoHonorInfs());
128   FMF.setNoSignedZeros(FPFeatures.getNoSignedZero());
129   FMF.setAllowReciprocal(FPFeatures.getAllowReciprocal());
130   FMF.setApproxFunc(FPFeatures.getAllowApproxFunc());
131   FMF.setAllowContract(FPFeatures.allowFPContractAcrossStatement());
132   Builder.setFastMathFlags(FMF);
133 }
134 
135 CodeGenFunction::CGFPOptionsRAII::CGFPOptionsRAII(CodeGenFunction &CGF,
136                                                   const Expr *E)
137     : CGF(CGF) {
138   ConstructorHelper(E->getFPFeaturesInEffect(CGF.getLangOpts()));
139 }
140 
141 CodeGenFunction::CGFPOptionsRAII::CGFPOptionsRAII(CodeGenFunction &CGF,
142                                                   FPOptions FPFeatures)
143     : CGF(CGF) {
144   ConstructorHelper(FPFeatures);
145 }
146 
147 void CodeGenFunction::CGFPOptionsRAII::ConstructorHelper(FPOptions FPFeatures) {
148   OldFPFeatures = CGF.CurFPFeatures;
149   CGF.CurFPFeatures = FPFeatures;
150 
151   OldExcept = CGF.Builder.getDefaultConstrainedExcept();
152   OldRounding = CGF.Builder.getDefaultConstrainedRounding();
153 
154   if (OldFPFeatures == FPFeatures)
155     return;
156 
157   FMFGuard.emplace(CGF.Builder);
158 
159   llvm::RoundingMode NewRoundingBehavior =
160       static_cast<llvm::RoundingMode>(FPFeatures.getRoundingMode());
161   CGF.Builder.setDefaultConstrainedRounding(NewRoundingBehavior);
162   auto NewExceptionBehavior =
163       ToConstrainedExceptMD(static_cast<LangOptions::FPExceptionModeKind>(
164           FPFeatures.getFPExceptionMode()));
165   CGF.Builder.setDefaultConstrainedExcept(NewExceptionBehavior);
166 
167   CGF.SetFastMathFlags(FPFeatures);
168 
169   assert((CGF.CurFuncDecl == nullptr || CGF.Builder.getIsFPConstrained() ||
170           isa<CXXConstructorDecl>(CGF.CurFuncDecl) ||
171           isa<CXXDestructorDecl>(CGF.CurFuncDecl) ||
172           (NewExceptionBehavior == llvm::fp::ebIgnore &&
173            NewRoundingBehavior == llvm::RoundingMode::NearestTiesToEven)) &&
174          "FPConstrained should be enabled on entire function");
175 
176   auto mergeFnAttrValue = [&](StringRef Name, bool Value) {
177     auto OldValue =
178         CGF.CurFn->getFnAttribute(Name).getValueAsBool();
179     auto NewValue = OldValue & Value;
180     if (OldValue != NewValue)
181       CGF.CurFn->addFnAttr(Name, llvm::toStringRef(NewValue));
182   };
183   mergeFnAttrValue("no-infs-fp-math", FPFeatures.getNoHonorInfs());
184   mergeFnAttrValue("no-nans-fp-math", FPFeatures.getNoHonorNaNs());
185   mergeFnAttrValue("no-signed-zeros-fp-math", FPFeatures.getNoSignedZero());
186   mergeFnAttrValue("unsafe-fp-math", FPFeatures.getAllowFPReassociate() &&
187                                          FPFeatures.getAllowReciprocal() &&
188                                          FPFeatures.getAllowApproxFunc() &&
189                                          FPFeatures.getNoSignedZero());
190 }
191 
192 CodeGenFunction::CGFPOptionsRAII::~CGFPOptionsRAII() {
193   CGF.CurFPFeatures = OldFPFeatures;
194   CGF.Builder.setDefaultConstrainedExcept(OldExcept);
195   CGF.Builder.setDefaultConstrainedRounding(OldRounding);
196 }
197 
198 LValue CodeGenFunction::MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T) {
199   LValueBaseInfo BaseInfo;
200   TBAAAccessInfo TBAAInfo;
201   CharUnits Alignment = CGM.getNaturalTypeAlignment(T, &BaseInfo, &TBAAInfo);
202   return LValue::MakeAddr(Address(V, Alignment), T, getContext(), BaseInfo,
203                           TBAAInfo);
204 }
205 
206 /// Given a value of type T* that may not be to a complete object,
207 /// construct an l-value with the natural pointee alignment of T.
208 LValue
209 CodeGenFunction::MakeNaturalAlignPointeeAddrLValue(llvm::Value *V, QualType T) {
210   LValueBaseInfo BaseInfo;
211   TBAAAccessInfo TBAAInfo;
212   CharUnits Align = CGM.getNaturalTypeAlignment(T, &BaseInfo, &TBAAInfo,
213                                                 /* forPointeeType= */ true);
214   return MakeAddrLValue(Address(V, Align), T, BaseInfo, TBAAInfo);
215 }
216 
217 
218 llvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) {
219   return CGM.getTypes().ConvertTypeForMem(T);
220 }
221 
222 llvm::Type *CodeGenFunction::ConvertType(QualType T) {
223   return CGM.getTypes().ConvertType(T);
224 }
225 
226 TypeEvaluationKind CodeGenFunction::getEvaluationKind(QualType type) {
227   type = type.getCanonicalType();
228   while (true) {
229     switch (type->getTypeClass()) {
230 #define TYPE(name, parent)
231 #define ABSTRACT_TYPE(name, parent)
232 #define NON_CANONICAL_TYPE(name, parent) case Type::name:
233 #define DEPENDENT_TYPE(name, parent) case Type::name:
234 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(name, parent) case Type::name:
235 #include "clang/AST/TypeNodes.inc"
236       llvm_unreachable("non-canonical or dependent type in IR-generation");
237 
238     case Type::Auto:
239     case Type::DeducedTemplateSpecialization:
240       llvm_unreachable("undeduced type in IR-generation");
241 
242     // Various scalar types.
243     case Type::Builtin:
244     case Type::Pointer:
245     case Type::BlockPointer:
246     case Type::LValueReference:
247     case Type::RValueReference:
248     case Type::MemberPointer:
249     case Type::Vector:
250     case Type::ExtVector:
251     case Type::ConstantMatrix:
252     case Type::FunctionProto:
253     case Type::FunctionNoProto:
254     case Type::Enum:
255     case Type::ObjCObjectPointer:
256     case Type::Pipe:
257     case Type::ExtInt:
258       return TEK_Scalar;
259 
260     // Complexes.
261     case Type::Complex:
262       return TEK_Complex;
263 
264     // Arrays, records, and Objective-C objects.
265     case Type::ConstantArray:
266     case Type::IncompleteArray:
267     case Type::VariableArray:
268     case Type::Record:
269     case Type::ObjCObject:
270     case Type::ObjCInterface:
271       return TEK_Aggregate;
272 
273     // We operate on atomic values according to their underlying type.
274     case Type::Atomic:
275       type = cast<AtomicType>(type)->getValueType();
276       continue;
277     }
278     llvm_unreachable("unknown type kind!");
279   }
280 }
281 
282 llvm::DebugLoc CodeGenFunction::EmitReturnBlock() {
283   // For cleanliness, we try to avoid emitting the return block for
284   // simple cases.
285   llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
286 
287   if (CurBB) {
288     assert(!CurBB->getTerminator() && "Unexpected terminated block.");
289 
290     // We have a valid insert point, reuse it if it is empty or there are no
291     // explicit jumps to the return block.
292     if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) {
293       ReturnBlock.getBlock()->replaceAllUsesWith(CurBB);
294       delete ReturnBlock.getBlock();
295       ReturnBlock = JumpDest();
296     } else
297       EmitBlock(ReturnBlock.getBlock());
298     return llvm::DebugLoc();
299   }
300 
301   // Otherwise, if the return block is the target of a single direct
302   // branch then we can just put the code in that block instead. This
303   // cleans up functions which started with a unified return block.
304   if (ReturnBlock.getBlock()->hasOneUse()) {
305     llvm::BranchInst *BI =
306       dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->user_begin());
307     if (BI && BI->isUnconditional() &&
308         BI->getSuccessor(0) == ReturnBlock.getBlock()) {
309       // Record/return the DebugLoc of the simple 'return' expression to be used
310       // later by the actual 'ret' instruction.
311       llvm::DebugLoc Loc = BI->getDebugLoc();
312       Builder.SetInsertPoint(BI->getParent());
313       BI->eraseFromParent();
314       delete ReturnBlock.getBlock();
315       ReturnBlock = JumpDest();
316       return Loc;
317     }
318   }
319 
320   // FIXME: We are at an unreachable point, there is no reason to emit the block
321   // unless it has uses. However, we still need a place to put the debug
322   // region.end for now.
323 
324   EmitBlock(ReturnBlock.getBlock());
325   return llvm::DebugLoc();
326 }
327 
328 static void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) {
329   if (!BB) return;
330   if (!BB->use_empty())
331     return CGF.CurFn->getBasicBlockList().push_back(BB);
332   delete BB;
333 }
334 
335 void CodeGenFunction::FinishFunction(SourceLocation EndLoc) {
336   assert(BreakContinueStack.empty() &&
337          "mismatched push/pop in break/continue stack!");
338 
339   bool OnlySimpleReturnStmts = NumSimpleReturnExprs > 0
340     && NumSimpleReturnExprs == NumReturnExprs
341     && ReturnBlock.getBlock()->use_empty();
342   // Usually the return expression is evaluated before the cleanup
343   // code.  If the function contains only a simple return statement,
344   // such as a constant, the location before the cleanup code becomes
345   // the last useful breakpoint in the function, because the simple
346   // return expression will be evaluated after the cleanup code. To be
347   // safe, set the debug location for cleanup code to the location of
348   // the return statement.  Otherwise the cleanup code should be at the
349   // end of the function's lexical scope.
350   //
351   // If there are multiple branches to the return block, the branch
352   // instructions will get the location of the return statements and
353   // all will be fine.
354   if (CGDebugInfo *DI = getDebugInfo()) {
355     if (OnlySimpleReturnStmts)
356       DI->EmitLocation(Builder, LastStopPoint);
357     else
358       DI->EmitLocation(Builder, EndLoc);
359   }
360 
361   // Pop any cleanups that might have been associated with the
362   // parameters.  Do this in whatever block we're currently in; it's
363   // important to do this before we enter the return block or return
364   // edges will be *really* confused.
365   bool HasCleanups = EHStack.stable_begin() != PrologueCleanupDepth;
366   bool HasOnlyLifetimeMarkers =
367       HasCleanups && EHStack.containsOnlyLifetimeMarkers(PrologueCleanupDepth);
368   bool EmitRetDbgLoc = !HasCleanups || HasOnlyLifetimeMarkers;
369   if (HasCleanups) {
370     // Make sure the line table doesn't jump back into the body for
371     // the ret after it's been at EndLoc.
372     Optional<ApplyDebugLocation> AL;
373     if (CGDebugInfo *DI = getDebugInfo()) {
374       if (OnlySimpleReturnStmts)
375         DI->EmitLocation(Builder, EndLoc);
376       else
377         // We may not have a valid end location. Try to apply it anyway, and
378         // fall back to an artificial location if needed.
379         AL = ApplyDebugLocation::CreateDefaultArtificial(*this, EndLoc);
380     }
381 
382     PopCleanupBlocks(PrologueCleanupDepth);
383   }
384 
385   // Emit function epilog (to return).
386   llvm::DebugLoc Loc = EmitReturnBlock();
387 
388   if (ShouldInstrumentFunction()) {
389     if (CGM.getCodeGenOpts().InstrumentFunctions)
390       CurFn->addFnAttr("instrument-function-exit", "__cyg_profile_func_exit");
391     if (CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining)
392       CurFn->addFnAttr("instrument-function-exit-inlined",
393                        "__cyg_profile_func_exit");
394   }
395 
396   // Emit debug descriptor for function end.
397   if (CGDebugInfo *DI = getDebugInfo())
398     DI->EmitFunctionEnd(Builder, CurFn);
399 
400   // Reset the debug location to that of the simple 'return' expression, if any
401   // rather than that of the end of the function's scope '}'.
402   ApplyDebugLocation AL(*this, Loc);
403   EmitFunctionEpilog(*CurFnInfo, EmitRetDbgLoc, EndLoc);
404   EmitEndEHSpec(CurCodeDecl);
405 
406   assert(EHStack.empty() &&
407          "did not remove all scopes from cleanup stack!");
408 
409   // If someone did an indirect goto, emit the indirect goto block at the end of
410   // the function.
411   if (IndirectBranch) {
412     EmitBlock(IndirectBranch->getParent());
413     Builder.ClearInsertionPoint();
414   }
415 
416   // If some of our locals escaped, insert a call to llvm.localescape in the
417   // entry block.
418   if (!EscapedLocals.empty()) {
419     // Invert the map from local to index into a simple vector. There should be
420     // no holes.
421     SmallVector<llvm::Value *, 4> EscapeArgs;
422     EscapeArgs.resize(EscapedLocals.size());
423     for (auto &Pair : EscapedLocals)
424       EscapeArgs[Pair.second] = Pair.first;
425     llvm::Function *FrameEscapeFn = llvm::Intrinsic::getDeclaration(
426         &CGM.getModule(), llvm::Intrinsic::localescape);
427     CGBuilderTy(*this, AllocaInsertPt).CreateCall(FrameEscapeFn, EscapeArgs);
428   }
429 
430   // Remove the AllocaInsertPt instruction, which is just a convenience for us.
431   llvm::Instruction *Ptr = AllocaInsertPt;
432   AllocaInsertPt = nullptr;
433   Ptr->eraseFromParent();
434 
435   // If someone took the address of a label but never did an indirect goto, we
436   // made a zero entry PHI node, which is illegal, zap it now.
437   if (IndirectBranch) {
438     llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress());
439     if (PN->getNumIncomingValues() == 0) {
440       PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType()));
441       PN->eraseFromParent();
442     }
443   }
444 
445   EmitIfUsed(*this, EHResumeBlock);
446   EmitIfUsed(*this, TerminateLandingPad);
447   EmitIfUsed(*this, TerminateHandler);
448   EmitIfUsed(*this, UnreachableBlock);
449 
450   for (const auto &FuncletAndParent : TerminateFunclets)
451     EmitIfUsed(*this, FuncletAndParent.second);
452 
453   if (CGM.getCodeGenOpts().EmitDeclMetadata)
454     EmitDeclMetadata();
455 
456   for (const auto &R : DeferredReplacements) {
457     if (llvm::Value *Old = R.first) {
458       Old->replaceAllUsesWith(R.second);
459       cast<llvm::Instruction>(Old)->eraseFromParent();
460     }
461   }
462   DeferredReplacements.clear();
463 
464   // Eliminate CleanupDestSlot alloca by replacing it with SSA values and
465   // PHIs if the current function is a coroutine. We don't do it for all
466   // functions as it may result in slight increase in numbers of instructions
467   // if compiled with no optimizations. We do it for coroutine as the lifetime
468   // of CleanupDestSlot alloca make correct coroutine frame building very
469   // difficult.
470   if (NormalCleanupDest.isValid() && isCoroutine()) {
471     llvm::DominatorTree DT(*CurFn);
472     llvm::PromoteMemToReg(
473         cast<llvm::AllocaInst>(NormalCleanupDest.getPointer()), DT);
474     NormalCleanupDest = Address::invalid();
475   }
476 
477   // Scan function arguments for vector width.
478   for (llvm::Argument &A : CurFn->args())
479     if (auto *VT = dyn_cast<llvm::VectorType>(A.getType()))
480       LargestVectorWidth =
481           std::max((uint64_t)LargestVectorWidth,
482                    VT->getPrimitiveSizeInBits().getKnownMinSize());
483 
484   // Update vector width based on return type.
485   if (auto *VT = dyn_cast<llvm::VectorType>(CurFn->getReturnType()))
486     LargestVectorWidth =
487         std::max((uint64_t)LargestVectorWidth,
488                  VT->getPrimitiveSizeInBits().getKnownMinSize());
489 
490   // Add the required-vector-width attribute. This contains the max width from:
491   // 1. min-vector-width attribute used in the source program.
492   // 2. Any builtins used that have a vector width specified.
493   // 3. Values passed in and out of inline assembly.
494   // 4. Width of vector arguments and return types for this function.
495   // 5. Width of vector aguments and return types for functions called by this
496   //    function.
497   CurFn->addFnAttr("min-legal-vector-width", llvm::utostr(LargestVectorWidth));
498 
499   // Add vscale attribute if appropriate.
500   if (getLangOpts().ArmSveVectorBits) {
501     unsigned VScale = getLangOpts().ArmSveVectorBits / 128;
502     CurFn->addFnAttr(llvm::Attribute::getWithVScaleRangeArgs(getLLVMContext(),
503                                                              VScale, VScale));
504   }
505 
506   // If we generated an unreachable return block, delete it now.
507   if (ReturnBlock.isValid() && ReturnBlock.getBlock()->use_empty()) {
508     Builder.ClearInsertionPoint();
509     ReturnBlock.getBlock()->eraseFromParent();
510   }
511   if (ReturnValue.isValid()) {
512     auto *RetAlloca = dyn_cast<llvm::AllocaInst>(ReturnValue.getPointer());
513     if (RetAlloca && RetAlloca->use_empty()) {
514       RetAlloca->eraseFromParent();
515       ReturnValue = Address::invalid();
516     }
517   }
518 }
519 
520 /// ShouldInstrumentFunction - Return true if the current function should be
521 /// instrumented with __cyg_profile_func_* calls
522 bool CodeGenFunction::ShouldInstrumentFunction() {
523   if (!CGM.getCodeGenOpts().InstrumentFunctions &&
524       !CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining &&
525       !CGM.getCodeGenOpts().InstrumentFunctionEntryBare)
526     return false;
527   if (!CurFuncDecl || CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>())
528     return false;
529   return true;
530 }
531 
532 /// ShouldXRayInstrument - Return true if the current function should be
533 /// instrumented with XRay nop sleds.
534 bool CodeGenFunction::ShouldXRayInstrumentFunction() const {
535   return CGM.getCodeGenOpts().XRayInstrumentFunctions;
536 }
537 
538 /// AlwaysEmitXRayCustomEvents - Return true if we should emit IR for calls to
539 /// the __xray_customevent(...) builtin calls, when doing XRay instrumentation.
540 bool CodeGenFunction::AlwaysEmitXRayCustomEvents() const {
541   return CGM.getCodeGenOpts().XRayInstrumentFunctions &&
542          (CGM.getCodeGenOpts().XRayAlwaysEmitCustomEvents ||
543           CGM.getCodeGenOpts().XRayInstrumentationBundle.Mask ==
544               XRayInstrKind::Custom);
545 }
546 
547 bool CodeGenFunction::AlwaysEmitXRayTypedEvents() const {
548   return CGM.getCodeGenOpts().XRayInstrumentFunctions &&
549          (CGM.getCodeGenOpts().XRayAlwaysEmitTypedEvents ||
550           CGM.getCodeGenOpts().XRayInstrumentationBundle.Mask ==
551               XRayInstrKind::Typed);
552 }
553 
554 llvm::Constant *
555 CodeGenFunction::EncodeAddrForUseInPrologue(llvm::Function *F,
556                                             llvm::Constant *Addr) {
557   // Addresses stored in prologue data can't require run-time fixups and must
558   // be PC-relative. Run-time fixups are undesirable because they necessitate
559   // writable text segments, which are unsafe. And absolute addresses are
560   // undesirable because they break PIE mode.
561 
562   // Add a layer of indirection through a private global. Taking its address
563   // won't result in a run-time fixup, even if Addr has linkonce_odr linkage.
564   auto *GV = new llvm::GlobalVariable(CGM.getModule(), Addr->getType(),
565                                       /*isConstant=*/true,
566                                       llvm::GlobalValue::PrivateLinkage, Addr);
567 
568   // Create a PC-relative address.
569   auto *GOTAsInt = llvm::ConstantExpr::getPtrToInt(GV, IntPtrTy);
570   auto *FuncAsInt = llvm::ConstantExpr::getPtrToInt(F, IntPtrTy);
571   auto *PCRelAsInt = llvm::ConstantExpr::getSub(GOTAsInt, FuncAsInt);
572   return (IntPtrTy == Int32Ty)
573              ? PCRelAsInt
574              : llvm::ConstantExpr::getTrunc(PCRelAsInt, Int32Ty);
575 }
576 
577 llvm::Value *
578 CodeGenFunction::DecodeAddrUsedInPrologue(llvm::Value *F,
579                                           llvm::Value *EncodedAddr) {
580   // Reconstruct the address of the global.
581   auto *PCRelAsInt = Builder.CreateSExt(EncodedAddr, IntPtrTy);
582   auto *FuncAsInt = Builder.CreatePtrToInt(F, IntPtrTy, "func_addr.int");
583   auto *GOTAsInt = Builder.CreateAdd(PCRelAsInt, FuncAsInt, "global_addr.int");
584   auto *GOTAddr = Builder.CreateIntToPtr(GOTAsInt, Int8PtrPtrTy, "global_addr");
585 
586   // Load the original pointer through the global.
587   return Builder.CreateLoad(Address(GOTAddr, getPointerAlign()),
588                             "decoded_addr");
589 }
590 
591 void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,
592                                                llvm::Function *Fn)
593 {
594   if (!FD->hasAttr<OpenCLKernelAttr>())
595     return;
596 
597   llvm::LLVMContext &Context = getLLVMContext();
598 
599   CGM.GenOpenCLArgMetadata(Fn, FD, this);
600 
601   if (const VecTypeHintAttr *A = FD->getAttr<VecTypeHintAttr>()) {
602     QualType HintQTy = A->getTypeHint();
603     const ExtVectorType *HintEltQTy = HintQTy->getAs<ExtVectorType>();
604     bool IsSignedInteger =
605         HintQTy->isSignedIntegerType() ||
606         (HintEltQTy && HintEltQTy->getElementType()->isSignedIntegerType());
607     llvm::Metadata *AttrMDArgs[] = {
608         llvm::ConstantAsMetadata::get(llvm::UndefValue::get(
609             CGM.getTypes().ConvertType(A->getTypeHint()))),
610         llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
611             llvm::IntegerType::get(Context, 32),
612             llvm::APInt(32, (uint64_t)(IsSignedInteger ? 1 : 0))))};
613     Fn->setMetadata("vec_type_hint", llvm::MDNode::get(Context, AttrMDArgs));
614   }
615 
616   if (const WorkGroupSizeHintAttr *A = FD->getAttr<WorkGroupSizeHintAttr>()) {
617     llvm::Metadata *AttrMDArgs[] = {
618         llvm::ConstantAsMetadata::get(Builder.getInt32(A->getXDim())),
619         llvm::ConstantAsMetadata::get(Builder.getInt32(A->getYDim())),
620         llvm::ConstantAsMetadata::get(Builder.getInt32(A->getZDim()))};
621     Fn->setMetadata("work_group_size_hint", llvm::MDNode::get(Context, AttrMDArgs));
622   }
623 
624   if (const ReqdWorkGroupSizeAttr *A = FD->getAttr<ReqdWorkGroupSizeAttr>()) {
625     llvm::Metadata *AttrMDArgs[] = {
626         llvm::ConstantAsMetadata::get(Builder.getInt32(A->getXDim())),
627         llvm::ConstantAsMetadata::get(Builder.getInt32(A->getYDim())),
628         llvm::ConstantAsMetadata::get(Builder.getInt32(A->getZDim()))};
629     Fn->setMetadata("reqd_work_group_size", llvm::MDNode::get(Context, AttrMDArgs));
630   }
631 
632   if (const OpenCLIntelReqdSubGroupSizeAttr *A =
633           FD->getAttr<OpenCLIntelReqdSubGroupSizeAttr>()) {
634     llvm::Metadata *AttrMDArgs[] = {
635         llvm::ConstantAsMetadata::get(Builder.getInt32(A->getSubGroupSize()))};
636     Fn->setMetadata("intel_reqd_sub_group_size",
637                     llvm::MDNode::get(Context, AttrMDArgs));
638   }
639 }
640 
641 /// Determine whether the function F ends with a return stmt.
642 static bool endsWithReturn(const Decl* F) {
643   const Stmt *Body = nullptr;
644   if (auto *FD = dyn_cast_or_null<FunctionDecl>(F))
645     Body = FD->getBody();
646   else if (auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(F))
647     Body = OMD->getBody();
648 
649   if (auto *CS = dyn_cast_or_null<CompoundStmt>(Body)) {
650     auto LastStmt = CS->body_rbegin();
651     if (LastStmt != CS->body_rend())
652       return isa<ReturnStmt>(*LastStmt);
653   }
654   return false;
655 }
656 
657 void CodeGenFunction::markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn) {
658   if (SanOpts.has(SanitizerKind::Thread)) {
659     Fn->addFnAttr("sanitize_thread_no_checking_at_run_time");
660     Fn->removeFnAttr(llvm::Attribute::SanitizeThread);
661   }
662 }
663 
664 /// Check if the return value of this function requires sanitization.
665 bool CodeGenFunction::requiresReturnValueCheck() const {
666   return requiresReturnValueNullabilityCheck() ||
667          (SanOpts.has(SanitizerKind::ReturnsNonnullAttribute) && CurCodeDecl &&
668           CurCodeDecl->getAttr<ReturnsNonNullAttr>());
669 }
670 
671 static bool matchesStlAllocatorFn(const Decl *D, const ASTContext &Ctx) {
672   auto *MD = dyn_cast_or_null<CXXMethodDecl>(D);
673   if (!MD || !MD->getDeclName().getAsIdentifierInfo() ||
674       !MD->getDeclName().getAsIdentifierInfo()->isStr("allocate") ||
675       (MD->getNumParams() != 1 && MD->getNumParams() != 2))
676     return false;
677 
678   if (MD->parameters()[0]->getType().getCanonicalType() != Ctx.getSizeType())
679     return false;
680 
681   if (MD->getNumParams() == 2) {
682     auto *PT = MD->parameters()[1]->getType()->getAs<PointerType>();
683     if (!PT || !PT->isVoidPointerType() ||
684         !PT->getPointeeType().isConstQualified())
685       return false;
686   }
687 
688   return true;
689 }
690 
691 /// Return the UBSan prologue signature for \p FD if one is available.
692 static llvm::Constant *getPrologueSignature(CodeGenModule &CGM,
693                                             const FunctionDecl *FD) {
694   if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
695     if (!MD->isStatic())
696       return nullptr;
697   return CGM.getTargetCodeGenInfo().getUBSanFunctionSignature(CGM);
698 }
699 
700 void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,
701                                     llvm::Function *Fn,
702                                     const CGFunctionInfo &FnInfo,
703                                     const FunctionArgList &Args,
704                                     SourceLocation Loc,
705                                     SourceLocation StartLoc) {
706   assert(!CurFn &&
707          "Do not use a CodeGenFunction object for more than one function");
708 
709   const Decl *D = GD.getDecl();
710 
711   DidCallStackSave = false;
712   CurCodeDecl = D;
713   const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
714   if (FD && FD->usesSEHTry())
715     CurSEHParent = FD;
716   CurFuncDecl = (D ? D->getNonClosureContext() : nullptr);
717   FnRetTy = RetTy;
718   CurFn = Fn;
719   CurFnInfo = &FnInfo;
720   assert(CurFn->isDeclaration() && "Function already has body?");
721 
722   // If this function is ignored for any of the enabled sanitizers,
723   // disable the sanitizer for the function.
724   do {
725 #define SANITIZER(NAME, ID)                                                    \
726   if (SanOpts.empty())                                                         \
727     break;                                                                     \
728   if (SanOpts.has(SanitizerKind::ID))                                          \
729     if (CGM.isInNoSanitizeList(SanitizerKind::ID, Fn, Loc))                    \
730       SanOpts.set(SanitizerKind::ID, false);
731 
732 #include "clang/Basic/Sanitizers.def"
733 #undef SANITIZER
734   } while (0);
735 
736   if (D) {
737     bool NoSanitizeCoverage = false;
738 
739     for (auto Attr : D->specific_attrs<NoSanitizeAttr>()) {
740       // Apply the no_sanitize* attributes to SanOpts.
741       SanitizerMask mask = Attr->getMask();
742       SanOpts.Mask &= ~mask;
743       if (mask & SanitizerKind::Address)
744         SanOpts.set(SanitizerKind::KernelAddress, false);
745       if (mask & SanitizerKind::KernelAddress)
746         SanOpts.set(SanitizerKind::Address, false);
747       if (mask & SanitizerKind::HWAddress)
748         SanOpts.set(SanitizerKind::KernelHWAddress, false);
749       if (mask & SanitizerKind::KernelHWAddress)
750         SanOpts.set(SanitizerKind::HWAddress, false);
751 
752       // SanitizeCoverage is not handled by SanOpts.
753       if (Attr->hasCoverage())
754         NoSanitizeCoverage = true;
755     }
756 
757     if (NoSanitizeCoverage && CGM.getCodeGenOpts().hasSanitizeCoverage())
758       Fn->addFnAttr(llvm::Attribute::NoSanitizeCoverage);
759   }
760 
761   // Apply sanitizer attributes to the function.
762   if (SanOpts.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress))
763     Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
764   if (SanOpts.hasOneOf(SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress))
765     Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
766   if (SanOpts.has(SanitizerKind::MemTag))
767     Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);
768   if (SanOpts.has(SanitizerKind::Thread))
769     Fn->addFnAttr(llvm::Attribute::SanitizeThread);
770   if (SanOpts.hasOneOf(SanitizerKind::Memory | SanitizerKind::KernelMemory))
771     Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
772   if (SanOpts.has(SanitizerKind::SafeStack))
773     Fn->addFnAttr(llvm::Attribute::SafeStack);
774   if (SanOpts.has(SanitizerKind::ShadowCallStack))
775     Fn->addFnAttr(llvm::Attribute::ShadowCallStack);
776 
777   // Apply fuzzing attribute to the function.
778   if (SanOpts.hasOneOf(SanitizerKind::Fuzzer | SanitizerKind::FuzzerNoLink))
779     Fn->addFnAttr(llvm::Attribute::OptForFuzzing);
780 
781   // Ignore TSan memory acesses from within ObjC/ObjC++ dealloc, initialize,
782   // .cxx_destruct, __destroy_helper_block_ and all of their calees at run time.
783   if (SanOpts.has(SanitizerKind::Thread)) {
784     if (const auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(D)) {
785       IdentifierInfo *II = OMD->getSelector().getIdentifierInfoForSlot(0);
786       if (OMD->getMethodFamily() == OMF_dealloc ||
787           OMD->getMethodFamily() == OMF_initialize ||
788           (OMD->getSelector().isUnarySelector() && II->isStr(".cxx_destruct"))) {
789         markAsIgnoreThreadCheckingAtRuntime(Fn);
790       }
791     }
792   }
793 
794   // Ignore unrelated casts in STL allocate() since the allocator must cast
795   // from void* to T* before object initialization completes. Don't match on the
796   // namespace because not all allocators are in std::
797   if (D && SanOpts.has(SanitizerKind::CFIUnrelatedCast)) {
798     if (matchesStlAllocatorFn(D, getContext()))
799       SanOpts.Mask &= ~SanitizerKind::CFIUnrelatedCast;
800   }
801 
802   // Ignore null checks in coroutine functions since the coroutines passes
803   // are not aware of how to move the extra UBSan instructions across the split
804   // coroutine boundaries.
805   if (D && SanOpts.has(SanitizerKind::Null))
806     if (FD && FD->getBody() &&
807         FD->getBody()->getStmtClass() == Stmt::CoroutineBodyStmtClass)
808       SanOpts.Mask &= ~SanitizerKind::Null;
809 
810   // Apply xray attributes to the function (as a string, for now)
811   bool AlwaysXRayAttr = false;
812   if (const auto *XRayAttr = D ? D->getAttr<XRayInstrumentAttr>() : nullptr) {
813     if (CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
814             XRayInstrKind::FunctionEntry) ||
815         CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
816             XRayInstrKind::FunctionExit)) {
817       if (XRayAttr->alwaysXRayInstrument() && ShouldXRayInstrumentFunction()) {
818         Fn->addFnAttr("function-instrument", "xray-always");
819         AlwaysXRayAttr = true;
820       }
821       if (XRayAttr->neverXRayInstrument())
822         Fn->addFnAttr("function-instrument", "xray-never");
823       if (const auto *LogArgs = D->getAttr<XRayLogArgsAttr>())
824         if (ShouldXRayInstrumentFunction())
825           Fn->addFnAttr("xray-log-args",
826                         llvm::utostr(LogArgs->getArgumentCount()));
827     }
828   } else {
829     if (ShouldXRayInstrumentFunction() && !CGM.imbueXRayAttrs(Fn, Loc))
830       Fn->addFnAttr(
831           "xray-instruction-threshold",
832           llvm::itostr(CGM.getCodeGenOpts().XRayInstructionThreshold));
833   }
834 
835   if (ShouldXRayInstrumentFunction()) {
836     if (CGM.getCodeGenOpts().XRayIgnoreLoops)
837       Fn->addFnAttr("xray-ignore-loops");
838 
839     if (!CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
840             XRayInstrKind::FunctionExit))
841       Fn->addFnAttr("xray-skip-exit");
842 
843     if (!CGM.getCodeGenOpts().XRayInstrumentationBundle.has(
844             XRayInstrKind::FunctionEntry))
845       Fn->addFnAttr("xray-skip-entry");
846 
847     auto FuncGroups = CGM.getCodeGenOpts().XRayTotalFunctionGroups;
848     if (FuncGroups > 1) {
849       auto FuncName = llvm::makeArrayRef<uint8_t>(
850           CurFn->getName().bytes_begin(), CurFn->getName().bytes_end());
851       auto Group = crc32(FuncName) % FuncGroups;
852       if (Group != CGM.getCodeGenOpts().XRaySelectedFunctionGroup &&
853           !AlwaysXRayAttr)
854         Fn->addFnAttr("function-instrument", "xray-never");
855     }
856   }
857 
858   if (CGM.getCodeGenOpts().getProfileInstr() != CodeGenOptions::ProfileNone)
859     if (CGM.isProfileInstrExcluded(Fn, Loc))
860       Fn->addFnAttr(llvm::Attribute::NoProfile);
861 
862   unsigned Count, Offset;
863   if (const auto *Attr =
864           D ? D->getAttr<PatchableFunctionEntryAttr>() : nullptr) {
865     Count = Attr->getCount();
866     Offset = Attr->getOffset();
867   } else {
868     Count = CGM.getCodeGenOpts().PatchableFunctionEntryCount;
869     Offset = CGM.getCodeGenOpts().PatchableFunctionEntryOffset;
870   }
871   if (Count && Offset <= Count) {
872     Fn->addFnAttr("patchable-function-entry", std::to_string(Count - Offset));
873     if (Offset)
874       Fn->addFnAttr("patchable-function-prefix", std::to_string(Offset));
875   }
876 
877   // Add no-jump-tables value.
878   if (CGM.getCodeGenOpts().NoUseJumpTables)
879     Fn->addFnAttr("no-jump-tables", "true");
880 
881   // Add no-inline-line-tables value.
882   if (CGM.getCodeGenOpts().NoInlineLineTables)
883     Fn->addFnAttr("no-inline-line-tables");
884 
885   // Add profile-sample-accurate value.
886   if (CGM.getCodeGenOpts().ProfileSampleAccurate)
887     Fn->addFnAttr("profile-sample-accurate");
888 
889   if (!CGM.getCodeGenOpts().SampleProfileFile.empty())
890     Fn->addFnAttr("use-sample-profile");
891 
892   if (D && D->hasAttr<CFICanonicalJumpTableAttr>())
893     Fn->addFnAttr("cfi-canonical-jump-table");
894 
895   if (D && D->hasAttr<NoProfileFunctionAttr>())
896     Fn->addFnAttr(llvm::Attribute::NoProfile);
897 
898   if (FD && getLangOpts().OpenCL) {
899     // Add metadata for a kernel function.
900     EmitOpenCLKernelMetadata(FD, Fn);
901   }
902 
903   // If we are checking function types, emit a function type signature as
904   // prologue data.
905   if (FD && getLangOpts().CPlusPlus && SanOpts.has(SanitizerKind::Function)) {
906     if (llvm::Constant *PrologueSig = getPrologueSignature(CGM, FD)) {
907       // Remove any (C++17) exception specifications, to allow calling e.g. a
908       // noexcept function through a non-noexcept pointer.
909       auto ProtoTy = getContext().getFunctionTypeWithExceptionSpec(
910           FD->getType(), EST_None);
911       llvm::Constant *FTRTTIConst =
912           CGM.GetAddrOfRTTIDescriptor(ProtoTy, /*ForEH=*/true);
913       llvm::Constant *FTRTTIConstEncoded =
914           EncodeAddrForUseInPrologue(Fn, FTRTTIConst);
915       llvm::Constant *PrologueStructElems[] = {PrologueSig, FTRTTIConstEncoded};
916       llvm::Constant *PrologueStructConst =
917           llvm::ConstantStruct::getAnon(PrologueStructElems, /*Packed=*/true);
918       Fn->setPrologueData(PrologueStructConst);
919     }
920   }
921 
922   // If we're checking nullability, we need to know whether we can check the
923   // return value. Initialize the flag to 'true' and refine it in EmitParmDecl.
924   if (SanOpts.has(SanitizerKind::NullabilityReturn)) {
925     auto Nullability = FnRetTy->getNullability(getContext());
926     if (Nullability && *Nullability == NullabilityKind::NonNull) {
927       if (!(SanOpts.has(SanitizerKind::ReturnsNonnullAttribute) &&
928             CurCodeDecl && CurCodeDecl->getAttr<ReturnsNonNullAttr>()))
929         RetValNullabilityPrecondition =
930             llvm::ConstantInt::getTrue(getLLVMContext());
931     }
932   }
933 
934   // If we're in C++ mode and the function name is "main", it is guaranteed
935   // to be norecurse by the standard (3.6.1.3 "The function main shall not be
936   // used within a program").
937   //
938   // OpenCL C 2.0 v2.2-11 s6.9.i:
939   //     Recursion is not supported.
940   //
941   // SYCL v1.2.1 s3.10:
942   //     kernels cannot include RTTI information, exception classes,
943   //     recursive code, virtual functions or make use of C++ libraries that
944   //     are not compiled for the device.
945   if (FD && ((getLangOpts().CPlusPlus && FD->isMain()) ||
946              getLangOpts().OpenCL || getLangOpts().SYCLIsDevice ||
947              (getLangOpts().CUDA && FD->hasAttr<CUDAGlobalAttr>())))
948     Fn->addFnAttr(llvm::Attribute::NoRecurse);
949 
950   if (FD) {
951     Builder.setIsFPConstrained(FD->hasAttr<StrictFPAttr>());
952     if (FD->hasAttr<StrictFPAttr>())
953       Fn->addFnAttr(llvm::Attribute::StrictFP);
954   }
955 
956   // If a custom alignment is used, force realigning to this alignment on
957   // any main function which certainly will need it.
958   if (FD && ((FD->isMain() || FD->isMSVCRTEntryPoint()) &&
959              CGM.getCodeGenOpts().StackAlignment))
960     Fn->addFnAttr("stackrealign");
961 
962   llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn);
963 
964   // Create a marker to make it easy to insert allocas into the entryblock
965   // later.  Don't create this with the builder, because we don't want it
966   // folded.
967   llvm::Value *Undef = llvm::UndefValue::get(Int32Ty);
968   AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "allocapt", EntryBB);
969 
970   ReturnBlock = getJumpDestInCurrentScope("return");
971 
972   Builder.SetInsertPoint(EntryBB);
973 
974   // If we're checking the return value, allocate space for a pointer to a
975   // precise source location of the checked return statement.
976   if (requiresReturnValueCheck()) {
977     ReturnLocation = CreateDefaultAlignTempAlloca(Int8PtrTy, "return.sloc.ptr");
978     InitTempAlloca(ReturnLocation, llvm::ConstantPointerNull::get(Int8PtrTy));
979   }
980 
981   // Emit subprogram debug descriptor.
982   if (CGDebugInfo *DI = getDebugInfo()) {
983     // Reconstruct the type from the argument list so that implicit parameters,
984     // such as 'this' and 'vtt', show up in the debug info. Preserve the calling
985     // convention.
986     CallingConv CC = CallingConv::CC_C;
987     if (FD)
988       if (const auto *SrcFnTy = FD->getType()->getAs<FunctionType>())
989         CC = SrcFnTy->getCallConv();
990     SmallVector<QualType, 16> ArgTypes;
991     for (const VarDecl *VD : Args)
992       ArgTypes.push_back(VD->getType());
993     QualType FnType = getContext().getFunctionType(
994         RetTy, ArgTypes, FunctionProtoType::ExtProtoInfo(CC));
995     DI->emitFunctionStart(GD, Loc, StartLoc, FnType, CurFn, CurFuncIsThunk);
996   }
997 
998   if (ShouldInstrumentFunction()) {
999     if (CGM.getCodeGenOpts().InstrumentFunctions)
1000       CurFn->addFnAttr("instrument-function-entry", "__cyg_profile_func_enter");
1001     if (CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining)
1002       CurFn->addFnAttr("instrument-function-entry-inlined",
1003                        "__cyg_profile_func_enter");
1004     if (CGM.getCodeGenOpts().InstrumentFunctionEntryBare)
1005       CurFn->addFnAttr("instrument-function-entry-inlined",
1006                        "__cyg_profile_func_enter_bare");
1007   }
1008 
1009   // Since emitting the mcount call here impacts optimizations such as function
1010   // inlining, we just add an attribute to insert a mcount call in backend.
1011   // The attribute "counting-function" is set to mcount function name which is
1012   // architecture dependent.
1013   if (CGM.getCodeGenOpts().InstrumentForProfiling) {
1014     // Calls to fentry/mcount should not be generated if function has
1015     // the no_instrument_function attribute.
1016     if (!CurFuncDecl || !CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>()) {
1017       if (CGM.getCodeGenOpts().CallFEntry)
1018         Fn->addFnAttr("fentry-call", "true");
1019       else {
1020         Fn->addFnAttr("instrument-function-entry-inlined",
1021                       getTarget().getMCountName());
1022       }
1023       if (CGM.getCodeGenOpts().MNopMCount) {
1024         if (!CGM.getCodeGenOpts().CallFEntry)
1025           CGM.getDiags().Report(diag::err_opt_not_valid_without_opt)
1026             << "-mnop-mcount" << "-mfentry";
1027         Fn->addFnAttr("mnop-mcount");
1028       }
1029 
1030       if (CGM.getCodeGenOpts().RecordMCount) {
1031         if (!CGM.getCodeGenOpts().CallFEntry)
1032           CGM.getDiags().Report(diag::err_opt_not_valid_without_opt)
1033             << "-mrecord-mcount" << "-mfentry";
1034         Fn->addFnAttr("mrecord-mcount");
1035       }
1036     }
1037   }
1038 
1039   if (CGM.getCodeGenOpts().PackedStack) {
1040     if (getContext().getTargetInfo().getTriple().getArch() !=
1041         llvm::Triple::systemz)
1042       CGM.getDiags().Report(diag::err_opt_not_valid_on_target)
1043         << "-mpacked-stack";
1044     Fn->addFnAttr("packed-stack");
1045   }
1046 
1047   if (CGM.getCodeGenOpts().WarnStackSize != UINT_MAX)
1048     Fn->addFnAttr("warn-stack-size",
1049                   std::to_string(CGM.getCodeGenOpts().WarnStackSize));
1050 
1051   if (RetTy->isVoidType()) {
1052     // Void type; nothing to return.
1053     ReturnValue = Address::invalid();
1054 
1055     // Count the implicit return.
1056     if (!endsWithReturn(D))
1057       ++NumReturnExprs;
1058   } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::Indirect) {
1059     // Indirect return; emit returned value directly into sret slot.
1060     // This reduces code size, and affects correctness in C++.
1061     auto AI = CurFn->arg_begin();
1062     if (CurFnInfo->getReturnInfo().isSRetAfterThis())
1063       ++AI;
1064     ReturnValue = Address(&*AI, CurFnInfo->getReturnInfo().getIndirectAlign());
1065     if (!CurFnInfo->getReturnInfo().getIndirectByVal()) {
1066       ReturnValuePointer =
1067           CreateDefaultAlignTempAlloca(Int8PtrTy, "result.ptr");
1068       Builder.CreateStore(Builder.CreatePointerBitCastOrAddrSpaceCast(
1069                               ReturnValue.getPointer(), Int8PtrTy),
1070                           ReturnValuePointer);
1071     }
1072   } else if (CurFnInfo->getReturnInfo().getKind() == ABIArgInfo::InAlloca &&
1073              !hasScalarEvaluationKind(CurFnInfo->getReturnType())) {
1074     // Load the sret pointer from the argument struct and return into that.
1075     unsigned Idx = CurFnInfo->getReturnInfo().getInAllocaFieldIndex();
1076     llvm::Function::arg_iterator EI = CurFn->arg_end();
1077     --EI;
1078     llvm::Value *Addr = Builder.CreateStructGEP(
1079         EI->getType()->getPointerElementType(), &*EI, Idx);
1080     llvm::Type *Ty =
1081         cast<llvm::GetElementPtrInst>(Addr)->getResultElementType();
1082     ReturnValuePointer = Address(Addr, getPointerAlign());
1083     Addr = Builder.CreateAlignedLoad(Ty, Addr, getPointerAlign(), "agg.result");
1084     ReturnValue = Address(Addr, CGM.getNaturalTypeAlignment(RetTy));
1085   } else {
1086     ReturnValue = CreateIRTemp(RetTy, "retval");
1087 
1088     // Tell the epilog emitter to autorelease the result.  We do this
1089     // now so that various specialized functions can suppress it
1090     // during their IR-generation.
1091     if (getLangOpts().ObjCAutoRefCount &&
1092         !CurFnInfo->isReturnsRetained() &&
1093         RetTy->isObjCRetainableType())
1094       AutoreleaseResult = true;
1095   }
1096 
1097   EmitStartEHSpec(CurCodeDecl);
1098 
1099   PrologueCleanupDepth = EHStack.stable_begin();
1100 
1101   // Emit OpenMP specific initialization of the device functions.
1102   if (getLangOpts().OpenMP && CurCodeDecl)
1103     CGM.getOpenMPRuntime().emitFunctionProlog(*this, CurCodeDecl);
1104 
1105   EmitFunctionProlog(*CurFnInfo, CurFn, Args);
1106 
1107   if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) {
1108     CGM.getCXXABI().EmitInstanceFunctionProlog(*this);
1109     const CXXMethodDecl *MD = cast<CXXMethodDecl>(D);
1110     if (MD->getParent()->isLambda() &&
1111         MD->getOverloadedOperator() == OO_Call) {
1112       // We're in a lambda; figure out the captures.
1113       MD->getParent()->getCaptureFields(LambdaCaptureFields,
1114                                         LambdaThisCaptureField);
1115       if (LambdaThisCaptureField) {
1116         // If the lambda captures the object referred to by '*this' - either by
1117         // value or by reference, make sure CXXThisValue points to the correct
1118         // object.
1119 
1120         // Get the lvalue for the field (which is a copy of the enclosing object
1121         // or contains the address of the enclosing object).
1122         LValue ThisFieldLValue = EmitLValueForLambdaField(LambdaThisCaptureField);
1123         if (!LambdaThisCaptureField->getType()->isPointerType()) {
1124           // If the enclosing object was captured by value, just use its address.
1125           CXXThisValue = ThisFieldLValue.getAddress(*this).getPointer();
1126         } else {
1127           // Load the lvalue pointed to by the field, since '*this' was captured
1128           // by reference.
1129           CXXThisValue =
1130               EmitLoadOfLValue(ThisFieldLValue, SourceLocation()).getScalarVal();
1131         }
1132       }
1133       for (auto *FD : MD->getParent()->fields()) {
1134         if (FD->hasCapturedVLAType()) {
1135           auto *ExprArg = EmitLoadOfLValue(EmitLValueForLambdaField(FD),
1136                                            SourceLocation()).getScalarVal();
1137           auto VAT = FD->getCapturedVLAType();
1138           VLASizeMap[VAT->getSizeExpr()] = ExprArg;
1139         }
1140       }
1141     } else {
1142       // Not in a lambda; just use 'this' from the method.
1143       // FIXME: Should we generate a new load for each use of 'this'?  The
1144       // fast register allocator would be happier...
1145       CXXThisValue = CXXABIThisValue;
1146     }
1147 
1148     // Check the 'this' pointer once per function, if it's available.
1149     if (CXXABIThisValue) {
1150       SanitizerSet SkippedChecks;
1151       SkippedChecks.set(SanitizerKind::ObjectSize, true);
1152       QualType ThisTy = MD->getThisType();
1153 
1154       // If this is the call operator of a lambda with no capture-default, it
1155       // may have a static invoker function, which may call this operator with
1156       // a null 'this' pointer.
1157       if (isLambdaCallOperator(MD) &&
1158           MD->getParent()->getLambdaCaptureDefault() == LCD_None)
1159         SkippedChecks.set(SanitizerKind::Null, true);
1160 
1161       EmitTypeCheck(
1162           isa<CXXConstructorDecl>(MD) ? TCK_ConstructorCall : TCK_MemberCall,
1163           Loc, CXXABIThisValue, ThisTy, CXXABIThisAlignment, SkippedChecks);
1164     }
1165   }
1166 
1167   // If any of the arguments have a variably modified type, make sure to
1168   // emit the type size.
1169   for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
1170        i != e; ++i) {
1171     const VarDecl *VD = *i;
1172 
1173     // Dig out the type as written from ParmVarDecls; it's unclear whether
1174     // the standard (C99 6.9.1p10) requires this, but we're following the
1175     // precedent set by gcc.
1176     QualType Ty;
1177     if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD))
1178       Ty = PVD->getOriginalType();
1179     else
1180       Ty = VD->getType();
1181 
1182     if (Ty->isVariablyModifiedType())
1183       EmitVariablyModifiedType(Ty);
1184   }
1185   // Emit a location at the end of the prologue.
1186   if (CGDebugInfo *DI = getDebugInfo())
1187     DI->EmitLocation(Builder, StartLoc);
1188 
1189   // TODO: Do we need to handle this in two places like we do with
1190   // target-features/target-cpu?
1191   if (CurFuncDecl)
1192     if (const auto *VecWidth = CurFuncDecl->getAttr<MinVectorWidthAttr>())
1193       LargestVectorWidth = VecWidth->getVectorWidth();
1194 }
1195 
1196 void CodeGenFunction::EmitFunctionBody(const Stmt *Body) {
1197   incrementProfileCounter(Body);
1198   if (const CompoundStmt *S = dyn_cast<CompoundStmt>(Body))
1199     EmitCompoundStmtWithoutScope(*S);
1200   else
1201     EmitStmt(Body);
1202 
1203   // This is checked after emitting the function body so we know if there
1204   // are any permitted infinite loops.
1205   if (checkIfFunctionMustProgress())
1206     CurFn->addFnAttr(llvm::Attribute::MustProgress);
1207 }
1208 
1209 /// When instrumenting to collect profile data, the counts for some blocks
1210 /// such as switch cases need to not include the fall-through counts, so
1211 /// emit a branch around the instrumentation code. When not instrumenting,
1212 /// this just calls EmitBlock().
1213 void CodeGenFunction::EmitBlockWithFallThrough(llvm::BasicBlock *BB,
1214                                                const Stmt *S) {
1215   llvm::BasicBlock *SkipCountBB = nullptr;
1216   if (HaveInsertPoint() && CGM.getCodeGenOpts().hasProfileClangInstr()) {
1217     // When instrumenting for profiling, the fallthrough to certain
1218     // statements needs to skip over the instrumentation code so that we
1219     // get an accurate count.
1220     SkipCountBB = createBasicBlock("skipcount");
1221     EmitBranch(SkipCountBB);
1222   }
1223   EmitBlock(BB);
1224   uint64_t CurrentCount = getCurrentProfileCount();
1225   incrementProfileCounter(S);
1226   setCurrentProfileCount(getCurrentProfileCount() + CurrentCount);
1227   if (SkipCountBB)
1228     EmitBlock(SkipCountBB);
1229 }
1230 
1231 /// Tries to mark the given function nounwind based on the
1232 /// non-existence of any throwing calls within it.  We believe this is
1233 /// lightweight enough to do at -O0.
1234 static void TryMarkNoThrow(llvm::Function *F) {
1235   // LLVM treats 'nounwind' on a function as part of the type, so we
1236   // can't do this on functions that can be overwritten.
1237   if (F->isInterposable()) return;
1238 
1239   for (llvm::BasicBlock &BB : *F)
1240     for (llvm::Instruction &I : BB)
1241       if (I.mayThrow())
1242         return;
1243 
1244   F->setDoesNotThrow();
1245 }
1246 
1247 QualType CodeGenFunction::BuildFunctionArgList(GlobalDecl GD,
1248                                                FunctionArgList &Args) {
1249   const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
1250   QualType ResTy = FD->getReturnType();
1251 
1252   const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
1253   if (MD && MD->isInstance()) {
1254     if (CGM.getCXXABI().HasThisReturn(GD))
1255       ResTy = MD->getThisType();
1256     else if (CGM.getCXXABI().hasMostDerivedReturn(GD))
1257       ResTy = CGM.getContext().VoidPtrTy;
1258     CGM.getCXXABI().buildThisParam(*this, Args);
1259   }
1260 
1261   // The base version of an inheriting constructor whose constructed base is a
1262   // virtual base is not passed any arguments (because it doesn't actually call
1263   // the inherited constructor).
1264   bool PassedParams = true;
1265   if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD))
1266     if (auto Inherited = CD->getInheritedConstructor())
1267       PassedParams =
1268           getTypes().inheritingCtorHasParams(Inherited, GD.getCtorType());
1269 
1270   if (PassedParams) {
1271     for (auto *Param : FD->parameters()) {
1272       Args.push_back(Param);
1273       if (!Param->hasAttr<PassObjectSizeAttr>())
1274         continue;
1275 
1276       auto *Implicit = ImplicitParamDecl::Create(
1277           getContext(), Param->getDeclContext(), Param->getLocation(),
1278           /*Id=*/nullptr, getContext().getSizeType(), ImplicitParamDecl::Other);
1279       SizeArguments[Param] = Implicit;
1280       Args.push_back(Implicit);
1281     }
1282   }
1283 
1284   if (MD && (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)))
1285     CGM.getCXXABI().addImplicitStructorParams(*this, ResTy, Args);
1286 
1287   return ResTy;
1288 }
1289 
1290 void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn,
1291                                    const CGFunctionInfo &FnInfo) {
1292   const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
1293   CurGD = GD;
1294 
1295   FunctionArgList Args;
1296   QualType ResTy = BuildFunctionArgList(GD, Args);
1297 
1298   // Check if we should generate debug info for this function.
1299   if (FD->hasAttr<NoDebugAttr>()) {
1300     // Clear non-distinct debug info that was possibly attached to the function
1301     // due to an earlier declaration without the nodebug attribute
1302     if (Fn)
1303       Fn->setSubprogram(nullptr);
1304     // Disable debug info indefinitely for this function
1305     DebugInfo = nullptr;
1306   }
1307 
1308   // The function might not have a body if we're generating thunks for a
1309   // function declaration.
1310   SourceRange BodyRange;
1311   if (Stmt *Body = FD->getBody())
1312     BodyRange = Body->getSourceRange();
1313   else
1314     BodyRange = FD->getLocation();
1315   CurEHLocation = BodyRange.getEnd();
1316 
1317   // Use the location of the start of the function to determine where
1318   // the function definition is located. By default use the location
1319   // of the declaration as the location for the subprogram. A function
1320   // may lack a declaration in the source code if it is created by code
1321   // gen. (examples: _GLOBAL__I_a, __cxx_global_array_dtor, thunk).
1322   SourceLocation Loc = FD->getLocation();
1323 
1324   // If this is a function specialization then use the pattern body
1325   // as the location for the function.
1326   if (const FunctionDecl *SpecDecl = FD->getTemplateInstantiationPattern())
1327     if (SpecDecl->hasBody(SpecDecl))
1328       Loc = SpecDecl->getLocation();
1329 
1330   Stmt *Body = FD->getBody();
1331 
1332   if (Body) {
1333     // Coroutines always emit lifetime markers.
1334     if (isa<CoroutineBodyStmt>(Body))
1335       ShouldEmitLifetimeMarkers = true;
1336 
1337     // Initialize helper which will detect jumps which can cause invalid
1338     // lifetime markers.
1339     if (ShouldEmitLifetimeMarkers)
1340       Bypasses.Init(Body);
1341   }
1342 
1343   // Emit the standard function prologue.
1344   StartFunction(GD, ResTy, Fn, FnInfo, Args, Loc, BodyRange.getBegin());
1345 
1346   // Save parameters for coroutine function.
1347   if (Body && isa_and_nonnull<CoroutineBodyStmt>(Body))
1348     for (const auto *ParamDecl : FD->parameters())
1349       FnArgs.push_back(ParamDecl);
1350 
1351   // Generate the body of the function.
1352   PGO.assignRegionCounters(GD, CurFn);
1353   if (isa<CXXDestructorDecl>(FD))
1354     EmitDestructorBody(Args);
1355   else if (isa<CXXConstructorDecl>(FD))
1356     EmitConstructorBody(Args);
1357   else if (getLangOpts().CUDA &&
1358            !getLangOpts().CUDAIsDevice &&
1359            FD->hasAttr<CUDAGlobalAttr>())
1360     CGM.getCUDARuntime().emitDeviceStub(*this, Args);
1361   else if (isa<CXXMethodDecl>(FD) &&
1362            cast<CXXMethodDecl>(FD)->isLambdaStaticInvoker()) {
1363     // The lambda static invoker function is special, because it forwards or
1364     // clones the body of the function call operator (but is actually static).
1365     EmitLambdaStaticInvokeBody(cast<CXXMethodDecl>(FD));
1366   } else if (FD->isDefaulted() && isa<CXXMethodDecl>(FD) &&
1367              (cast<CXXMethodDecl>(FD)->isCopyAssignmentOperator() ||
1368               cast<CXXMethodDecl>(FD)->isMoveAssignmentOperator())) {
1369     // Implicit copy-assignment gets the same special treatment as implicit
1370     // copy-constructors.
1371     emitImplicitAssignmentOperatorBody(Args);
1372   } else if (Body) {
1373     EmitFunctionBody(Body);
1374   } else
1375     llvm_unreachable("no definition for emitted function");
1376 
1377   // C++11 [stmt.return]p2:
1378   //   Flowing off the end of a function [...] results in undefined behavior in
1379   //   a value-returning function.
1380   // C11 6.9.1p12:
1381   //   If the '}' that terminates a function is reached, and the value of the
1382   //   function call is used by the caller, the behavior is undefined.
1383   if (getLangOpts().CPlusPlus && !FD->hasImplicitReturnZero() && !SawAsmBlock &&
1384       !FD->getReturnType()->isVoidType() && Builder.GetInsertBlock()) {
1385     bool ShouldEmitUnreachable =
1386         CGM.getCodeGenOpts().StrictReturn ||
1387         !CGM.MayDropFunctionReturn(FD->getASTContext(), FD->getReturnType());
1388     if (SanOpts.has(SanitizerKind::Return)) {
1389       SanitizerScope SanScope(this);
1390       llvm::Value *IsFalse = Builder.getFalse();
1391       EmitCheck(std::make_pair(IsFalse, SanitizerKind::Return),
1392                 SanitizerHandler::MissingReturn,
1393                 EmitCheckSourceLocation(FD->getLocation()), None);
1394     } else if (ShouldEmitUnreachable) {
1395       if (CGM.getCodeGenOpts().OptimizationLevel == 0)
1396         EmitTrapCall(llvm::Intrinsic::trap);
1397     }
1398     if (SanOpts.has(SanitizerKind::Return) || ShouldEmitUnreachable) {
1399       Builder.CreateUnreachable();
1400       Builder.ClearInsertionPoint();
1401     }
1402   }
1403 
1404   // Emit the standard function epilogue.
1405   FinishFunction(BodyRange.getEnd());
1406 
1407   // If we haven't marked the function nothrow through other means, do
1408   // a quick pass now to see if we can.
1409   if (!CurFn->doesNotThrow())
1410     TryMarkNoThrow(CurFn);
1411 }
1412 
1413 /// ContainsLabel - Return true if the statement contains a label in it.  If
1414 /// this statement is not executed normally, it not containing a label means
1415 /// that we can just remove the code.
1416 bool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) {
1417   // Null statement, not a label!
1418   if (!S) return false;
1419 
1420   // If this is a label, we have to emit the code, consider something like:
1421   // if (0) {  ...  foo:  bar(); }  goto foo;
1422   //
1423   // TODO: If anyone cared, we could track __label__'s, since we know that you
1424   // can't jump to one from outside their declared region.
1425   if (isa<LabelStmt>(S))
1426     return true;
1427 
1428   // If this is a case/default statement, and we haven't seen a switch, we have
1429   // to emit the code.
1430   if (isa<SwitchCase>(S) && !IgnoreCaseStmts)
1431     return true;
1432 
1433   // If this is a switch statement, we want to ignore cases below it.
1434   if (isa<SwitchStmt>(S))
1435     IgnoreCaseStmts = true;
1436 
1437   // Scan subexpressions for verboten labels.
1438   for (const Stmt *SubStmt : S->children())
1439     if (ContainsLabel(SubStmt, IgnoreCaseStmts))
1440       return true;
1441 
1442   return false;
1443 }
1444 
1445 /// containsBreak - Return true if the statement contains a break out of it.
1446 /// If the statement (recursively) contains a switch or loop with a break
1447 /// inside of it, this is fine.
1448 bool CodeGenFunction::containsBreak(const Stmt *S) {
1449   // Null statement, not a label!
1450   if (!S) return false;
1451 
1452   // If this is a switch or loop that defines its own break scope, then we can
1453   // include it and anything inside of it.
1454   if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || isa<DoStmt>(S) ||
1455       isa<ForStmt>(S))
1456     return false;
1457 
1458   if (isa<BreakStmt>(S))
1459     return true;
1460 
1461   // Scan subexpressions for verboten breaks.
1462   for (const Stmt *SubStmt : S->children())
1463     if (containsBreak(SubStmt))
1464       return true;
1465 
1466   return false;
1467 }
1468 
1469 bool CodeGenFunction::mightAddDeclToScope(const Stmt *S) {
1470   if (!S) return false;
1471 
1472   // Some statement kinds add a scope and thus never add a decl to the current
1473   // scope. Note, this list is longer than the list of statements that might
1474   // have an unscoped decl nested within them, but this way is conservatively
1475   // correct even if more statement kinds are added.
1476   if (isa<IfStmt>(S) || isa<SwitchStmt>(S) || isa<WhileStmt>(S) ||
1477       isa<DoStmt>(S) || isa<ForStmt>(S) || isa<CompoundStmt>(S) ||
1478       isa<CXXForRangeStmt>(S) || isa<CXXTryStmt>(S) ||
1479       isa<ObjCForCollectionStmt>(S) || isa<ObjCAtTryStmt>(S))
1480     return false;
1481 
1482   if (isa<DeclStmt>(S))
1483     return true;
1484 
1485   for (const Stmt *SubStmt : S->children())
1486     if (mightAddDeclToScope(SubStmt))
1487       return true;
1488 
1489   return false;
1490 }
1491 
1492 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
1493 /// to a constant, or if it does but contains a label, return false.  If it
1494 /// constant folds return true and set the boolean result in Result.
1495 bool CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond,
1496                                                    bool &ResultBool,
1497                                                    bool AllowLabels) {
1498   llvm::APSInt ResultInt;
1499   if (!ConstantFoldsToSimpleInteger(Cond, ResultInt, AllowLabels))
1500     return false;
1501 
1502   ResultBool = ResultInt.getBoolValue();
1503   return true;
1504 }
1505 
1506 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
1507 /// to a constant, or if it does but contains a label, return false.  If it
1508 /// constant folds return true and set the folded value.
1509 bool CodeGenFunction::ConstantFoldsToSimpleInteger(const Expr *Cond,
1510                                                    llvm::APSInt &ResultInt,
1511                                                    bool AllowLabels) {
1512   // FIXME: Rename and handle conversion of other evaluatable things
1513   // to bool.
1514   Expr::EvalResult Result;
1515   if (!Cond->EvaluateAsInt(Result, getContext()))
1516     return false;  // Not foldable, not integer or not fully evaluatable.
1517 
1518   llvm::APSInt Int = Result.Val.getInt();
1519   if (!AllowLabels && CodeGenFunction::ContainsLabel(Cond))
1520     return false;  // Contains a label.
1521 
1522   ResultInt = Int;
1523   return true;
1524 }
1525 
1526 /// Determine whether the given condition is an instrumentable condition
1527 /// (i.e. no "&&" or "||").
1528 bool CodeGenFunction::isInstrumentedCondition(const Expr *C) {
1529   // Bypass simplistic logical-NOT operator before determining whether the
1530   // condition contains any other logical operator.
1531   if (const UnaryOperator *UnOp = dyn_cast<UnaryOperator>(C->IgnoreParens()))
1532     if (UnOp->getOpcode() == UO_LNot)
1533       C = UnOp->getSubExpr();
1534 
1535   const BinaryOperator *BOp = dyn_cast<BinaryOperator>(C->IgnoreParens());
1536   return (!BOp || !BOp->isLogicalOp());
1537 }
1538 
1539 /// EmitBranchToCounterBlock - Emit a conditional branch to a new block that
1540 /// increments a profile counter based on the semantics of the given logical
1541 /// operator opcode.  This is used to instrument branch condition coverage for
1542 /// logical operators.
1543 void CodeGenFunction::EmitBranchToCounterBlock(
1544     const Expr *Cond, BinaryOperator::Opcode LOp, llvm::BasicBlock *TrueBlock,
1545     llvm::BasicBlock *FalseBlock, uint64_t TrueCount /* = 0 */,
1546     Stmt::Likelihood LH /* =None */, const Expr *CntrIdx /* = nullptr */) {
1547   // If not instrumenting, just emit a branch.
1548   bool InstrumentRegions = CGM.getCodeGenOpts().hasProfileClangInstr();
1549   if (!InstrumentRegions || !isInstrumentedCondition(Cond))
1550     return EmitBranchOnBoolExpr(Cond, TrueBlock, FalseBlock, TrueCount, LH);
1551 
1552   llvm::BasicBlock *ThenBlock = NULL;
1553   llvm::BasicBlock *ElseBlock = NULL;
1554   llvm::BasicBlock *NextBlock = NULL;
1555 
1556   // Create the block we'll use to increment the appropriate counter.
1557   llvm::BasicBlock *CounterIncrBlock = createBasicBlock("lop.rhscnt");
1558 
1559   // Set block pointers according to Logical-AND (BO_LAnd) semantics. This
1560   // means we need to evaluate the condition and increment the counter on TRUE:
1561   //
1562   // if (Cond)
1563   //   goto CounterIncrBlock;
1564   // else
1565   //   goto FalseBlock;
1566   //
1567   // CounterIncrBlock:
1568   //   Counter++;
1569   //   goto TrueBlock;
1570 
1571   if (LOp == BO_LAnd) {
1572     ThenBlock = CounterIncrBlock;
1573     ElseBlock = FalseBlock;
1574     NextBlock = TrueBlock;
1575   }
1576 
1577   // Set block pointers according to Logical-OR (BO_LOr) semantics. This means
1578   // we need to evaluate the condition and increment the counter on FALSE:
1579   //
1580   // if (Cond)
1581   //   goto TrueBlock;
1582   // else
1583   //   goto CounterIncrBlock;
1584   //
1585   // CounterIncrBlock:
1586   //   Counter++;
1587   //   goto FalseBlock;
1588 
1589   else if (LOp == BO_LOr) {
1590     ThenBlock = TrueBlock;
1591     ElseBlock = CounterIncrBlock;
1592     NextBlock = FalseBlock;
1593   } else {
1594     llvm_unreachable("Expected Opcode must be that of a Logical Operator");
1595   }
1596 
1597   // Emit Branch based on condition.
1598   EmitBranchOnBoolExpr(Cond, ThenBlock, ElseBlock, TrueCount, LH);
1599 
1600   // Emit the block containing the counter increment(s).
1601   EmitBlock(CounterIncrBlock);
1602 
1603   // Increment corresponding counter; if index not provided, use Cond as index.
1604   incrementProfileCounter(CntrIdx ? CntrIdx : Cond);
1605 
1606   // Go to the next block.
1607   EmitBranch(NextBlock);
1608 }
1609 
1610 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if
1611 /// statement) to the specified blocks.  Based on the condition, this might try
1612 /// to simplify the codegen of the conditional based on the branch.
1613 /// \param LH The value of the likelihood attribute on the True branch.
1614 void CodeGenFunction::EmitBranchOnBoolExpr(const Expr *Cond,
1615                                            llvm::BasicBlock *TrueBlock,
1616                                            llvm::BasicBlock *FalseBlock,
1617                                            uint64_t TrueCount,
1618                                            Stmt::Likelihood LH) {
1619   Cond = Cond->IgnoreParens();
1620 
1621   if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) {
1622 
1623     // Handle X && Y in a condition.
1624     if (CondBOp->getOpcode() == BO_LAnd) {
1625       // If we have "1 && X", simplify the code.  "0 && X" would have constant
1626       // folded if the case was simple enough.
1627       bool ConstantBool = false;
1628       if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) &&
1629           ConstantBool) {
1630         // br(1 && X) -> br(X).
1631         incrementProfileCounter(CondBOp);
1632         return EmitBranchToCounterBlock(CondBOp->getRHS(), BO_LAnd, TrueBlock,
1633                                         FalseBlock, TrueCount, LH);
1634       }
1635 
1636       // If we have "X && 1", simplify the code to use an uncond branch.
1637       // "X && 0" would have been constant folded to 0.
1638       if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) &&
1639           ConstantBool) {
1640         // br(X && 1) -> br(X).
1641         return EmitBranchToCounterBlock(CondBOp->getLHS(), BO_LAnd, TrueBlock,
1642                                         FalseBlock, TrueCount, LH, CondBOp);
1643       }
1644 
1645       // Emit the LHS as a conditional.  If the LHS conditional is false, we
1646       // want to jump to the FalseBlock.
1647       llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true");
1648       // The counter tells us how often we evaluate RHS, and all of TrueCount
1649       // can be propagated to that branch.
1650       uint64_t RHSCount = getProfileCount(CondBOp->getRHS());
1651 
1652       ConditionalEvaluation eval(*this);
1653       {
1654         ApplyDebugLocation DL(*this, Cond);
1655         // Propagate the likelihood attribute like __builtin_expect
1656         // __builtin_expect(X && Y, 1) -> X and Y are likely
1657         // __builtin_expect(X && Y, 0) -> only Y is unlikely
1658         EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock, RHSCount,
1659                              LH == Stmt::LH_Unlikely ? Stmt::LH_None : LH);
1660         EmitBlock(LHSTrue);
1661       }
1662 
1663       incrementProfileCounter(CondBOp);
1664       setCurrentProfileCount(getProfileCount(CondBOp->getRHS()));
1665 
1666       // Any temporaries created here are conditional.
1667       eval.begin(*this);
1668       EmitBranchToCounterBlock(CondBOp->getRHS(), BO_LAnd, TrueBlock,
1669                                FalseBlock, TrueCount, LH);
1670       eval.end(*this);
1671 
1672       return;
1673     }
1674 
1675     if (CondBOp->getOpcode() == BO_LOr) {
1676       // If we have "0 || X", simplify the code.  "1 || X" would have constant
1677       // folded if the case was simple enough.
1678       bool ConstantBool = false;
1679       if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) &&
1680           !ConstantBool) {
1681         // br(0 || X) -> br(X).
1682         incrementProfileCounter(CondBOp);
1683         return EmitBranchToCounterBlock(CondBOp->getRHS(), BO_LOr, TrueBlock,
1684                                         FalseBlock, TrueCount, LH);
1685       }
1686 
1687       // If we have "X || 0", simplify the code to use an uncond branch.
1688       // "X || 1" would have been constant folded to 1.
1689       if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) &&
1690           !ConstantBool) {
1691         // br(X || 0) -> br(X).
1692         return EmitBranchToCounterBlock(CondBOp->getLHS(), BO_LOr, TrueBlock,
1693                                         FalseBlock, TrueCount, LH, CondBOp);
1694       }
1695 
1696       // Emit the LHS as a conditional.  If the LHS conditional is true, we
1697       // want to jump to the TrueBlock.
1698       llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false");
1699       // We have the count for entry to the RHS and for the whole expression
1700       // being true, so we can divy up True count between the short circuit and
1701       // the RHS.
1702       uint64_t LHSCount =
1703           getCurrentProfileCount() - getProfileCount(CondBOp->getRHS());
1704       uint64_t RHSCount = TrueCount - LHSCount;
1705 
1706       ConditionalEvaluation eval(*this);
1707       {
1708         // Propagate the likelihood attribute like __builtin_expect
1709         // __builtin_expect(X || Y, 1) -> only Y is likely
1710         // __builtin_expect(X || Y, 0) -> both X and Y are unlikely
1711         ApplyDebugLocation DL(*this, Cond);
1712         EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse, LHSCount,
1713                              LH == Stmt::LH_Likely ? Stmt::LH_None : LH);
1714         EmitBlock(LHSFalse);
1715       }
1716 
1717       incrementProfileCounter(CondBOp);
1718       setCurrentProfileCount(getProfileCount(CondBOp->getRHS()));
1719 
1720       // Any temporaries created here are conditional.
1721       eval.begin(*this);
1722       EmitBranchToCounterBlock(CondBOp->getRHS(), BO_LOr, TrueBlock, FalseBlock,
1723                                RHSCount, LH);
1724 
1725       eval.end(*this);
1726 
1727       return;
1728     }
1729   }
1730 
1731   if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) {
1732     // br(!x, t, f) -> br(x, f, t)
1733     if (CondUOp->getOpcode() == UO_LNot) {
1734       // Negate the count.
1735       uint64_t FalseCount = getCurrentProfileCount() - TrueCount;
1736       // The values of the enum are chosen to make this negation possible.
1737       LH = static_cast<Stmt::Likelihood>(-LH);
1738       // Negate the condition and swap the destination blocks.
1739       return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock,
1740                                   FalseCount, LH);
1741     }
1742   }
1743 
1744   if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) {
1745     // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f))
1746     llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true");
1747     llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false");
1748 
1749     // The ConditionalOperator itself has no likelihood information for its
1750     // true and false branches. This matches the behavior of __builtin_expect.
1751     ConditionalEvaluation cond(*this);
1752     EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock,
1753                          getProfileCount(CondOp), Stmt::LH_None);
1754 
1755     // When computing PGO branch weights, we only know the overall count for
1756     // the true block. This code is essentially doing tail duplication of the
1757     // naive code-gen, introducing new edges for which counts are not
1758     // available. Divide the counts proportionally between the LHS and RHS of
1759     // the conditional operator.
1760     uint64_t LHSScaledTrueCount = 0;
1761     if (TrueCount) {
1762       double LHSRatio =
1763           getProfileCount(CondOp) / (double)getCurrentProfileCount();
1764       LHSScaledTrueCount = TrueCount * LHSRatio;
1765     }
1766 
1767     cond.begin(*this);
1768     EmitBlock(LHSBlock);
1769     incrementProfileCounter(CondOp);
1770     {
1771       ApplyDebugLocation DL(*this, Cond);
1772       EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock,
1773                            LHSScaledTrueCount, LH);
1774     }
1775     cond.end(*this);
1776 
1777     cond.begin(*this);
1778     EmitBlock(RHSBlock);
1779     EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock,
1780                          TrueCount - LHSScaledTrueCount, LH);
1781     cond.end(*this);
1782 
1783     return;
1784   }
1785 
1786   if (const CXXThrowExpr *Throw = dyn_cast<CXXThrowExpr>(Cond)) {
1787     // Conditional operator handling can give us a throw expression as a
1788     // condition for a case like:
1789     //   br(c ? throw x : y, t, f) -> br(c, br(throw x, t, f), br(y, t, f)
1790     // Fold this to:
1791     //   br(c, throw x, br(y, t, f))
1792     EmitCXXThrowExpr(Throw, /*KeepInsertionPoint*/false);
1793     return;
1794   }
1795 
1796   // Emit the code with the fully general case.
1797   llvm::Value *CondV;
1798   {
1799     ApplyDebugLocation DL(*this, Cond);
1800     CondV = EvaluateExprAsBool(Cond);
1801   }
1802 
1803   llvm::MDNode *Weights = nullptr;
1804   llvm::MDNode *Unpredictable = nullptr;
1805 
1806   // If the branch has a condition wrapped by __builtin_unpredictable,
1807   // create metadata that specifies that the branch is unpredictable.
1808   // Don't bother if not optimizing because that metadata would not be used.
1809   auto *Call = dyn_cast<CallExpr>(Cond->IgnoreImpCasts());
1810   if (Call && CGM.getCodeGenOpts().OptimizationLevel != 0) {
1811     auto *FD = dyn_cast_or_null<FunctionDecl>(Call->getCalleeDecl());
1812     if (FD && FD->getBuiltinID() == Builtin::BI__builtin_unpredictable) {
1813       llvm::MDBuilder MDHelper(getLLVMContext());
1814       Unpredictable = MDHelper.createUnpredictable();
1815     }
1816   }
1817 
1818   // If there is a Likelihood knowledge for the cond, lower it.
1819   // Note that if not optimizing this won't emit anything.
1820   llvm::Value *NewCondV = emitCondLikelihoodViaExpectIntrinsic(CondV, LH);
1821   if (CondV != NewCondV)
1822     CondV = NewCondV;
1823   else {
1824     // Otherwise, lower profile counts. Note that we do this even at -O0.
1825     uint64_t CurrentCount = std::max(getCurrentProfileCount(), TrueCount);
1826     Weights = createProfileWeights(TrueCount, CurrentCount - TrueCount);
1827   }
1828 
1829   Builder.CreateCondBr(CondV, TrueBlock, FalseBlock, Weights, Unpredictable);
1830 }
1831 
1832 /// ErrorUnsupported - Print out an error that codegen doesn't support the
1833 /// specified stmt yet.
1834 void CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type) {
1835   CGM.ErrorUnsupported(S, Type);
1836 }
1837 
1838 /// emitNonZeroVLAInit - Emit the "zero" initialization of a
1839 /// variable-length array whose elements have a non-zero bit-pattern.
1840 ///
1841 /// \param baseType the inner-most element type of the array
1842 /// \param src - a char* pointing to the bit-pattern for a single
1843 /// base element of the array
1844 /// \param sizeInChars - the total size of the VLA, in chars
1845 static void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType,
1846                                Address dest, Address src,
1847                                llvm::Value *sizeInChars) {
1848   CGBuilderTy &Builder = CGF.Builder;
1849 
1850   CharUnits baseSize = CGF.getContext().getTypeSizeInChars(baseType);
1851   llvm::Value *baseSizeInChars
1852     = llvm::ConstantInt::get(CGF.IntPtrTy, baseSize.getQuantity());
1853 
1854   Address begin =
1855     Builder.CreateElementBitCast(dest, CGF.Int8Ty, "vla.begin");
1856   llvm::Value *end = Builder.CreateInBoundsGEP(
1857       begin.getElementType(), begin.getPointer(), sizeInChars, "vla.end");
1858 
1859   llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock();
1860   llvm::BasicBlock *loopBB = CGF.createBasicBlock("vla-init.loop");
1861   llvm::BasicBlock *contBB = CGF.createBasicBlock("vla-init.cont");
1862 
1863   // Make a loop over the VLA.  C99 guarantees that the VLA element
1864   // count must be nonzero.
1865   CGF.EmitBlock(loopBB);
1866 
1867   llvm::PHINode *cur = Builder.CreatePHI(begin.getType(), 2, "vla.cur");
1868   cur->addIncoming(begin.getPointer(), originBB);
1869 
1870   CharUnits curAlign =
1871     dest.getAlignment().alignmentOfArrayElement(baseSize);
1872 
1873   // memcpy the individual element bit-pattern.
1874   Builder.CreateMemCpy(Address(cur, curAlign), src, baseSizeInChars,
1875                        /*volatile*/ false);
1876 
1877   // Go to the next element.
1878   llvm::Value *next =
1879     Builder.CreateInBoundsGEP(CGF.Int8Ty, cur, baseSizeInChars, "vla.next");
1880 
1881   // Leave if that's the end of the VLA.
1882   llvm::Value *done = Builder.CreateICmpEQ(next, end, "vla-init.isdone");
1883   Builder.CreateCondBr(done, contBB, loopBB);
1884   cur->addIncoming(next, loopBB);
1885 
1886   CGF.EmitBlock(contBB);
1887 }
1888 
1889 void
1890 CodeGenFunction::EmitNullInitialization(Address DestPtr, QualType Ty) {
1891   // Ignore empty classes in C++.
1892   if (getLangOpts().CPlusPlus) {
1893     if (const RecordType *RT = Ty->getAs<RecordType>()) {
1894       if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty())
1895         return;
1896     }
1897   }
1898 
1899   // Cast the dest ptr to the appropriate i8 pointer type.
1900   if (DestPtr.getElementType() != Int8Ty)
1901     DestPtr = Builder.CreateElementBitCast(DestPtr, Int8Ty);
1902 
1903   // Get size and alignment info for this aggregate.
1904   CharUnits size = getContext().getTypeSizeInChars(Ty);
1905 
1906   llvm::Value *SizeVal;
1907   const VariableArrayType *vla;
1908 
1909   // Don't bother emitting a zero-byte memset.
1910   if (size.isZero()) {
1911     // But note that getTypeInfo returns 0 for a VLA.
1912     if (const VariableArrayType *vlaType =
1913           dyn_cast_or_null<VariableArrayType>(
1914                                           getContext().getAsArrayType(Ty))) {
1915       auto VlaSize = getVLASize(vlaType);
1916       SizeVal = VlaSize.NumElts;
1917       CharUnits eltSize = getContext().getTypeSizeInChars(VlaSize.Type);
1918       if (!eltSize.isOne())
1919         SizeVal = Builder.CreateNUWMul(SizeVal, CGM.getSize(eltSize));
1920       vla = vlaType;
1921     } else {
1922       return;
1923     }
1924   } else {
1925     SizeVal = CGM.getSize(size);
1926     vla = nullptr;
1927   }
1928 
1929   // If the type contains a pointer to data member we can't memset it to zero.
1930   // Instead, create a null constant and copy it to the destination.
1931   // TODO: there are other patterns besides zero that we can usefully memset,
1932   // like -1, which happens to be the pattern used by member-pointers.
1933   if (!CGM.getTypes().isZeroInitializable(Ty)) {
1934     // For a VLA, emit a single element, then splat that over the VLA.
1935     if (vla) Ty = getContext().getBaseElementType(vla);
1936 
1937     llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty);
1938 
1939     llvm::GlobalVariable *NullVariable =
1940       new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(),
1941                                /*isConstant=*/true,
1942                                llvm::GlobalVariable::PrivateLinkage,
1943                                NullConstant, Twine());
1944     CharUnits NullAlign = DestPtr.getAlignment();
1945     NullVariable->setAlignment(NullAlign.getAsAlign());
1946     Address SrcPtr(Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()),
1947                    NullAlign);
1948 
1949     if (vla) return emitNonZeroVLAInit(*this, Ty, DestPtr, SrcPtr, SizeVal);
1950 
1951     // Get and call the appropriate llvm.memcpy overload.
1952     Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, false);
1953     return;
1954   }
1955 
1956   // Otherwise, just memset the whole thing to zero.  This is legal
1957   // because in LLVM, all default initializers (other than the ones we just
1958   // handled above) are guaranteed to have a bit pattern of all zeros.
1959   Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal, false);
1960 }
1961 
1962 llvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelDecl *L) {
1963   // Make sure that there is a block for the indirect goto.
1964   if (!IndirectBranch)
1965     GetIndirectGotoBlock();
1966 
1967   llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock();
1968 
1969   // Make sure the indirect branch includes all of the address-taken blocks.
1970   IndirectBranch->addDestination(BB);
1971   return llvm::BlockAddress::get(CurFn, BB);
1972 }
1973 
1974 llvm::BasicBlock *CodeGenFunction::GetIndirectGotoBlock() {
1975   // If we already made the indirect branch for indirect goto, return its block.
1976   if (IndirectBranch) return IndirectBranch->getParent();
1977 
1978   CGBuilderTy TmpBuilder(*this, createBasicBlock("indirectgoto"));
1979 
1980   // Create the PHI node that indirect gotos will add entries to.
1981   llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, 0,
1982                                               "indirect.goto.dest");
1983 
1984   // Create the indirect branch instruction.
1985   IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal);
1986   return IndirectBranch->getParent();
1987 }
1988 
1989 /// Computes the length of an array in elements, as well as the base
1990 /// element type and a properly-typed first element pointer.
1991 llvm::Value *CodeGenFunction::emitArrayLength(const ArrayType *origArrayType,
1992                                               QualType &baseType,
1993                                               Address &addr) {
1994   const ArrayType *arrayType = origArrayType;
1995 
1996   // If it's a VLA, we have to load the stored size.  Note that
1997   // this is the size of the VLA in bytes, not its size in elements.
1998   llvm::Value *numVLAElements = nullptr;
1999   if (isa<VariableArrayType>(arrayType)) {
2000     numVLAElements = getVLASize(cast<VariableArrayType>(arrayType)).NumElts;
2001 
2002     // Walk into all VLAs.  This doesn't require changes to addr,
2003     // which has type T* where T is the first non-VLA element type.
2004     do {
2005       QualType elementType = arrayType->getElementType();
2006       arrayType = getContext().getAsArrayType(elementType);
2007 
2008       // If we only have VLA components, 'addr' requires no adjustment.
2009       if (!arrayType) {
2010         baseType = elementType;
2011         return numVLAElements;
2012       }
2013     } while (isa<VariableArrayType>(arrayType));
2014 
2015     // We get out here only if we find a constant array type
2016     // inside the VLA.
2017   }
2018 
2019   // We have some number of constant-length arrays, so addr should
2020   // have LLVM type [M x [N x [...]]]*.  Build a GEP that walks
2021   // down to the first element of addr.
2022   SmallVector<llvm::Value*, 8> gepIndices;
2023 
2024   // GEP down to the array type.
2025   llvm::ConstantInt *zero = Builder.getInt32(0);
2026   gepIndices.push_back(zero);
2027 
2028   uint64_t countFromCLAs = 1;
2029   QualType eltType;
2030 
2031   llvm::ArrayType *llvmArrayType =
2032     dyn_cast<llvm::ArrayType>(addr.getElementType());
2033   while (llvmArrayType) {
2034     assert(isa<ConstantArrayType>(arrayType));
2035     assert(cast<ConstantArrayType>(arrayType)->getSize().getZExtValue()
2036              == llvmArrayType->getNumElements());
2037 
2038     gepIndices.push_back(zero);
2039     countFromCLAs *= llvmArrayType->getNumElements();
2040     eltType = arrayType->getElementType();
2041 
2042     llvmArrayType =
2043       dyn_cast<llvm::ArrayType>(llvmArrayType->getElementType());
2044     arrayType = getContext().getAsArrayType(arrayType->getElementType());
2045     assert((!llvmArrayType || arrayType) &&
2046            "LLVM and Clang types are out-of-synch");
2047   }
2048 
2049   if (arrayType) {
2050     // From this point onwards, the Clang array type has been emitted
2051     // as some other type (probably a packed struct). Compute the array
2052     // size, and just emit the 'begin' expression as a bitcast.
2053     while (arrayType) {
2054       countFromCLAs *=
2055           cast<ConstantArrayType>(arrayType)->getSize().getZExtValue();
2056       eltType = arrayType->getElementType();
2057       arrayType = getContext().getAsArrayType(eltType);
2058     }
2059 
2060     llvm::Type *baseType = ConvertType(eltType);
2061     addr = Builder.CreateElementBitCast(addr, baseType, "array.begin");
2062   } else {
2063     // Create the actual GEP.
2064     addr = Address(Builder.CreateInBoundsGEP(
2065         addr.getElementType(), addr.getPointer(), gepIndices, "array.begin"),
2066         addr.getAlignment());
2067   }
2068 
2069   baseType = eltType;
2070 
2071   llvm::Value *numElements
2072     = llvm::ConstantInt::get(SizeTy, countFromCLAs);
2073 
2074   // If we had any VLA dimensions, factor them in.
2075   if (numVLAElements)
2076     numElements = Builder.CreateNUWMul(numVLAElements, numElements);
2077 
2078   return numElements;
2079 }
2080 
2081 CodeGenFunction::VlaSizePair CodeGenFunction::getVLASize(QualType type) {
2082   const VariableArrayType *vla = getContext().getAsVariableArrayType(type);
2083   assert(vla && "type was not a variable array type!");
2084   return getVLASize(vla);
2085 }
2086 
2087 CodeGenFunction::VlaSizePair
2088 CodeGenFunction::getVLASize(const VariableArrayType *type) {
2089   // The number of elements so far; always size_t.
2090   llvm::Value *numElements = nullptr;
2091 
2092   QualType elementType;
2093   do {
2094     elementType = type->getElementType();
2095     llvm::Value *vlaSize = VLASizeMap[type->getSizeExpr()];
2096     assert(vlaSize && "no size for VLA!");
2097     assert(vlaSize->getType() == SizeTy);
2098 
2099     if (!numElements) {
2100       numElements = vlaSize;
2101     } else {
2102       // It's undefined behavior if this wraps around, so mark it that way.
2103       // FIXME: Teach -fsanitize=undefined to trap this.
2104       numElements = Builder.CreateNUWMul(numElements, vlaSize);
2105     }
2106   } while ((type = getContext().getAsVariableArrayType(elementType)));
2107 
2108   return { numElements, elementType };
2109 }
2110 
2111 CodeGenFunction::VlaSizePair
2112 CodeGenFunction::getVLAElements1D(QualType type) {
2113   const VariableArrayType *vla = getContext().getAsVariableArrayType(type);
2114   assert(vla && "type was not a variable array type!");
2115   return getVLAElements1D(vla);
2116 }
2117 
2118 CodeGenFunction::VlaSizePair
2119 CodeGenFunction::getVLAElements1D(const VariableArrayType *Vla) {
2120   llvm::Value *VlaSize = VLASizeMap[Vla->getSizeExpr()];
2121   assert(VlaSize && "no size for VLA!");
2122   assert(VlaSize->getType() == SizeTy);
2123   return { VlaSize, Vla->getElementType() };
2124 }
2125 
2126 void CodeGenFunction::EmitVariablyModifiedType(QualType type) {
2127   assert(type->isVariablyModifiedType() &&
2128          "Must pass variably modified type to EmitVLASizes!");
2129 
2130   EnsureInsertPoint();
2131 
2132   // We're going to walk down into the type and look for VLA
2133   // expressions.
2134   do {
2135     assert(type->isVariablyModifiedType());
2136 
2137     const Type *ty = type.getTypePtr();
2138     switch (ty->getTypeClass()) {
2139 
2140 #define TYPE(Class, Base)
2141 #define ABSTRACT_TYPE(Class, Base)
2142 #define NON_CANONICAL_TYPE(Class, Base)
2143 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
2144 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
2145 #include "clang/AST/TypeNodes.inc"
2146       llvm_unreachable("unexpected dependent type!");
2147 
2148     // These types are never variably-modified.
2149     case Type::Builtin:
2150     case Type::Complex:
2151     case Type::Vector:
2152     case Type::ExtVector:
2153     case Type::ConstantMatrix:
2154     case Type::Record:
2155     case Type::Enum:
2156     case Type::Elaborated:
2157     case Type::TemplateSpecialization:
2158     case Type::ObjCTypeParam:
2159     case Type::ObjCObject:
2160     case Type::ObjCInterface:
2161     case Type::ObjCObjectPointer:
2162     case Type::ExtInt:
2163       llvm_unreachable("type class is never variably-modified!");
2164 
2165     case Type::Adjusted:
2166       type = cast<AdjustedType>(ty)->getAdjustedType();
2167       break;
2168 
2169     case Type::Decayed:
2170       type = cast<DecayedType>(ty)->getPointeeType();
2171       break;
2172 
2173     case Type::Pointer:
2174       type = cast<PointerType>(ty)->getPointeeType();
2175       break;
2176 
2177     case Type::BlockPointer:
2178       type = cast<BlockPointerType>(ty)->getPointeeType();
2179       break;
2180 
2181     case Type::LValueReference:
2182     case Type::RValueReference:
2183       type = cast<ReferenceType>(ty)->getPointeeType();
2184       break;
2185 
2186     case Type::MemberPointer:
2187       type = cast<MemberPointerType>(ty)->getPointeeType();
2188       break;
2189 
2190     case Type::ConstantArray:
2191     case Type::IncompleteArray:
2192       // Losing element qualification here is fine.
2193       type = cast<ArrayType>(ty)->getElementType();
2194       break;
2195 
2196     case Type::VariableArray: {
2197       // Losing element qualification here is fine.
2198       const VariableArrayType *vat = cast<VariableArrayType>(ty);
2199 
2200       // Unknown size indication requires no size computation.
2201       // Otherwise, evaluate and record it.
2202       if (const Expr *size = vat->getSizeExpr()) {
2203         // It's possible that we might have emitted this already,
2204         // e.g. with a typedef and a pointer to it.
2205         llvm::Value *&entry = VLASizeMap[size];
2206         if (!entry) {
2207           llvm::Value *Size = EmitScalarExpr(size);
2208 
2209           // C11 6.7.6.2p5:
2210           //   If the size is an expression that is not an integer constant
2211           //   expression [...] each time it is evaluated it shall have a value
2212           //   greater than zero.
2213           if (SanOpts.has(SanitizerKind::VLABound) &&
2214               size->getType()->isSignedIntegerType()) {
2215             SanitizerScope SanScope(this);
2216             llvm::Value *Zero = llvm::Constant::getNullValue(Size->getType());
2217             llvm::Constant *StaticArgs[] = {
2218                 EmitCheckSourceLocation(size->getBeginLoc()),
2219                 EmitCheckTypeDescriptor(size->getType())};
2220             EmitCheck(std::make_pair(Builder.CreateICmpSGT(Size, Zero),
2221                                      SanitizerKind::VLABound),
2222                       SanitizerHandler::VLABoundNotPositive, StaticArgs, Size);
2223           }
2224 
2225           // Always zexting here would be wrong if it weren't
2226           // undefined behavior to have a negative bound.
2227           entry = Builder.CreateIntCast(Size, SizeTy, /*signed*/ false);
2228         }
2229       }
2230       type = vat->getElementType();
2231       break;
2232     }
2233 
2234     case Type::FunctionProto:
2235     case Type::FunctionNoProto:
2236       type = cast<FunctionType>(ty)->getReturnType();
2237       break;
2238 
2239     case Type::Paren:
2240     case Type::TypeOf:
2241     case Type::UnaryTransform:
2242     case Type::Attributed:
2243     case Type::SubstTemplateTypeParm:
2244     case Type::MacroQualified:
2245       // Keep walking after single level desugaring.
2246       type = type.getSingleStepDesugaredType(getContext());
2247       break;
2248 
2249     case Type::Typedef:
2250     case Type::Decltype:
2251     case Type::Auto:
2252     case Type::DeducedTemplateSpecialization:
2253       // Stop walking: nothing to do.
2254       return;
2255 
2256     case Type::TypeOfExpr:
2257       // Stop walking: emit typeof expression.
2258       EmitIgnoredExpr(cast<TypeOfExprType>(ty)->getUnderlyingExpr());
2259       return;
2260 
2261     case Type::Atomic:
2262       type = cast<AtomicType>(ty)->getValueType();
2263       break;
2264 
2265     case Type::Pipe:
2266       type = cast<PipeType>(ty)->getElementType();
2267       break;
2268     }
2269   } while (type->isVariablyModifiedType());
2270 }
2271 
2272 Address CodeGenFunction::EmitVAListRef(const Expr* E) {
2273   if (getContext().getBuiltinVaListType()->isArrayType())
2274     return EmitPointerWithAlignment(E);
2275   return EmitLValue(E).getAddress(*this);
2276 }
2277 
2278 Address CodeGenFunction::EmitMSVAListRef(const Expr *E) {
2279   return EmitLValue(E).getAddress(*this);
2280 }
2281 
2282 void CodeGenFunction::EmitDeclRefExprDbgValue(const DeclRefExpr *E,
2283                                               const APValue &Init) {
2284   assert(Init.hasValue() && "Invalid DeclRefExpr initializer!");
2285   if (CGDebugInfo *Dbg = getDebugInfo())
2286     if (CGM.getCodeGenOpts().hasReducedDebugInfo())
2287       Dbg->EmitGlobalVariable(E->getDecl(), Init);
2288 }
2289 
2290 CodeGenFunction::PeepholeProtection
2291 CodeGenFunction::protectFromPeepholes(RValue rvalue) {
2292   // At the moment, the only aggressive peephole we do in IR gen
2293   // is trunc(zext) folding, but if we add more, we can easily
2294   // extend this protection.
2295 
2296   if (!rvalue.isScalar()) return PeepholeProtection();
2297   llvm::Value *value = rvalue.getScalarVal();
2298   if (!isa<llvm::ZExtInst>(value)) return PeepholeProtection();
2299 
2300   // Just make an extra bitcast.
2301   assert(HaveInsertPoint());
2302   llvm::Instruction *inst = new llvm::BitCastInst(value, value->getType(), "",
2303                                                   Builder.GetInsertBlock());
2304 
2305   PeepholeProtection protection;
2306   protection.Inst = inst;
2307   return protection;
2308 }
2309 
2310 void CodeGenFunction::unprotectFromPeepholes(PeepholeProtection protection) {
2311   if (!protection.Inst) return;
2312 
2313   // In theory, we could try to duplicate the peepholes now, but whatever.
2314   protection.Inst->eraseFromParent();
2315 }
2316 
2317 void CodeGenFunction::emitAlignmentAssumption(llvm::Value *PtrValue,
2318                                               QualType Ty, SourceLocation Loc,
2319                                               SourceLocation AssumptionLoc,
2320                                               llvm::Value *Alignment,
2321                                               llvm::Value *OffsetValue) {
2322   if (Alignment->getType() != IntPtrTy)
2323     Alignment =
2324         Builder.CreateIntCast(Alignment, IntPtrTy, false, "casted.align");
2325   if (OffsetValue && OffsetValue->getType() != IntPtrTy)
2326     OffsetValue =
2327         Builder.CreateIntCast(OffsetValue, IntPtrTy, true, "casted.offset");
2328   llvm::Value *TheCheck = nullptr;
2329   if (SanOpts.has(SanitizerKind::Alignment)) {
2330     llvm::Value *PtrIntValue =
2331         Builder.CreatePtrToInt(PtrValue, IntPtrTy, "ptrint");
2332 
2333     if (OffsetValue) {
2334       bool IsOffsetZero = false;
2335       if (const auto *CI = dyn_cast<llvm::ConstantInt>(OffsetValue))
2336         IsOffsetZero = CI->isZero();
2337 
2338       if (!IsOffsetZero)
2339         PtrIntValue = Builder.CreateSub(PtrIntValue, OffsetValue, "offsetptr");
2340     }
2341 
2342     llvm::Value *Zero = llvm::ConstantInt::get(IntPtrTy, 0);
2343     llvm::Value *Mask =
2344         Builder.CreateSub(Alignment, llvm::ConstantInt::get(IntPtrTy, 1));
2345     llvm::Value *MaskedPtr = Builder.CreateAnd(PtrIntValue, Mask, "maskedptr");
2346     TheCheck = Builder.CreateICmpEQ(MaskedPtr, Zero, "maskcond");
2347   }
2348   llvm::Instruction *Assumption = Builder.CreateAlignmentAssumption(
2349       CGM.getDataLayout(), PtrValue, Alignment, OffsetValue);
2350 
2351   if (!SanOpts.has(SanitizerKind::Alignment))
2352     return;
2353   emitAlignmentAssumptionCheck(PtrValue, Ty, Loc, AssumptionLoc, Alignment,
2354                                OffsetValue, TheCheck, Assumption);
2355 }
2356 
2357 void CodeGenFunction::emitAlignmentAssumption(llvm::Value *PtrValue,
2358                                               const Expr *E,
2359                                               SourceLocation AssumptionLoc,
2360                                               llvm::Value *Alignment,
2361                                               llvm::Value *OffsetValue) {
2362   if (auto *CE = dyn_cast<CastExpr>(E))
2363     E = CE->getSubExprAsWritten();
2364   QualType Ty = E->getType();
2365   SourceLocation Loc = E->getExprLoc();
2366 
2367   emitAlignmentAssumption(PtrValue, Ty, Loc, AssumptionLoc, Alignment,
2368                           OffsetValue);
2369 }
2370 
2371 llvm::Value *CodeGenFunction::EmitAnnotationCall(llvm::Function *AnnotationFn,
2372                                                  llvm::Value *AnnotatedVal,
2373                                                  StringRef AnnotationStr,
2374                                                  SourceLocation Location,
2375                                                  const AnnotateAttr *Attr) {
2376   SmallVector<llvm::Value *, 5> Args = {
2377       AnnotatedVal,
2378       Builder.CreateBitCast(CGM.EmitAnnotationString(AnnotationStr), Int8PtrTy),
2379       Builder.CreateBitCast(CGM.EmitAnnotationUnit(Location), Int8PtrTy),
2380       CGM.EmitAnnotationLineNo(Location),
2381   };
2382   if (Attr)
2383     Args.push_back(CGM.EmitAnnotationArgs(Attr));
2384   return Builder.CreateCall(AnnotationFn, Args);
2385 }
2386 
2387 void CodeGenFunction::EmitVarAnnotations(const VarDecl *D, llvm::Value *V) {
2388   assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
2389   // FIXME We create a new bitcast for every annotation because that's what
2390   // llvm-gcc was doing.
2391   for (const auto *I : D->specific_attrs<AnnotateAttr>())
2392     EmitAnnotationCall(CGM.getIntrinsic(llvm::Intrinsic::var_annotation),
2393                        Builder.CreateBitCast(V, CGM.Int8PtrTy, V->getName()),
2394                        I->getAnnotation(), D->getLocation(), I);
2395 }
2396 
2397 Address CodeGenFunction::EmitFieldAnnotations(const FieldDecl *D,
2398                                               Address Addr) {
2399   assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
2400   llvm::Value *V = Addr.getPointer();
2401   llvm::Type *VTy = V->getType();
2402   llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::ptr_annotation,
2403                                     CGM.Int8PtrTy);
2404 
2405   for (const auto *I : D->specific_attrs<AnnotateAttr>()) {
2406     // FIXME Always emit the cast inst so we can differentiate between
2407     // annotation on the first field of a struct and annotation on the struct
2408     // itself.
2409     if (VTy != CGM.Int8PtrTy)
2410       V = Builder.CreateBitCast(V, CGM.Int8PtrTy);
2411     V = EmitAnnotationCall(F, V, I->getAnnotation(), D->getLocation(), I);
2412     V = Builder.CreateBitCast(V, VTy);
2413   }
2414 
2415   return Address(V, Addr.getAlignment());
2416 }
2417 
2418 CodeGenFunction::CGCapturedStmtInfo::~CGCapturedStmtInfo() { }
2419 
2420 CodeGenFunction::SanitizerScope::SanitizerScope(CodeGenFunction *CGF)
2421     : CGF(CGF) {
2422   assert(!CGF->IsSanitizerScope);
2423   CGF->IsSanitizerScope = true;
2424 }
2425 
2426 CodeGenFunction::SanitizerScope::~SanitizerScope() {
2427   CGF->IsSanitizerScope = false;
2428 }
2429 
2430 void CodeGenFunction::InsertHelper(llvm::Instruction *I,
2431                                    const llvm::Twine &Name,
2432                                    llvm::BasicBlock *BB,
2433                                    llvm::BasicBlock::iterator InsertPt) const {
2434   LoopStack.InsertHelper(I);
2435   if (IsSanitizerScope)
2436     CGM.getSanitizerMetadata()->disableSanitizerForInstruction(I);
2437 }
2438 
2439 void CGBuilderInserter::InsertHelper(
2440     llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB,
2441     llvm::BasicBlock::iterator InsertPt) const {
2442   llvm::IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt);
2443   if (CGF)
2444     CGF->InsertHelper(I, Name, BB, InsertPt);
2445 }
2446 
2447 // Emits an error if we don't have a valid set of target features for the
2448 // called function.
2449 void CodeGenFunction::checkTargetFeatures(const CallExpr *E,
2450                                           const FunctionDecl *TargetDecl) {
2451   return checkTargetFeatures(E->getBeginLoc(), TargetDecl);
2452 }
2453 
2454 // Emits an error if we don't have a valid set of target features for the
2455 // called function.
2456 void CodeGenFunction::checkTargetFeatures(SourceLocation Loc,
2457                                           const FunctionDecl *TargetDecl) {
2458   // Early exit if this is an indirect call.
2459   if (!TargetDecl)
2460     return;
2461 
2462   // Get the current enclosing function if it exists. If it doesn't
2463   // we can't check the target features anyhow.
2464   const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurCodeDecl);
2465   if (!FD)
2466     return;
2467 
2468   // Grab the required features for the call. For a builtin this is listed in
2469   // the td file with the default cpu, for an always_inline function this is any
2470   // listed cpu and any listed features.
2471   unsigned BuiltinID = TargetDecl->getBuiltinID();
2472   std::string MissingFeature;
2473   llvm::StringMap<bool> CallerFeatureMap;
2474   CGM.getContext().getFunctionFeatureMap(CallerFeatureMap, FD);
2475   if (BuiltinID) {
2476     StringRef FeatureList(
2477         CGM.getContext().BuiltinInfo.getRequiredFeatures(BuiltinID));
2478     // Return if the builtin doesn't have any required features.
2479     if (FeatureList.empty())
2480       return;
2481     assert(FeatureList.find(' ') == StringRef::npos &&
2482            "Space in feature list");
2483     TargetFeatures TF(CallerFeatureMap);
2484     if (!TF.hasRequiredFeatures(FeatureList))
2485       CGM.getDiags().Report(Loc, diag::err_builtin_needs_feature)
2486           << TargetDecl->getDeclName() << FeatureList;
2487   } else if (!TargetDecl->isMultiVersion() &&
2488              TargetDecl->hasAttr<TargetAttr>()) {
2489     // Get the required features for the callee.
2490 
2491     const TargetAttr *TD = TargetDecl->getAttr<TargetAttr>();
2492     ParsedTargetAttr ParsedAttr =
2493         CGM.getContext().filterFunctionTargetAttrs(TD);
2494 
2495     SmallVector<StringRef, 1> ReqFeatures;
2496     llvm::StringMap<bool> CalleeFeatureMap;
2497     CGM.getContext().getFunctionFeatureMap(CalleeFeatureMap, TargetDecl);
2498 
2499     for (const auto &F : ParsedAttr.Features) {
2500       if (F[0] == '+' && CalleeFeatureMap.lookup(F.substr(1)))
2501         ReqFeatures.push_back(StringRef(F).substr(1));
2502     }
2503 
2504     for (const auto &F : CalleeFeatureMap) {
2505       // Only positive features are "required".
2506       if (F.getValue())
2507         ReqFeatures.push_back(F.getKey());
2508     }
2509     if (!llvm::all_of(ReqFeatures, [&](StringRef Feature) {
2510       if (!CallerFeatureMap.lookup(Feature)) {
2511         MissingFeature = Feature.str();
2512         return false;
2513       }
2514       return true;
2515     }))
2516       CGM.getDiags().Report(Loc, diag::err_function_needs_feature)
2517           << FD->getDeclName() << TargetDecl->getDeclName() << MissingFeature;
2518   }
2519 }
2520 
2521 void CodeGenFunction::EmitSanitizerStatReport(llvm::SanitizerStatKind SSK) {
2522   if (!CGM.getCodeGenOpts().SanitizeStats)
2523     return;
2524 
2525   llvm::IRBuilder<> IRB(Builder.GetInsertBlock(), Builder.GetInsertPoint());
2526   IRB.SetCurrentDebugLocation(Builder.getCurrentDebugLocation());
2527   CGM.getSanStats().create(IRB, SSK);
2528 }
2529 
2530 llvm::Value *
2531 CodeGenFunction::FormResolverCondition(const MultiVersionResolverOption &RO) {
2532   llvm::Value *Condition = nullptr;
2533 
2534   if (!RO.Conditions.Architecture.empty())
2535     Condition = EmitX86CpuIs(RO.Conditions.Architecture);
2536 
2537   if (!RO.Conditions.Features.empty()) {
2538     llvm::Value *FeatureCond = EmitX86CpuSupports(RO.Conditions.Features);
2539     Condition =
2540         Condition ? Builder.CreateAnd(Condition, FeatureCond) : FeatureCond;
2541   }
2542   return Condition;
2543 }
2544 
2545 static void CreateMultiVersionResolverReturn(CodeGenModule &CGM,
2546                                              llvm::Function *Resolver,
2547                                              CGBuilderTy &Builder,
2548                                              llvm::Function *FuncToReturn,
2549                                              bool SupportsIFunc) {
2550   if (SupportsIFunc) {
2551     Builder.CreateRet(FuncToReturn);
2552     return;
2553   }
2554 
2555   llvm::SmallVector<llvm::Value *, 10> Args;
2556   llvm::for_each(Resolver->args(),
2557                  [&](llvm::Argument &Arg) { Args.push_back(&Arg); });
2558 
2559   llvm::CallInst *Result = Builder.CreateCall(FuncToReturn, Args);
2560   Result->setTailCallKind(llvm::CallInst::TCK_MustTail);
2561 
2562   if (Resolver->getReturnType()->isVoidTy())
2563     Builder.CreateRetVoid();
2564   else
2565     Builder.CreateRet(Result);
2566 }
2567 
2568 void CodeGenFunction::EmitMultiVersionResolver(
2569     llvm::Function *Resolver, ArrayRef<MultiVersionResolverOption> Options) {
2570   assert(getContext().getTargetInfo().getTriple().isX86() &&
2571          "Only implemented for x86 targets");
2572 
2573   bool SupportsIFunc = getContext().getTargetInfo().supportsIFunc();
2574 
2575   // Main function's basic block.
2576   llvm::BasicBlock *CurBlock = createBasicBlock("resolver_entry", Resolver);
2577   Builder.SetInsertPoint(CurBlock);
2578   EmitX86CpuInit();
2579 
2580   for (const MultiVersionResolverOption &RO : Options) {
2581     Builder.SetInsertPoint(CurBlock);
2582     llvm::Value *Condition = FormResolverCondition(RO);
2583 
2584     // The 'default' or 'generic' case.
2585     if (!Condition) {
2586       assert(&RO == Options.end() - 1 &&
2587              "Default or Generic case must be last");
2588       CreateMultiVersionResolverReturn(CGM, Resolver, Builder, RO.Function,
2589                                        SupportsIFunc);
2590       return;
2591     }
2592 
2593     llvm::BasicBlock *RetBlock = createBasicBlock("resolver_return", Resolver);
2594     CGBuilderTy RetBuilder(*this, RetBlock);
2595     CreateMultiVersionResolverReturn(CGM, Resolver, RetBuilder, RO.Function,
2596                                      SupportsIFunc);
2597     CurBlock = createBasicBlock("resolver_else", Resolver);
2598     Builder.CreateCondBr(Condition, RetBlock, CurBlock);
2599   }
2600 
2601   // If no generic/default, emit an unreachable.
2602   Builder.SetInsertPoint(CurBlock);
2603   llvm::CallInst *TrapCall = EmitTrapCall(llvm::Intrinsic::trap);
2604   TrapCall->setDoesNotReturn();
2605   TrapCall->setDoesNotThrow();
2606   Builder.CreateUnreachable();
2607   Builder.ClearInsertionPoint();
2608 }
2609 
2610 // Loc - where the diagnostic will point, where in the source code this
2611 //  alignment has failed.
2612 // SecondaryLoc - if present (will be present if sufficiently different from
2613 //  Loc), the diagnostic will additionally point a "Note:" to this location.
2614 //  It should be the location where the __attribute__((assume_aligned))
2615 //  was written e.g.
2616 void CodeGenFunction::emitAlignmentAssumptionCheck(
2617     llvm::Value *Ptr, QualType Ty, SourceLocation Loc,
2618     SourceLocation SecondaryLoc, llvm::Value *Alignment,
2619     llvm::Value *OffsetValue, llvm::Value *TheCheck,
2620     llvm::Instruction *Assumption) {
2621   assert(Assumption && isa<llvm::CallInst>(Assumption) &&
2622          cast<llvm::CallInst>(Assumption)->getCalledOperand() ==
2623              llvm::Intrinsic::getDeclaration(
2624                  Builder.GetInsertBlock()->getParent()->getParent(),
2625                  llvm::Intrinsic::assume) &&
2626          "Assumption should be a call to llvm.assume().");
2627   assert(&(Builder.GetInsertBlock()->back()) == Assumption &&
2628          "Assumption should be the last instruction of the basic block, "
2629          "since the basic block is still being generated.");
2630 
2631   if (!SanOpts.has(SanitizerKind::Alignment))
2632     return;
2633 
2634   // Don't check pointers to volatile data. The behavior here is implementation-
2635   // defined.
2636   if (Ty->getPointeeType().isVolatileQualified())
2637     return;
2638 
2639   // We need to temorairly remove the assumption so we can insert the
2640   // sanitizer check before it, else the check will be dropped by optimizations.
2641   Assumption->removeFromParent();
2642 
2643   {
2644     SanitizerScope SanScope(this);
2645 
2646     if (!OffsetValue)
2647       OffsetValue = Builder.getInt1(0); // no offset.
2648 
2649     llvm::Constant *StaticData[] = {EmitCheckSourceLocation(Loc),
2650                                     EmitCheckSourceLocation(SecondaryLoc),
2651                                     EmitCheckTypeDescriptor(Ty)};
2652     llvm::Value *DynamicData[] = {EmitCheckValue(Ptr),
2653                                   EmitCheckValue(Alignment),
2654                                   EmitCheckValue(OffsetValue)};
2655     EmitCheck({std::make_pair(TheCheck, SanitizerKind::Alignment)},
2656               SanitizerHandler::AlignmentAssumption, StaticData, DynamicData);
2657   }
2658 
2659   // We are now in the (new, empty) "cont" basic block.
2660   // Reintroduce the assumption.
2661   Builder.Insert(Assumption);
2662   // FIXME: Assumption still has it's original basic block as it's Parent.
2663 }
2664 
2665 llvm::DebugLoc CodeGenFunction::SourceLocToDebugLoc(SourceLocation Location) {
2666   if (CGDebugInfo *DI = getDebugInfo())
2667     return DI->SourceLocToDebugLoc(Location);
2668 
2669   return llvm::DebugLoc();
2670 }
2671 
2672 llvm::Value *
2673 CodeGenFunction::emitCondLikelihoodViaExpectIntrinsic(llvm::Value *Cond,
2674                                                       Stmt::Likelihood LH) {
2675   switch (LH) {
2676   case Stmt::LH_None:
2677     return Cond;
2678   case Stmt::LH_Likely:
2679   case Stmt::LH_Unlikely:
2680     // Don't generate llvm.expect on -O0 as the backend won't use it for
2681     // anything.
2682     if (CGM.getCodeGenOpts().OptimizationLevel == 0)
2683       return Cond;
2684     llvm::Type *CondTy = Cond->getType();
2685     assert(CondTy->isIntegerTy(1) && "expecting condition to be a boolean");
2686     llvm::Function *FnExpect =
2687         CGM.getIntrinsic(llvm::Intrinsic::expect, CondTy);
2688     llvm::Value *ExpectedValueOfCond =
2689         llvm::ConstantInt::getBool(CondTy, LH == Stmt::LH_Likely);
2690     return Builder.CreateCall(FnExpect, {Cond, ExpectedValueOfCond},
2691                               Cond->getName() + ".expval");
2692   }
2693   llvm_unreachable("Unknown Likelihood");
2694 }
2695