clang  9.0.0
CodeGenFunction.cpp
Go to the documentation of this file.
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 "CGCleanup.h"
16 #include "CGCUDARuntime.h"
17 #include "CGCXXABI.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/Decl.h"
26 #include "clang/AST/DeclCXX.h"
27 #include "clang/AST/StmtCXX.h"
28 #include "clang/AST/StmtObjC.h"
29 #include "clang/Basic/Builtins.h"
31 #include "clang/Basic/TargetInfo.h"
34 #include "llvm/IR/DataLayout.h"
35 #include "llvm/IR/Dominators.h"
36 #include "llvm/IR/Intrinsics.h"
37 #include "llvm/IR/MDBuilder.h"
38 #include "llvm/IR/Operator.h"
39 #include "llvm/Transforms/Utils/PromoteMemToReg.h"
40 using namespace clang;
41 using namespace CodeGen;
42 
43 /// shouldEmitLifetimeMarkers - Decide whether we need emit the life-time
44 /// markers.
45 static bool shouldEmitLifetimeMarkers(const CodeGenOptions &CGOpts,
46  const LangOptions &LangOpts) {
47  if (CGOpts.DisableLifetimeMarkers)
48  return false;
49 
50  // Disable lifetime markers in msan builds.
51  // FIXME: Remove this when msan works with lifetime markers.
52  if (LangOpts.Sanitize.has(SanitizerKind::Memory))
53  return false;
54 
55  // Asan uses markers for use-after-scope checks.
56  if (CGOpts.SanitizeAddressUseAfterScope)
57  return true;
58 
59  // For now, only in optimized builds.
60  return CGOpts.OptimizationLevel != 0;
61 }
62 
63 CodeGenFunction::CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext)
64  : CodeGenTypeCache(cgm), CGM(cgm), Target(cgm.getTarget()),
65  Builder(cgm, cgm.getModule().getContext(), llvm::ConstantFolder(),
66  CGBuilderInserterTy(this)),
67  SanOpts(CGM.getLangOpts().Sanitize), DebugInfo(CGM.getModuleDebugInfo()),
68  PGO(cgm), ShouldEmitLifetimeMarkers(shouldEmitLifetimeMarkers(
69  CGM.getCodeGenOpts(), CGM.getLangOpts())) {
70  if (!suppressNewContext)
72 
73  llvm::FastMathFlags FMF;
74  if (CGM.getLangOpts().FastMath)
75  FMF.setFast();
76  if (CGM.getLangOpts().FiniteMathOnly) {
77  FMF.setNoNaNs();
78  FMF.setNoInfs();
79  }
80  if (CGM.getCodeGenOpts().NoNaNsFPMath) {
81  FMF.setNoNaNs();
82  }
83  if (CGM.getCodeGenOpts().NoSignedZeros) {
84  FMF.setNoSignedZeros();
85  }
86  if (CGM.getCodeGenOpts().ReciprocalMath) {
87  FMF.setAllowReciprocal();
88  }
89  if (CGM.getCodeGenOpts().Reassociate) {
90  FMF.setAllowReassoc();
91  }
92  Builder.setFastMathFlags(FMF);
93 }
94 
96  assert(LifetimeExtendedCleanupStack.empty() && "failed to emit a cleanup");
97 
98  // If there are any unclaimed block infos, go ahead and destroy them
99  // now. This can happen if IR-gen gets clever and skips evaluating
100  // something.
101  if (FirstBlockInfo)
103 
104  if (getLangOpts().OpenMP && CurFn)
105  CGM.getOpenMPRuntime().functionFinished(*this);
106 }
107 
109  LValueBaseInfo *BaseInfo,
110  TBAAAccessInfo *TBAAInfo) {
111  return getNaturalTypeAlignment(T->getPointeeType(), BaseInfo, TBAAInfo,
112  /* forPointeeType= */ true);
113 }
114 
116  LValueBaseInfo *BaseInfo,
117  TBAAAccessInfo *TBAAInfo,
118  bool forPointeeType) {
119  if (TBAAInfo)
120  *TBAAInfo = CGM.getTBAAAccessInfo(T);
121 
122  // Honor alignment typedef attributes even on incomplete types.
123  // We also honor them straight for C++ class types, even as pointees;
124  // there's an expressivity gap here.
125  if (auto TT = T->getAs<TypedefType>()) {
126  if (auto Align = TT->getDecl()->getMaxAlignment()) {
127  if (BaseInfo)
129  return getContext().toCharUnitsFromBits(Align);
130  }
131  }
132 
133  if (BaseInfo)
135 
136  CharUnits Alignment;
137  if (T->isIncompleteType()) {
138  Alignment = CharUnits::One(); // Shouldn't be used, but pessimistic is best.
139  } else {
140  // For C++ class pointees, we don't know whether we're pointing at a
141  // base or a complete object, so we generally need to use the
142  // non-virtual alignment.
143  const CXXRecordDecl *RD;
144  if (forPointeeType && (RD = T->getAsCXXRecordDecl())) {
145  Alignment = CGM.getClassPointerAlignment(RD);
146  } else {
147  Alignment = getContext().getTypeAlignInChars(T);
148  if (T.getQualifiers().hasUnaligned())
149  Alignment = CharUnits::One();
150  }
151 
152  // Cap to the global maximum type alignment unless the alignment
153  // was somehow explicit on the type.
154  if (unsigned MaxAlign = getLangOpts().MaxTypeAlign) {
155  if (Alignment.getQuantity() > MaxAlign &&
157  Alignment = CharUnits::fromQuantity(MaxAlign);
158  }
159  }
160  return Alignment;
161 }
162 
164  LValueBaseInfo BaseInfo;
165  TBAAAccessInfo TBAAInfo;
166  CharUnits Alignment = getNaturalTypeAlignment(T, &BaseInfo, &TBAAInfo);
167  return LValue::MakeAddr(Address(V, Alignment), T, getContext(), BaseInfo,
168  TBAAInfo);
169 }
170 
171 /// Given a value of type T* that may not be to a complete object,
172 /// construct an l-value with the natural pointee alignment of T.
173 LValue
175  LValueBaseInfo BaseInfo;
176  TBAAAccessInfo TBAAInfo;
177  CharUnits Align = getNaturalTypeAlignment(T, &BaseInfo, &TBAAInfo,
178  /* forPointeeType= */ true);
179  return MakeAddrLValue(Address(V, Align), T, BaseInfo, TBAAInfo);
180 }
181 
182 
184  return CGM.getTypes().ConvertTypeForMem(T);
185 }
186 
188  return CGM.getTypes().ConvertType(T);
189 }
190 
192  type = type.getCanonicalType();
193  while (true) {
194  switch (type->getTypeClass()) {
195 #define TYPE(name, parent)
196 #define ABSTRACT_TYPE(name, parent)
197 #define NON_CANONICAL_TYPE(name, parent) case Type::name:
198 #define DEPENDENT_TYPE(name, parent) case Type::name:
199 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(name, parent) case Type::name:
200 #include "clang/AST/TypeNodes.def"
201  llvm_unreachable("non-canonical or dependent type in IR-generation");
202 
203  case Type::Auto:
204  case Type::DeducedTemplateSpecialization:
205  llvm_unreachable("undeduced type in IR-generation");
206 
207  // Various scalar types.
208  case Type::Builtin:
209  case Type::Pointer:
210  case Type::BlockPointer:
211  case Type::LValueReference:
212  case Type::RValueReference:
213  case Type::MemberPointer:
214  case Type::Vector:
215  case Type::ExtVector:
216  case Type::FunctionProto:
217  case Type::FunctionNoProto:
218  case Type::Enum:
219  case Type::ObjCObjectPointer:
220  case Type::Pipe:
221  return TEK_Scalar;
222 
223  // Complexes.
224  case Type::Complex:
225  return TEK_Complex;
226 
227  // Arrays, records, and Objective-C objects.
228  case Type::ConstantArray:
229  case Type::IncompleteArray:
230  case Type::VariableArray:
231  case Type::Record:
232  case Type::ObjCObject:
233  case Type::ObjCInterface:
234  return TEK_Aggregate;
235 
236  // We operate on atomic values according to their underlying type.
237  case Type::Atomic:
238  type = cast<AtomicType>(type)->getValueType();
239  continue;
240  }
241  llvm_unreachable("unknown type kind!");
242  }
243 }
244 
246  // For cleanliness, we try to avoid emitting the return block for
247  // simple cases.
248  llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
249 
250  if (CurBB) {
251  assert(!CurBB->getTerminator() && "Unexpected terminated block.");
252 
253  // We have a valid insert point, reuse it if it is empty or there are no
254  // explicit jumps to the return block.
255  if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) {
256  ReturnBlock.getBlock()->replaceAllUsesWith(CurBB);
257  delete ReturnBlock.getBlock();
258  ReturnBlock = JumpDest();
259  } else
261  return llvm::DebugLoc();
262  }
263 
264  // Otherwise, if the return block is the target of a single direct
265  // branch then we can just put the code in that block instead. This
266  // cleans up functions which started with a unified return block.
267  if (ReturnBlock.getBlock()->hasOneUse()) {
268  llvm::BranchInst *BI =
269  dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->user_begin());
270  if (BI && BI->isUnconditional() &&
271  BI->getSuccessor(0) == ReturnBlock.getBlock()) {
272  // Record/return the DebugLoc of the simple 'return' expression to be used
273  // later by the actual 'ret' instruction.
274  llvm::DebugLoc Loc = BI->getDebugLoc();
275  Builder.SetInsertPoint(BI->getParent());
276  BI->eraseFromParent();
277  delete ReturnBlock.getBlock();
278  ReturnBlock = JumpDest();
279  return Loc;
280  }
281  }
282 
283  // FIXME: We are at an unreachable point, there is no reason to emit the block
284  // unless it has uses. However, we still need a place to put the debug
285  // region.end for now.
286 
288  return llvm::DebugLoc();
289 }
290 
291 static void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) {
292  if (!BB) return;
293  if (!BB->use_empty())
294  return CGF.CurFn->getBasicBlockList().push_back(BB);
295  delete BB;
296 }
297 
299  assert(BreakContinueStack.empty() &&
300  "mismatched push/pop in break/continue stack!");
301 
302  bool OnlySimpleReturnStmts = NumSimpleReturnExprs > 0
303  && NumSimpleReturnExprs == NumReturnExprs
304  && ReturnBlock.getBlock()->use_empty();
305  // Usually the return expression is evaluated before the cleanup
306  // code. If the function contains only a simple return statement,
307  // such as a constant, the location before the cleanup code becomes
308  // the last useful breakpoint in the function, because the simple
309  // return expression will be evaluated after the cleanup code. To be
310  // safe, set the debug location for cleanup code to the location of
311  // the return statement. Otherwise the cleanup code should be at the
312  // end of the function's lexical scope.
313  //
314  // If there are multiple branches to the return block, the branch
315  // instructions will get the location of the return statements and
316  // all will be fine.
317  if (CGDebugInfo *DI = getDebugInfo()) {
318  if (OnlySimpleReturnStmts)
319  DI->EmitLocation(Builder, LastStopPoint);
320  else
321  DI->EmitLocation(Builder, EndLoc);
322  }
323 
324  // Pop any cleanups that might have been associated with the
325  // parameters. Do this in whatever block we're currently in; it's
326  // important to do this before we enter the return block or return
327  // edges will be *really* confused.
328  bool HasCleanups = EHStack.stable_begin() != PrologueCleanupDepth;
329  bool HasOnlyLifetimeMarkers =
331  bool EmitRetDbgLoc = !HasCleanups || HasOnlyLifetimeMarkers;
332  if (HasCleanups) {
333  // Make sure the line table doesn't jump back into the body for
334  // the ret after it's been at EndLoc.
335  if (CGDebugInfo *DI = getDebugInfo())
336  if (OnlySimpleReturnStmts)
337  DI->EmitLocation(Builder, EndLoc);
338 
340  }
341 
342  // Emit function epilog (to return).
343  llvm::DebugLoc Loc = EmitReturnBlock();
344 
345  if (ShouldInstrumentFunction()) {
346  if (CGM.getCodeGenOpts().InstrumentFunctions)
347  CurFn->addFnAttr("instrument-function-exit", "__cyg_profile_func_exit");
348  if (CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining)
349  CurFn->addFnAttr("instrument-function-exit-inlined",
350  "__cyg_profile_func_exit");
351  }
352 
353  // Emit debug descriptor for function end.
354  if (CGDebugInfo *DI = getDebugInfo())
355  DI->EmitFunctionEnd(Builder, CurFn);
356 
357  // Reset the debug location to that of the simple 'return' expression, if any
358  // rather than that of the end of the function's scope '}'.
359  ApplyDebugLocation AL(*this, Loc);
360  EmitFunctionEpilog(*CurFnInfo, EmitRetDbgLoc, EndLoc);
362 
363  assert(EHStack.empty() &&
364  "did not remove all scopes from cleanup stack!");
365 
366  // If someone did an indirect goto, emit the indirect goto block at the end of
367  // the function.
368  if (IndirectBranch) {
369  EmitBlock(IndirectBranch->getParent());
370  Builder.ClearInsertionPoint();
371  }
372 
373  // If some of our locals escaped, insert a call to llvm.localescape in the
374  // entry block.
375  if (!EscapedLocals.empty()) {
376  // Invert the map from local to index into a simple vector. There should be
377  // no holes.
379  EscapeArgs.resize(EscapedLocals.size());
380  for (auto &Pair : EscapedLocals)
381  EscapeArgs[Pair.second] = Pair.first;
382  llvm::Function *FrameEscapeFn = llvm::Intrinsic::getDeclaration(
383  &CGM.getModule(), llvm::Intrinsic::localescape);
384  CGBuilderTy(*this, AllocaInsertPt).CreateCall(FrameEscapeFn, EscapeArgs);
385  }
386 
387  // Remove the AllocaInsertPt instruction, which is just a convenience for us.
388  llvm::Instruction *Ptr = AllocaInsertPt;
389  AllocaInsertPt = nullptr;
390  Ptr->eraseFromParent();
391 
392  // If someone took the address of a label but never did an indirect goto, we
393  // made a zero entry PHI node, which is illegal, zap it now.
394  if (IndirectBranch) {
395  llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress());
396  if (PN->getNumIncomingValues() == 0) {
397  PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType()));
398  PN->eraseFromParent();
399  }
400  }
401 
402  EmitIfUsed(*this, EHResumeBlock);
403  EmitIfUsed(*this, TerminateLandingPad);
404  EmitIfUsed(*this, TerminateHandler);
405  EmitIfUsed(*this, UnreachableBlock);
406 
407  for (const auto &FuncletAndParent : TerminateFunclets)
408  EmitIfUsed(*this, FuncletAndParent.second);
409 
410  if (CGM.getCodeGenOpts().EmitDeclMetadata)
411  EmitDeclMetadata();
412 
413  for (SmallVectorImpl<std::pair<llvm::Instruction *, llvm::Value *> >::iterator
414  I = DeferredReplacements.begin(),
415  E = DeferredReplacements.end();
416  I != E; ++I) {
417  I->first->replaceAllUsesWith(I->second);
418  I->first->eraseFromParent();
419  }
420 
421  // Eliminate CleanupDestSlot alloca by replacing it with SSA values and
422  // PHIs if the current function is a coroutine. We don't do it for all
423  // functions as it may result in slight increase in numbers of instructions
424  // if compiled with no optimizations. We do it for coroutine as the lifetime
425  // of CleanupDestSlot alloca make correct coroutine frame building very
426  // difficult.
428  llvm::DominatorTree DT(*CurFn);
429  llvm::PromoteMemToReg(
430  cast<llvm::AllocaInst>(NormalCleanupDest.getPointer()), DT);
432  }
433 
434  // Scan function arguments for vector width.
435  for (llvm::Argument &A : CurFn->args())
436  if (auto *VT = dyn_cast<llvm::VectorType>(A.getType()))
437  LargestVectorWidth = std::max(LargestVectorWidth,
438  VT->getPrimitiveSizeInBits());
439 
440  // Update vector width based on return type.
441  if (auto *VT = dyn_cast<llvm::VectorType>(CurFn->getReturnType()))
442  LargestVectorWidth = std::max(LargestVectorWidth,
443  VT->getPrimitiveSizeInBits());
444 
445  // Add the required-vector-width attribute. This contains the max width from:
446  // 1. min-vector-width attribute used in the source program.
447  // 2. Any builtins used that have a vector width specified.
448  // 3. Values passed in and out of inline assembly.
449  // 4. Width of vector arguments and return types for this function.
450  // 5. Width of vector aguments and return types for functions called by this
451  // function.
452  CurFn->addFnAttr("min-legal-vector-width", llvm::utostr(LargestVectorWidth));
453 
454  // If we generated an unreachable return block, delete it now.
455  if (ReturnBlock.isValid() && ReturnBlock.getBlock()->use_empty()) {
456  Builder.ClearInsertionPoint();
457  ReturnBlock.getBlock()->eraseFromParent();
458  }
459  if (ReturnValue.isValid()) {
460  auto *RetAlloca = dyn_cast<llvm::AllocaInst>(ReturnValue.getPointer());
461  if (RetAlloca && RetAlloca->use_empty()) {
462  RetAlloca->eraseFromParent();
464  }
465  }
466 }
467 
468 /// ShouldInstrumentFunction - Return true if the current function should be
469 /// instrumented with __cyg_profile_func_* calls
471  if (!CGM.getCodeGenOpts().InstrumentFunctions &&
472  !CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining &&
473  !CGM.getCodeGenOpts().InstrumentFunctionEntryBare)
474  return false;
475  if (!CurFuncDecl || CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>())
476  return false;
477  return true;
478 }
479 
480 /// ShouldXRayInstrument - Return true if the current function should be
481 /// instrumented with XRay nop sleds.
483  return CGM.getCodeGenOpts().XRayInstrumentFunctions;
484 }
485 
486 /// AlwaysEmitXRayCustomEvents - Return true if we should emit IR for calls to
487 /// the __xray_customevent(...) builtin calls, when doing XRay instrumentation.
489  return CGM.getCodeGenOpts().XRayInstrumentFunctions &&
490  (CGM.getCodeGenOpts().XRayAlwaysEmitCustomEvents ||
493 }
494 
496  return CGM.getCodeGenOpts().XRayInstrumentFunctions &&
497  (CGM.getCodeGenOpts().XRayAlwaysEmitTypedEvents ||
500 }
501 
502 llvm::Constant *
504  llvm::Constant *Addr) {
505  // Addresses stored in prologue data can't require run-time fixups and must
506  // be PC-relative. Run-time fixups are undesirable because they necessitate
507  // writable text segments, which are unsafe. And absolute addresses are
508  // undesirable because they break PIE mode.
509 
510  // Add a layer of indirection through a private global. Taking its address
511  // won't result in a run-time fixup, even if Addr has linkonce_odr linkage.
512  auto *GV = new llvm::GlobalVariable(CGM.getModule(), Addr->getType(),
513  /*isConstant=*/true,
514  llvm::GlobalValue::PrivateLinkage, Addr);
515 
516  // Create a PC-relative address.
517  auto *GOTAsInt = llvm::ConstantExpr::getPtrToInt(GV, IntPtrTy);
518  auto *FuncAsInt = llvm::ConstantExpr::getPtrToInt(F, IntPtrTy);
519  auto *PCRelAsInt = llvm::ConstantExpr::getSub(GOTAsInt, FuncAsInt);
520  return (IntPtrTy == Int32Ty)
521  ? PCRelAsInt
522  : llvm::ConstantExpr::getTrunc(PCRelAsInt, Int32Ty);
523 }
524 
525 llvm::Value *
527  llvm::Value *EncodedAddr) {
528  // Reconstruct the address of the global.
529  auto *PCRelAsInt = Builder.CreateSExt(EncodedAddr, IntPtrTy);
530  auto *FuncAsInt = Builder.CreatePtrToInt(F, IntPtrTy, "func_addr.int");
531  auto *GOTAsInt = Builder.CreateAdd(PCRelAsInt, FuncAsInt, "global_addr.int");
532  auto *GOTAddr = Builder.CreateIntToPtr(GOTAsInt, Int8PtrPtrTy, "global_addr");
533 
534  // Load the original pointer through the global.
535  return Builder.CreateLoad(Address(GOTAddr, getPointerAlign()),
536  "decoded_addr");
537 }
538 
539 void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,
540  llvm::Function *Fn)
541 {
542  if (!FD->hasAttr<OpenCLKernelAttr>())
543  return;
544 
545  llvm::LLVMContext &Context = getLLVMContext();
546 
547  CGM.GenOpenCLArgMetadata(Fn, FD, this);
548 
549  if (const VecTypeHintAttr *A = FD->getAttr<VecTypeHintAttr>()) {
550  QualType HintQTy = A->getTypeHint();
551  const ExtVectorType *HintEltQTy = HintQTy->getAs<ExtVectorType>();
552  bool IsSignedInteger =
553  HintQTy->isSignedIntegerType() ||
554  (HintEltQTy && HintEltQTy->getElementType()->isSignedIntegerType());
555  llvm::Metadata *AttrMDArgs[] = {
556  llvm::ConstantAsMetadata::get(llvm::UndefValue::get(
557  CGM.getTypes().ConvertType(A->getTypeHint()))),
558  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
559  llvm::IntegerType::get(Context, 32),
560  llvm::APInt(32, (uint64_t)(IsSignedInteger ? 1 : 0))))};
561  Fn->setMetadata("vec_type_hint", llvm::MDNode::get(Context, AttrMDArgs));
562  }
563 
564  if (const WorkGroupSizeHintAttr *A = FD->getAttr<WorkGroupSizeHintAttr>()) {
565  llvm::Metadata *AttrMDArgs[] = {
566  llvm::ConstantAsMetadata::get(Builder.getInt32(A->getXDim())),
567  llvm::ConstantAsMetadata::get(Builder.getInt32(A->getYDim())),
568  llvm::ConstantAsMetadata::get(Builder.getInt32(A->getZDim()))};
569  Fn->setMetadata("work_group_size_hint", llvm::MDNode::get(Context, AttrMDArgs));
570  }
571 
572  if (const ReqdWorkGroupSizeAttr *A = FD->getAttr<ReqdWorkGroupSizeAttr>()) {
573  llvm::Metadata *AttrMDArgs[] = {
574  llvm::ConstantAsMetadata::get(Builder.getInt32(A->getXDim())),
575  llvm::ConstantAsMetadata::get(Builder.getInt32(A->getYDim())),
576  llvm::ConstantAsMetadata::get(Builder.getInt32(A->getZDim()))};
577  Fn->setMetadata("reqd_work_group_size", llvm::MDNode::get(Context, AttrMDArgs));
578  }
579 
580  if (const OpenCLIntelReqdSubGroupSizeAttr *A =
581  FD->getAttr<OpenCLIntelReqdSubGroupSizeAttr>()) {
582  llvm::Metadata *AttrMDArgs[] = {
583  llvm::ConstantAsMetadata::get(Builder.getInt32(A->getSubGroupSize()))};
584  Fn->setMetadata("intel_reqd_sub_group_size",
585  llvm::MDNode::get(Context, AttrMDArgs));
586  }
587 }
588 
589 /// Determine whether the function F ends with a return stmt.
590 static bool endsWithReturn(const Decl* F) {
591  const Stmt *Body = nullptr;
592  if (auto *FD = dyn_cast_or_null<FunctionDecl>(F))
593  Body = FD->getBody();
594  else if (auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(F))
595  Body = OMD->getBody();
596 
597  if (auto *CS = dyn_cast_or_null<CompoundStmt>(Body)) {
598  auto LastStmt = CS->body_rbegin();
599  if (LastStmt != CS->body_rend())
600  return isa<ReturnStmt>(*LastStmt);
601  }
602  return false;
603 }
604 
606  if (SanOpts.has(SanitizerKind::Thread)) {
607  Fn->addFnAttr("sanitize_thread_no_checking_at_run_time");
608  Fn->removeFnAttr(llvm::Attribute::SanitizeThread);
609  }
610 }
611 
612 static bool matchesStlAllocatorFn(const Decl *D, const ASTContext &Ctx) {
613  auto *MD = dyn_cast_or_null<CXXMethodDecl>(D);
614  if (!MD || !MD->getDeclName().getAsIdentifierInfo() ||
615  !MD->getDeclName().getAsIdentifierInfo()->isStr("allocate") ||
616  (MD->getNumParams() != 1 && MD->getNumParams() != 2))
617  return false;
618 
619  if (MD->parameters()[0]->getType().getCanonicalType() != Ctx.getSizeType())
620  return false;
621 
622  if (MD->getNumParams() == 2) {
623  auto *PT = MD->parameters()[1]->getType()->getAs<PointerType>();
624  if (!PT || !PT->isVoidPointerType() ||
625  !PT->getPointeeType().isConstQualified())
626  return false;
627  }
628 
629  return true;
630 }
631 
632 /// Return the UBSan prologue signature for \p FD if one is available.
633 static llvm::Constant *getPrologueSignature(CodeGenModule &CGM,
634  const FunctionDecl *FD) {
635  if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
636  if (!MD->isStatic())
637  return nullptr;
639 }
640 
642  QualType RetTy,
643  llvm::Function *Fn,
644  const CGFunctionInfo &FnInfo,
645  const FunctionArgList &Args,
646  SourceLocation Loc,
647  SourceLocation StartLoc) {
648  assert(!CurFn &&
649  "Do not use a CodeGenFunction object for more than one function");
650 
651  const Decl *D = GD.getDecl();
652 
653  DidCallStackSave = false;
654  CurCodeDecl = D;
655  if (const auto *FD = dyn_cast_or_null<FunctionDecl>(D))
656  if (FD->usesSEHTry())
657  CurSEHParent = FD;
658  CurFuncDecl = (D ? D->getNonClosureContext() : nullptr);
659  FnRetTy = RetTy;
660  CurFn = Fn;
661  CurFnInfo = &FnInfo;
662  assert(CurFn->isDeclaration() && "Function already has body?");
663 
664  // If this function has been blacklisted for any of the enabled sanitizers,
665  // disable the sanitizer for the function.
666  do {
667 #define SANITIZER(NAME, ID) \
668  if (SanOpts.empty()) \
669  break; \
670  if (SanOpts.has(SanitizerKind::ID)) \
671  if (CGM.isInSanitizerBlacklist(SanitizerKind::ID, Fn, Loc)) \
672  SanOpts.set(SanitizerKind::ID, false);
673 
674 #include "clang/Basic/Sanitizers.def"
675 #undef SANITIZER
676  } while (0);
677 
678  if (D) {
679  // Apply the no_sanitize* attributes to SanOpts.
680  for (auto Attr : D->specific_attrs<NoSanitizeAttr>()) {
681  SanitizerMask mask = Attr->getMask();
682  SanOpts.Mask &= ~mask;
683  if (mask & SanitizerKind::Address)
684  SanOpts.set(SanitizerKind::KernelAddress, false);
685  if (mask & SanitizerKind::KernelAddress)
686  SanOpts.set(SanitizerKind::Address, false);
687  if (mask & SanitizerKind::HWAddress)
688  SanOpts.set(SanitizerKind::KernelHWAddress, false);
689  if (mask & SanitizerKind::KernelHWAddress)
690  SanOpts.set(SanitizerKind::HWAddress, false);
691  }
692  }
693 
694  // Apply sanitizer attributes to the function.
695  if (SanOpts.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress))
696  Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
697  if (SanOpts.hasOneOf(SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress))
698  Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
699  if (SanOpts.has(SanitizerKind::MemTag))
700  Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);
701  if (SanOpts.has(SanitizerKind::Thread))
702  Fn->addFnAttr(llvm::Attribute::SanitizeThread);
703  if (SanOpts.hasOneOf(SanitizerKind::Memory | SanitizerKind::KernelMemory))
704  Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
705  if (SanOpts.has(SanitizerKind::SafeStack))
706  Fn->addFnAttr(llvm::Attribute::SafeStack);
707  if (SanOpts.has(SanitizerKind::ShadowCallStack))
708  Fn->addFnAttr(llvm::Attribute::ShadowCallStack);
709 
710  // Apply fuzzing attribute to the function.
711  if (SanOpts.hasOneOf(SanitizerKind::Fuzzer | SanitizerKind::FuzzerNoLink))
712  Fn->addFnAttr(llvm::Attribute::OptForFuzzing);
713 
714  // Ignore TSan memory acesses from within ObjC/ObjC++ dealloc, initialize,
715  // .cxx_destruct, __destroy_helper_block_ and all of their calees at run time.
716  if (SanOpts.has(SanitizerKind::Thread)) {
717  if (const auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(D)) {
718  IdentifierInfo *II = OMD->getSelector().getIdentifierInfoForSlot(0);
719  if (OMD->getMethodFamily() == OMF_dealloc ||
720  OMD->getMethodFamily() == OMF_initialize ||
721  (OMD->getSelector().isUnarySelector() && II->isStr(".cxx_destruct"))) {
723  }
724  }
725  }
726 
727  // Ignore unrelated casts in STL allocate() since the allocator must cast
728  // from void* to T* before object initialization completes. Don't match on the
729  // namespace because not all allocators are in std::
730  if (D && SanOpts.has(SanitizerKind::CFIUnrelatedCast)) {
732  SanOpts.Mask &= ~SanitizerKind::CFIUnrelatedCast;
733  }
734 
735  // Apply xray attributes to the function (as a string, for now)
736  if (D) {
737  if (const auto *XRayAttr = D->getAttr<XRayInstrumentAttr>()) {
740  if (XRayAttr->alwaysXRayInstrument() && ShouldXRayInstrumentFunction())
741  Fn->addFnAttr("function-instrument", "xray-always");
742  if (XRayAttr->neverXRayInstrument())
743  Fn->addFnAttr("function-instrument", "xray-never");
744  if (const auto *LogArgs = D->getAttr<XRayLogArgsAttr>())
746  Fn->addFnAttr("xray-log-args",
747  llvm::utostr(LogArgs->getArgumentCount()));
748  }
749  } else {
751  Fn->addFnAttr(
752  "xray-instruction-threshold",
753  llvm::itostr(CGM.getCodeGenOpts().XRayInstructionThreshold));
754  }
755  }
756 
757  // Add no-jump-tables value.
758  Fn->addFnAttr("no-jump-tables",
759  llvm::toStringRef(CGM.getCodeGenOpts().NoUseJumpTables));
760 
761  // Add profile-sample-accurate value.
762  if (CGM.getCodeGenOpts().ProfileSampleAccurate)
763  Fn->addFnAttr("profile-sample-accurate");
764 
765  if (getLangOpts().OpenCL) {
766  // Add metadata for a kernel function.
767  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
768  EmitOpenCLKernelMetadata(FD, Fn);
769  }
770 
771  // If we are checking function types, emit a function type signature as
772  // prologue data.
774  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
775  if (llvm::Constant *PrologueSig = getPrologueSignature(CGM, FD)) {
776  // Remove any (C++17) exception specifications, to allow calling e.g. a
777  // noexcept function through a non-noexcept pointer.
778  auto ProtoTy =
780  EST_None);
781  llvm::Constant *FTRTTIConst =
782  CGM.GetAddrOfRTTIDescriptor(ProtoTy, /*ForEH=*/true);
783  llvm::Constant *FTRTTIConstEncoded =
784  EncodeAddrForUseInPrologue(Fn, FTRTTIConst);
785  llvm::Constant *PrologueStructElems[] = {PrologueSig,
786  FTRTTIConstEncoded};
787  llvm::Constant *PrologueStructConst =
788  llvm::ConstantStruct::getAnon(PrologueStructElems, /*Packed=*/true);
789  Fn->setPrologueData(PrologueStructConst);
790  }
791  }
792  }
793 
794  // If we're checking nullability, we need to know whether we can check the
795  // return value. Initialize the flag to 'true' and refine it in EmitParmDecl.
796  if (SanOpts.has(SanitizerKind::NullabilityReturn)) {
799  if (!(SanOpts.has(SanitizerKind::ReturnsNonnullAttribute) &&
800  CurCodeDecl && CurCodeDecl->getAttr<ReturnsNonNullAttr>()))
801  RetValNullabilityPrecondition =
802  llvm::ConstantInt::getTrue(getLLVMContext());
803  }
804  }
805 
806  // If we're in C++ mode and the function name is "main", it is guaranteed
807  // to be norecurse by the standard (3.6.1.3 "The function main shall not be
808  // used within a program").
809  if (getLangOpts().CPlusPlus)
810  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
811  if (FD->isMain())
812  Fn->addFnAttr(llvm::Attribute::NoRecurse);
813 
814  // If a custom alignment is used, force realigning to this alignment on
815  // any main function which certainly will need it.
816  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
817  if ((FD->isMain() || FD->isMSVCRTEntryPoint()) &&
818  CGM.getCodeGenOpts().StackAlignment)
819  Fn->addFnAttr("stackrealign");
820 
821  llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn);
822 
823  // Create a marker to make it easy to insert allocas into the entryblock
824  // later. Don't create this with the builder, because we don't want it
825  // folded.
826  llvm::Value *Undef = llvm::UndefValue::get(Int32Ty);
827  AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "allocapt", EntryBB);
828 
830 
831  Builder.SetInsertPoint(EntryBB);
832 
833  // If we're checking the return value, allocate space for a pointer to a
834  // precise source location of the checked return statement.
835  if (requiresReturnValueCheck()) {
836  ReturnLocation = CreateDefaultAlignTempAlloca(Int8PtrTy, "return.sloc.ptr");
837  InitTempAlloca(ReturnLocation, llvm::ConstantPointerNull::get(Int8PtrTy));
838  }
839 
840  // Emit subprogram debug descriptor.
841  if (CGDebugInfo *DI = getDebugInfo()) {
842  // Reconstruct the type from the argument list so that implicit parameters,
843  // such as 'this' and 'vtt', show up in the debug info. Preserve the calling
844  // convention.
846  if (auto *FD = dyn_cast_or_null<FunctionDecl>(D))
847  if (const auto *SrcFnTy = FD->getType()->getAs<FunctionType>())
848  CC = SrcFnTy->getCallConv();
849  SmallVector<QualType, 16> ArgTypes;
850  for (const VarDecl *VD : Args)
851  ArgTypes.push_back(VD->getType());
853  RetTy, ArgTypes, FunctionProtoType::ExtProtoInfo(CC));
854  DI->EmitFunctionStart(GD, Loc, StartLoc, FnType, CurFn, CurFuncIsThunk,
855  Builder);
856  }
857 
858  if (ShouldInstrumentFunction()) {
859  if (CGM.getCodeGenOpts().InstrumentFunctions)
860  CurFn->addFnAttr("instrument-function-entry", "__cyg_profile_func_enter");
861  if (CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining)
862  CurFn->addFnAttr("instrument-function-entry-inlined",
863  "__cyg_profile_func_enter");
864  if (CGM.getCodeGenOpts().InstrumentFunctionEntryBare)
865  CurFn->addFnAttr("instrument-function-entry-inlined",
866  "__cyg_profile_func_enter_bare");
867  }
868 
869  // Since emitting the mcount call here impacts optimizations such as function
870  // inlining, we just add an attribute to insert a mcount call in backend.
871  // The attribute "counting-function" is set to mcount function name which is
872  // architecture dependent.
873  if (CGM.getCodeGenOpts().InstrumentForProfiling) {
874  // Calls to fentry/mcount should not be generated if function has
875  // the no_instrument_function attribute.
876  if (!CurFuncDecl || !CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>()) {
877  if (CGM.getCodeGenOpts().CallFEntry)
878  Fn->addFnAttr("fentry-call", "true");
879  else {
880  Fn->addFnAttr("instrument-function-entry-inlined",
881  getTarget().getMCountName());
882  }
883  }
884  }
885 
886  if (RetTy->isVoidType()) {
887  // Void type; nothing to return.
889 
890  // Count the implicit return.
891  if (!endsWithReturn(D))
892  ++NumReturnExprs;
894  // Indirect return; emit returned value directly into sret slot.
895  // This reduces code size, and affects correctness in C++.
896  auto AI = CurFn->arg_begin();
898  ++AI;
906  }
909  // Load the sret pointer from the argument struct and return into that.
910  unsigned Idx = CurFnInfo->getReturnInfo().getInAllocaFieldIndex();
911  llvm::Function::arg_iterator EI = CurFn->arg_end();
912  --EI;
913  llvm::Value *Addr = Builder.CreateStructGEP(nullptr, &*EI, Idx);
915  Addr = Builder.CreateAlignedLoad(Addr, getPointerAlign(), "agg.result");
917  } else {
918  ReturnValue = CreateIRTemp(RetTy, "retval");
919 
920  // Tell the epilog emitter to autorelease the result. We do this
921  // now so that various specialized functions can suppress it
922  // during their IR-generation.
923  if (getLangOpts().ObjCAutoRefCount &&
925  RetTy->isObjCRetainableType())
926  AutoreleaseResult = true;
927  }
928 
930 
932 
933  // Emit OpenMP specific initialization of the device functions.
934  if (getLangOpts().OpenMP && CurCodeDecl)
935  CGM.getOpenMPRuntime().emitFunctionProlog(*this, CurCodeDecl);
936 
938 
939  if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) {
941  const CXXMethodDecl *MD = cast<CXXMethodDecl>(D);
942  if (MD->getParent()->isLambda() &&
943  MD->getOverloadedOperator() == OO_Call) {
944  // We're in a lambda; figure out the captures.
948  // If the lambda captures the object referred to by '*this' - either by
949  // value or by reference, make sure CXXThisValue points to the correct
950  // object.
951 
952  // Get the lvalue for the field (which is a copy of the enclosing object
953  // or contains the address of the enclosing object).
956  // If the enclosing object was captured by value, just use its address.
957  CXXThisValue = ThisFieldLValue.getAddress().getPointer();
958  } else {
959  // Load the lvalue pointed to by the field, since '*this' was captured
960  // by reference.
961  CXXThisValue =
962  EmitLoadOfLValue(ThisFieldLValue, SourceLocation()).getScalarVal();
963  }
964  }
965  for (auto *FD : MD->getParent()->fields()) {
966  if (FD->hasCapturedVLAType()) {
967  auto *ExprArg = EmitLoadOfLValue(EmitLValueForLambdaField(FD),
969  auto VAT = FD->getCapturedVLAType();
970  VLASizeMap[VAT->getSizeExpr()] = ExprArg;
971  }
972  }
973  } else {
974  // Not in a lambda; just use 'this' from the method.
975  // FIXME: Should we generate a new load for each use of 'this'? The
976  // fast register allocator would be happier...
977  CXXThisValue = CXXABIThisValue;
978  }
979 
980  // Check the 'this' pointer once per function, if it's available.
981  if (CXXABIThisValue) {
982  SanitizerSet SkippedChecks;
983  SkippedChecks.set(SanitizerKind::ObjectSize, true);
984  QualType ThisTy = MD->getThisType();
985 
986  // If this is the call operator of a lambda with no capture-default, it
987  // may have a static invoker function, which may call this operator with
988  // a null 'this' pointer.
989  if (isLambdaCallOperator(MD) &&
991  SkippedChecks.set(SanitizerKind::Null, true);
992 
993  EmitTypeCheck(isa<CXXConstructorDecl>(MD) ? TCK_ConstructorCall
994  : TCK_MemberCall,
995  Loc, CXXABIThisValue, ThisTy,
996  getContext().getTypeAlignInChars(ThisTy->getPointeeType()),
997  SkippedChecks);
998  }
999  }
1000 
1001  // If any of the arguments have a variably modified type, make sure to
1002  // emit the type size.
1003  for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
1004  i != e; ++i) {
1005  const VarDecl *VD = *i;
1006 
1007  // Dig out the type as written from ParmVarDecls; it's unclear whether
1008  // the standard (C99 6.9.1p10) requires this, but we're following the
1009  // precedent set by gcc.
1010  QualType Ty;
1011  if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD))
1012  Ty = PVD->getOriginalType();
1013  else
1014  Ty = VD->getType();
1015 
1016  if (Ty->isVariablyModifiedType())
1018  }
1019  // Emit a location at the end of the prologue.
1020  if (CGDebugInfo *DI = getDebugInfo())
1021  DI->EmitLocation(Builder, StartLoc);
1022 
1023  // TODO: Do we need to handle this in two places like we do with
1024  // target-features/target-cpu?
1025  if (CurFuncDecl)
1026  if (const auto *VecWidth = CurFuncDecl->getAttr<MinVectorWidthAttr>())
1027  LargestVectorWidth = VecWidth->getVectorWidth();
1028 }
1029 
1032  if (const CompoundStmt *S = dyn_cast<CompoundStmt>(Body))
1034  else
1035  EmitStmt(Body);
1036 }
1037 
1038 /// When instrumenting to collect profile data, the counts for some blocks
1039 /// such as switch cases need to not include the fall-through counts, so
1040 /// emit a branch around the instrumentation code. When not instrumenting,
1041 /// this just calls EmitBlock().
1043  const Stmt *S) {
1044  llvm::BasicBlock *SkipCountBB = nullptr;
1046  // When instrumenting for profiling, the fallthrough to certain
1047  // statements needs to skip over the instrumentation code so that we
1048  // get an accurate count.
1049  SkipCountBB = createBasicBlock("skipcount");
1050  EmitBranch(SkipCountBB);
1051  }
1052  EmitBlock(BB);
1053  uint64_t CurrentCount = getCurrentProfileCount();
1056  if (SkipCountBB)
1057  EmitBlock(SkipCountBB);
1058 }
1059 
1060 /// Tries to mark the given function nounwind based on the
1061 /// non-existence of any throwing calls within it. We believe this is
1062 /// lightweight enough to do at -O0.
1063 static void TryMarkNoThrow(llvm::Function *F) {
1064  // LLVM treats 'nounwind' on a function as part of the type, so we
1065  // can't do this on functions that can be overwritten.
1066  if (F->isInterposable()) return;
1067 
1068  for (llvm::BasicBlock &BB : *F)
1069  for (llvm::Instruction &I : BB)
1070  if (I.mayThrow())
1071  return;
1072 
1073  F->setDoesNotThrow();
1074 }
1075 
1077  FunctionArgList &Args) {
1078  const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
1079  QualType ResTy = FD->getReturnType();
1080 
1081  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
1082  if (MD && MD->isInstance()) {
1083  if (CGM.getCXXABI().HasThisReturn(GD))
1084  ResTy = MD->getThisType();
1085  else if (CGM.getCXXABI().hasMostDerivedReturn(GD))
1086  ResTy = CGM.getContext().VoidPtrTy;
1087  CGM.getCXXABI().buildThisParam(*this, Args);
1088  }
1089 
1090  // The base version of an inheriting constructor whose constructed base is a
1091  // virtual base is not passed any arguments (because it doesn't actually call
1092  // the inherited constructor).
1093  bool PassedParams = true;
1094  if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD))
1095  if (auto Inherited = CD->getInheritedConstructor())
1096  PassedParams =
1097  getTypes().inheritingCtorHasParams(Inherited, GD.getCtorType());
1098 
1099  if (PassedParams) {
1100  for (auto *Param : FD->parameters()) {
1101  Args.push_back(Param);
1102  if (!Param->hasAttr<PassObjectSizeAttr>())
1103  continue;
1104 
1105  auto *Implicit = ImplicitParamDecl::Create(
1106  getContext(), Param->getDeclContext(), Param->getLocation(),
1107  /*Id=*/nullptr, getContext().getSizeType(), ImplicitParamDecl::Other);
1108  SizeArguments[Param] = Implicit;
1109  Args.push_back(Implicit);
1110  }
1111  }
1112 
1113  if (MD && (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)))
1114  CGM.getCXXABI().addImplicitStructorParams(*this, ResTy, Args);
1115 
1116  return ResTy;
1117 }
1118 
1119 static bool
1121  const ASTContext &Context) {
1122  QualType T = FD->getReturnType();
1123  // Avoid the optimization for functions that return a record type with a
1124  // trivial destructor or another trivially copyable type.
1125  if (const RecordType *RT = T.getCanonicalType()->getAs<RecordType>()) {
1126  if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl()))
1127  return !ClassDecl->hasTrivialDestructor();
1128  }
1129  return !T.isTriviallyCopyableType(Context);
1130 }
1131 
1132 void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn,
1133  const CGFunctionInfo &FnInfo) {
1134  const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
1135  CurGD = GD;
1136 
1137  FunctionArgList Args;
1138  QualType ResTy = BuildFunctionArgList(GD, Args);
1139 
1140  // Check if we should generate debug info for this function.
1141  if (FD->hasAttr<NoDebugAttr>())
1142  DebugInfo = nullptr; // disable debug info indefinitely for this function
1143 
1144  // The function might not have a body if we're generating thunks for a
1145  // function declaration.
1146  SourceRange BodyRange;
1147  if (Stmt *Body = FD->getBody())
1148  BodyRange = Body->getSourceRange();
1149  else
1150  BodyRange = FD->getLocation();
1151  CurEHLocation = BodyRange.getEnd();
1152 
1153  // Use the location of the start of the function to determine where
1154  // the function definition is located. By default use the location
1155  // of the declaration as the location for the subprogram. A function
1156  // may lack a declaration in the source code if it is created by code
1157  // gen. (examples: _GLOBAL__I_a, __cxx_global_array_dtor, thunk).
1158  SourceLocation Loc = FD->getLocation();
1159 
1160  // If this is a function specialization then use the pattern body
1161  // as the location for the function.
1162  if (const FunctionDecl *SpecDecl = FD->getTemplateInstantiationPattern())
1163  if (SpecDecl->hasBody(SpecDecl))
1164  Loc = SpecDecl->getLocation();
1165 
1166  Stmt *Body = FD->getBody();
1167 
1168  // Initialize helper which will detect jumps which can cause invalid lifetime
1169  // markers.
1170  if (Body && ShouldEmitLifetimeMarkers)
1171  Bypasses.Init(Body);
1172 
1173  // Emit the standard function prologue.
1174  StartFunction(GD, ResTy, Fn, FnInfo, Args, Loc, BodyRange.getBegin());
1175 
1176  // Generate the body of the function.
1177  PGO.assignRegionCounters(GD, CurFn);
1178  if (isa<CXXDestructorDecl>(FD))
1179  EmitDestructorBody(Args);
1180  else if (isa<CXXConstructorDecl>(FD))
1181  EmitConstructorBody(Args);
1182  else if (getLangOpts().CUDA &&
1183  !getLangOpts().CUDAIsDevice &&
1184  FD->hasAttr<CUDAGlobalAttr>())
1185  CGM.getCUDARuntime().emitDeviceStub(*this, Args);
1186  else if (isa<CXXMethodDecl>(FD) &&
1187  cast<CXXMethodDecl>(FD)->isLambdaStaticInvoker()) {
1188  // The lambda static invoker function is special, because it forwards or
1189  // clones the body of the function call operator (but is actually static).
1190  EmitLambdaStaticInvokeBody(cast<CXXMethodDecl>(FD));
1191  } else if (FD->isDefaulted() && isa<CXXMethodDecl>(FD) &&
1192  (cast<CXXMethodDecl>(FD)->isCopyAssignmentOperator() ||
1193  cast<CXXMethodDecl>(FD)->isMoveAssignmentOperator())) {
1194  // Implicit copy-assignment gets the same special treatment as implicit
1195  // copy-constructors.
1197  } else if (Body) {
1198  EmitFunctionBody(Body);
1199  } else
1200  llvm_unreachable("no definition for emitted function");
1201 
1202  // C++11 [stmt.return]p2:
1203  // Flowing off the end of a function [...] results in undefined behavior in
1204  // a value-returning function.
1205  // C11 6.9.1p12:
1206  // If the '}' that terminates a function is reached, and the value of the
1207  // function call is used by the caller, the behavior is undefined.
1209  !FD->getReturnType()->isVoidType() && Builder.GetInsertBlock()) {
1210  bool ShouldEmitUnreachable =
1211  CGM.getCodeGenOpts().StrictReturn ||
1213  if (SanOpts.has(SanitizerKind::Return)) {
1214  SanitizerScope SanScope(this);
1215  llvm::Value *IsFalse = Builder.getFalse();
1216  EmitCheck(std::make_pair(IsFalse, SanitizerKind::Return),
1217  SanitizerHandler::MissingReturn,
1218  EmitCheckSourceLocation(FD->getLocation()), None);
1219  } else if (ShouldEmitUnreachable) {
1220  if (CGM.getCodeGenOpts().OptimizationLevel == 0)
1221  EmitTrapCall(llvm::Intrinsic::trap);
1222  }
1223  if (SanOpts.has(SanitizerKind::Return) || ShouldEmitUnreachable) {
1224  Builder.CreateUnreachable();
1225  Builder.ClearInsertionPoint();
1226  }
1227  }
1228 
1229  // Emit the standard function epilogue.
1230  FinishFunction(BodyRange.getEnd());
1231 
1232  // If we haven't marked the function nothrow through other means, do
1233  // a quick pass now to see if we can.
1234  if (!CurFn->doesNotThrow())
1236 }
1237 
1238 /// ContainsLabel - Return true if the statement contains a label in it. If
1239 /// this statement is not executed normally, it not containing a label means
1240 /// that we can just remove the code.
1241 bool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) {
1242  // Null statement, not a label!
1243  if (!S) return false;
1244 
1245  // If this is a label, we have to emit the code, consider something like:
1246  // if (0) { ... foo: bar(); } goto foo;
1247  //
1248  // TODO: If anyone cared, we could track __label__'s, since we know that you
1249  // can't jump to one from outside their declared region.
1250  if (isa<LabelStmt>(S))
1251  return true;
1252 
1253  // If this is a case/default statement, and we haven't seen a switch, we have
1254  // to emit the code.
1255  if (isa<SwitchCase>(S) && !IgnoreCaseStmts)
1256  return true;
1257 
1258  // If this is a switch statement, we want to ignore cases below it.
1259  if (isa<SwitchStmt>(S))
1260  IgnoreCaseStmts = true;
1261 
1262  // Scan subexpressions for verboten labels.
1263  for (const Stmt *SubStmt : S->children())
1264  if (ContainsLabel(SubStmt, IgnoreCaseStmts))
1265  return true;
1266 
1267  return false;
1268 }
1269 
1270 /// containsBreak - Return true if the statement contains a break out of it.
1271 /// If the statement (recursively) contains a switch or loop with a break
1272 /// inside of it, this is fine.
1274  // Null statement, not a label!
1275  if (!S) return false;
1276 
1277  // If this is a switch or loop that defines its own break scope, then we can
1278  // include it and anything inside of it.
1279  if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || isa<DoStmt>(S) ||
1280  isa<ForStmt>(S))
1281  return false;
1282 
1283  if (isa<BreakStmt>(S))
1284  return true;
1285 
1286  // Scan subexpressions for verboten breaks.
1287  for (const Stmt *SubStmt : S->children())
1288  if (containsBreak(SubStmt))
1289  return true;
1290 
1291  return false;
1292 }
1293 
1295  if (!S) return false;
1296 
1297  // Some statement kinds add a scope and thus never add a decl to the current
1298  // scope. Note, this list is longer than the list of statements that might
1299  // have an unscoped decl nested within them, but this way is conservatively
1300  // correct even if more statement kinds are added.
1301  if (isa<IfStmt>(S) || isa<SwitchStmt>(S) || isa<WhileStmt>(S) ||
1302  isa<DoStmt>(S) || isa<ForStmt>(S) || isa<CompoundStmt>(S) ||
1303  isa<CXXForRangeStmt>(S) || isa<CXXTryStmt>(S) ||
1304  isa<ObjCForCollectionStmt>(S) || isa<ObjCAtTryStmt>(S))
1305  return false;
1306 
1307  if (isa<DeclStmt>(S))
1308  return true;
1309 
1310  for (const Stmt *SubStmt : S->children())
1311  if (mightAddDeclToScope(SubStmt))
1312  return true;
1313 
1314  return false;
1315 }
1316 
1317 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
1318 /// to a constant, or if it does but contains a label, return false. If it
1319 /// constant folds return true and set the boolean result in Result.
1321  bool &ResultBool,
1322  bool AllowLabels) {
1323  llvm::APSInt ResultInt;
1324  if (!ConstantFoldsToSimpleInteger(Cond, ResultInt, AllowLabels))
1325  return false;
1326 
1327  ResultBool = ResultInt.getBoolValue();
1328  return true;
1329 }
1330 
1331 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
1332 /// to a constant, or if it does but contains a label, return false. If it
1333 /// constant folds return true and set the folded value.
1335  llvm::APSInt &ResultInt,
1336  bool AllowLabels) {
1337  // FIXME: Rename and handle conversion of other evaluatable things
1338  // to bool.
1339  Expr::EvalResult Result;
1340  if (!Cond->EvaluateAsInt(Result, getContext()))
1341  return false; // Not foldable, not integer or not fully evaluatable.
1342 
1343  llvm::APSInt Int = Result.Val.getInt();
1344  if (!AllowLabels && CodeGenFunction::ContainsLabel(Cond))
1345  return false; // Contains a label.
1346 
1347  ResultInt = Int;
1348  return true;
1349 }
1350 
1351 
1352 
1353 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if
1354 /// statement) to the specified blocks. Based on the condition, this might try
1355 /// to simplify the codegen of the conditional based on the branch.
1356 ///
1358  llvm::BasicBlock *TrueBlock,
1359  llvm::BasicBlock *FalseBlock,
1360  uint64_t TrueCount) {
1361  Cond = Cond->IgnoreParens();
1362 
1363  if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) {
1364 
1365  // Handle X && Y in a condition.
1366  if (CondBOp->getOpcode() == BO_LAnd) {
1367  // If we have "1 && X", simplify the code. "0 && X" would have constant
1368  // folded if the case was simple enough.
1369  bool ConstantBool = false;
1370  if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) &&
1371  ConstantBool) {
1372  // br(1 && X) -> br(X).
1373  incrementProfileCounter(CondBOp);
1374  return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock,
1375  TrueCount);
1376  }
1377 
1378  // If we have "X && 1", simplify the code to use an uncond branch.
1379  // "X && 0" would have been constant folded to 0.
1380  if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) &&
1381  ConstantBool) {
1382  // br(X && 1) -> br(X).
1383  return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock,
1384  TrueCount);
1385  }
1386 
1387  // Emit the LHS as a conditional. If the LHS conditional is false, we
1388  // want to jump to the FalseBlock.
1389  llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true");
1390  // The counter tells us how often we evaluate RHS, and all of TrueCount
1391  // can be propagated to that branch.
1392  uint64_t RHSCount = getProfileCount(CondBOp->getRHS());
1393 
1394  ConditionalEvaluation eval(*this);
1395  {
1396  ApplyDebugLocation DL(*this, Cond);
1397  EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock, RHSCount);
1398  EmitBlock(LHSTrue);
1399  }
1400 
1401  incrementProfileCounter(CondBOp);
1402  setCurrentProfileCount(getProfileCount(CondBOp->getRHS()));
1403 
1404  // Any temporaries created here are conditional.
1405  eval.begin(*this);
1406  EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock, TrueCount);
1407  eval.end(*this);
1408 
1409  return;
1410  }
1411 
1412  if (CondBOp->getOpcode() == BO_LOr) {
1413  // If we have "0 || X", simplify the code. "1 || X" would have constant
1414  // folded if the case was simple enough.
1415  bool ConstantBool = false;
1416  if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) &&
1417  !ConstantBool) {
1418  // br(0 || X) -> br(X).
1419  incrementProfileCounter(CondBOp);
1420  return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock,
1421  TrueCount);
1422  }
1423 
1424  // If we have "X || 0", simplify the code to use an uncond branch.
1425  // "X || 1" would have been constant folded to 1.
1426  if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) &&
1427  !ConstantBool) {
1428  // br(X || 0) -> br(X).
1429  return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock,
1430  TrueCount);
1431  }
1432 
1433  // Emit the LHS as a conditional. If the LHS conditional is true, we
1434  // want to jump to the TrueBlock.
1435  llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false");
1436  // We have the count for entry to the RHS and for the whole expression
1437  // being true, so we can divy up True count between the short circuit and
1438  // the RHS.
1439  uint64_t LHSCount =
1440  getCurrentProfileCount() - getProfileCount(CondBOp->getRHS());
1441  uint64_t RHSCount = TrueCount - LHSCount;
1442 
1443  ConditionalEvaluation eval(*this);
1444  {
1445  ApplyDebugLocation DL(*this, Cond);
1446  EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse, LHSCount);
1447  EmitBlock(LHSFalse);
1448  }
1449 
1450  incrementProfileCounter(CondBOp);
1451  setCurrentProfileCount(getProfileCount(CondBOp->getRHS()));
1452 
1453  // Any temporaries created here are conditional.
1454  eval.begin(*this);
1455  EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock, RHSCount);
1456 
1457  eval.end(*this);
1458 
1459  return;
1460  }
1461  }
1462 
1463  if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) {
1464  // br(!x, t, f) -> br(x, f, t)
1465  if (CondUOp->getOpcode() == UO_LNot) {
1466  // Negate the count.
1467  uint64_t FalseCount = getCurrentProfileCount() - TrueCount;
1468  // Negate the condition and swap the destination blocks.
1469  return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock,
1470  FalseCount);
1471  }
1472  }
1473 
1474  if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) {
1475  // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f))
1476  llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true");
1477  llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false");
1478 
1479  ConditionalEvaluation cond(*this);
1480  EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock,
1481  getProfileCount(CondOp));
1482 
1483  // When computing PGO branch weights, we only know the overall count for
1484  // the true block. This code is essentially doing tail duplication of the
1485  // naive code-gen, introducing new edges for which counts are not
1486  // available. Divide the counts proportionally between the LHS and RHS of
1487  // the conditional operator.
1488  uint64_t LHSScaledTrueCount = 0;
1489  if (TrueCount) {
1490  double LHSRatio =
1491  getProfileCount(CondOp) / (double)getCurrentProfileCount();
1492  LHSScaledTrueCount = TrueCount * LHSRatio;
1493  }
1494 
1495  cond.begin(*this);
1496  EmitBlock(LHSBlock);
1497  incrementProfileCounter(CondOp);
1498  {
1499  ApplyDebugLocation DL(*this, Cond);
1500  EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock,
1501  LHSScaledTrueCount);
1502  }
1503  cond.end(*this);
1504 
1505  cond.begin(*this);
1506  EmitBlock(RHSBlock);
1507  EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock,
1508  TrueCount - LHSScaledTrueCount);
1509  cond.end(*this);
1510 
1511  return;
1512  }
1513 
1514  if (const CXXThrowExpr *Throw = dyn_cast<CXXThrowExpr>(Cond)) {
1515  // Conditional operator handling can give us a throw expression as a
1516  // condition for a case like:
1517  // br(c ? throw x : y, t, f) -> br(c, br(throw x, t, f), br(y, t, f)
1518  // Fold this to:
1519  // br(c, throw x, br(y, t, f))
1520  EmitCXXThrowExpr(Throw, /*KeepInsertionPoint*/false);
1521  return;
1522  }
1523 
1524  // If the branch has a condition wrapped by __builtin_unpredictable,
1525  // create metadata that specifies that the branch is unpredictable.
1526  // Don't bother if not optimizing because that metadata would not be used.
1527  llvm::MDNode *Unpredictable = nullptr;
1528  auto *Call = dyn_cast<CallExpr>(Cond->IgnoreImpCasts());
1529  if (Call && CGM.getCodeGenOpts().OptimizationLevel != 0) {
1530  auto *FD = dyn_cast_or_null<FunctionDecl>(Call->getCalleeDecl());
1531  if (FD && FD->getBuiltinID() == Builtin::BI__builtin_unpredictable) {
1532  llvm::MDBuilder MDHelper(getLLVMContext());
1533  Unpredictable = MDHelper.createUnpredictable();
1534  }
1535  }
1536 
1537  // Create branch weights based on the number of times we get here and the
1538  // number of times the condition should be true.
1539  uint64_t CurrentCount = std::max(getCurrentProfileCount(), TrueCount);
1540  llvm::MDNode *Weights =
1541  createProfileWeights(TrueCount, CurrentCount - TrueCount);
1542 
1543  // Emit the code with the fully general case.
1544  llvm::Value *CondV;
1545  {
1546  ApplyDebugLocation DL(*this, Cond);
1547  CondV = EvaluateExprAsBool(Cond);
1548  }
1549  Builder.CreateCondBr(CondV, TrueBlock, FalseBlock, Weights, Unpredictable);
1550 }
1551 
1552 /// ErrorUnsupported - Print out an error that codegen doesn't support the
1553 /// specified stmt yet.
1554 void CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type) {
1555  CGM.ErrorUnsupported(S, Type);
1556 }
1557 
1558 /// emitNonZeroVLAInit - Emit the "zero" initialization of a
1559 /// variable-length array whose elements have a non-zero bit-pattern.
1560 ///
1561 /// \param baseType the inner-most element type of the array
1562 /// \param src - a char* pointing to the bit-pattern for a single
1563 /// base element of the array
1564 /// \param sizeInChars - the total size of the VLA, in chars
1565 static void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType,
1566  Address dest, Address src,
1567  llvm::Value *sizeInChars) {
1568  CGBuilderTy &Builder = CGF.Builder;
1569 
1570  CharUnits baseSize = CGF.getContext().getTypeSizeInChars(baseType);
1571  llvm::Value *baseSizeInChars
1572  = llvm::ConstantInt::get(CGF.IntPtrTy, baseSize.getQuantity());
1573 
1574  Address begin =
1575  Builder.CreateElementBitCast(dest, CGF.Int8Ty, "vla.begin");
1576  llvm::Value *end =
1577  Builder.CreateInBoundsGEP(begin.getPointer(), sizeInChars, "vla.end");
1578 
1579  llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock();
1580  llvm::BasicBlock *loopBB = CGF.createBasicBlock("vla-init.loop");
1581  llvm::BasicBlock *contBB = CGF.createBasicBlock("vla-init.cont");
1582 
1583  // Make a loop over the VLA. C99 guarantees that the VLA element
1584  // count must be nonzero.
1585  CGF.EmitBlock(loopBB);
1586 
1587  llvm::PHINode *cur = Builder.CreatePHI(begin.getType(), 2, "vla.cur");
1588  cur->addIncoming(begin.getPointer(), originBB);
1589 
1590  CharUnits curAlign =
1591  dest.getAlignment().alignmentOfArrayElement(baseSize);
1592 
1593  // memcpy the individual element bit-pattern.
1594  Builder.CreateMemCpy(Address(cur, curAlign), src, baseSizeInChars,
1595  /*volatile*/ false);
1596 
1597  // Go to the next element.
1598  llvm::Value *next =
1599  Builder.CreateInBoundsGEP(CGF.Int8Ty, cur, baseSizeInChars, "vla.next");
1600 
1601  // Leave if that's the end of the VLA.
1602  llvm::Value *done = Builder.CreateICmpEQ(next, end, "vla-init.isdone");
1603  Builder.CreateCondBr(done, contBB, loopBB);
1604  cur->addIncoming(next, loopBB);
1605 
1606  CGF.EmitBlock(contBB);
1607 }
1608 
1609 void
1611  // Ignore empty classes in C++.
1612  if (getLangOpts().CPlusPlus) {
1613  if (const RecordType *RT = Ty->getAs<RecordType>()) {
1614  if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty())
1615  return;
1616  }
1617  }
1618 
1619  // Cast the dest ptr to the appropriate i8 pointer type.
1620  if (DestPtr.getElementType() != Int8Ty)
1621  DestPtr = Builder.CreateElementBitCast(DestPtr, Int8Ty);
1622 
1623  // Get size and alignment info for this aggregate.
1625 
1626  llvm::Value *SizeVal;
1627  const VariableArrayType *vla;
1628 
1629  // Don't bother emitting a zero-byte memset.
1630  if (size.isZero()) {
1631  // But note that getTypeInfo returns 0 for a VLA.
1632  if (const VariableArrayType *vlaType =
1633  dyn_cast_or_null<VariableArrayType>(
1634  getContext().getAsArrayType(Ty))) {
1635  auto VlaSize = getVLASize(vlaType);
1636  SizeVal = VlaSize.NumElts;
1637  CharUnits eltSize = getContext().getTypeSizeInChars(VlaSize.Type);
1638  if (!eltSize.isOne())
1639  SizeVal = Builder.CreateNUWMul(SizeVal, CGM.getSize(eltSize));
1640  vla = vlaType;
1641  } else {
1642  return;
1643  }
1644  } else {
1645  SizeVal = CGM.getSize(size);
1646  vla = nullptr;
1647  }
1648 
1649  // If the type contains a pointer to data member we can't memset it to zero.
1650  // Instead, create a null constant and copy it to the destination.
1651  // TODO: there are other patterns besides zero that we can usefully memset,
1652  // like -1, which happens to be the pattern used by member-pointers.
1653  if (!CGM.getTypes().isZeroInitializable(Ty)) {
1654  // For a VLA, emit a single element, then splat that over the VLA.
1655  if (vla) Ty = getContext().getBaseElementType(vla);
1656 
1657  llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty);
1658 
1659  llvm::GlobalVariable *NullVariable =
1660  new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(),
1661  /*isConstant=*/true,
1662  llvm::GlobalVariable::PrivateLinkage,
1663  NullConstant, Twine());
1664  CharUnits NullAlign = DestPtr.getAlignment();
1665  NullVariable->setAlignment(NullAlign.getQuantity());
1666  Address SrcPtr(Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()),
1667  NullAlign);
1668 
1669  if (vla) return emitNonZeroVLAInit(*this, Ty, DestPtr, SrcPtr, SizeVal);
1670 
1671  // Get and call the appropriate llvm.memcpy overload.
1672  Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, false);
1673  return;
1674  }
1675 
1676  // Otherwise, just memset the whole thing to zero. This is legal
1677  // because in LLVM, all default initializers (other than the ones we just
1678  // handled above) are guaranteed to have a bit pattern of all zeros.
1679  Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal, false);
1680 }
1681 
1682 llvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelDecl *L) {
1683  // Make sure that there is a block for the indirect goto.
1684  if (!IndirectBranch)
1686 
1687  llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock();
1688 
1689  // Make sure the indirect branch includes all of the address-taken blocks.
1690  IndirectBranch->addDestination(BB);
1691  return llvm::BlockAddress::get(CurFn, BB);
1692 }
1693 
1695  // If we already made the indirect branch for indirect goto, return its block.
1696  if (IndirectBranch) return IndirectBranch->getParent();
1697 
1698  CGBuilderTy TmpBuilder(*this, createBasicBlock("indirectgoto"));
1699 
1700  // Create the PHI node that indirect gotos will add entries to.
1701  llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, 0,
1702  "indirect.goto.dest");
1703 
1704  // Create the indirect branch instruction.
1705  IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal);
1706  return IndirectBranch->getParent();
1707 }
1708 
1709 /// Computes the length of an array in elements, as well as the base
1710 /// element type and a properly-typed first element pointer.
1712  QualType &baseType,
1713  Address &addr) {
1714  const ArrayType *arrayType = origArrayType;
1715 
1716  // If it's a VLA, we have to load the stored size. Note that
1717  // this is the size of the VLA in bytes, not its size in elements.
1718  llvm::Value *numVLAElements = nullptr;
1719  if (isa<VariableArrayType>(arrayType)) {
1720  numVLAElements = getVLASize(cast<VariableArrayType>(arrayType)).NumElts;
1721 
1722  // Walk into all VLAs. This doesn't require changes to addr,
1723  // which has type T* where T is the first non-VLA element type.
1724  do {
1725  QualType elementType = arrayType->getElementType();
1726  arrayType = getContext().getAsArrayType(elementType);
1727 
1728  // If we only have VLA components, 'addr' requires no adjustment.
1729  if (!arrayType) {
1730  baseType = elementType;
1731  return numVLAElements;
1732  }
1733  } while (isa<VariableArrayType>(arrayType));
1734 
1735  // We get out here only if we find a constant array type
1736  // inside the VLA.
1737  }
1738 
1739  // We have some number of constant-length arrays, so addr should
1740  // have LLVM type [M x [N x [...]]]*. Build a GEP that walks
1741  // down to the first element of addr.
1742  SmallVector<llvm::Value*, 8> gepIndices;
1743 
1744  // GEP down to the array type.
1745  llvm::ConstantInt *zero = Builder.getInt32(0);
1746  gepIndices.push_back(zero);
1747 
1748  uint64_t countFromCLAs = 1;
1749  QualType eltType;
1750 
1751  llvm::ArrayType *llvmArrayType =
1752  dyn_cast<llvm::ArrayType>(addr.getElementType());
1753  while (llvmArrayType) {
1754  assert(isa<ConstantArrayType>(arrayType));
1755  assert(cast<ConstantArrayType>(arrayType)->getSize().getZExtValue()
1756  == llvmArrayType->getNumElements());
1757 
1758  gepIndices.push_back(zero);
1759  countFromCLAs *= llvmArrayType->getNumElements();
1760  eltType = arrayType->getElementType();
1761 
1762  llvmArrayType =
1763  dyn_cast<llvm::ArrayType>(llvmArrayType->getElementType());
1764  arrayType = getContext().getAsArrayType(arrayType->getElementType());
1765  assert((!llvmArrayType || arrayType) &&
1766  "LLVM and Clang types are out-of-synch");
1767  }
1768 
1769  if (arrayType) {
1770  // From this point onwards, the Clang array type has been emitted
1771  // as some other type (probably a packed struct). Compute the array
1772  // size, and just emit the 'begin' expression as a bitcast.
1773  while (arrayType) {
1774  countFromCLAs *=
1775  cast<ConstantArrayType>(arrayType)->getSize().getZExtValue();
1776  eltType = arrayType->getElementType();
1777  arrayType = getContext().getAsArrayType(eltType);
1778  }
1779 
1780  llvm::Type *baseType = ConvertType(eltType);
1781  addr = Builder.CreateElementBitCast(addr, baseType, "array.begin");
1782  } else {
1783  // Create the actual GEP.
1784  addr = Address(Builder.CreateInBoundsGEP(addr.getPointer(),
1785  gepIndices, "array.begin"),
1786  addr.getAlignment());
1787  }
1788 
1789  baseType = eltType;
1790 
1791  llvm::Value *numElements
1792  = llvm::ConstantInt::get(SizeTy, countFromCLAs);
1793 
1794  // If we had any VLA dimensions, factor them in.
1795  if (numVLAElements)
1796  numElements = Builder.CreateNUWMul(numVLAElements, numElements);
1797 
1798  return numElements;
1799 }
1800 
1803  assert(vla && "type was not a variable array type!");
1804  return getVLASize(vla);
1805 }
1806 
1809  // The number of elements so far; always size_t.
1810  llvm::Value *numElements = nullptr;
1811 
1812  QualType elementType;
1813  do {
1814  elementType = type->getElementType();
1815  llvm::Value *vlaSize = VLASizeMap[type->getSizeExpr()];
1816  assert(vlaSize && "no size for VLA!");
1817  assert(vlaSize->getType() == SizeTy);
1818 
1819  if (!numElements) {
1820  numElements = vlaSize;
1821  } else {
1822  // It's undefined behavior if this wraps around, so mark it that way.
1823  // FIXME: Teach -fsanitize=undefined to trap this.
1824  numElements = Builder.CreateNUWMul(numElements, vlaSize);
1825  }
1826  } while ((type = getContext().getAsVariableArrayType(elementType)));
1827 
1828  return { numElements, elementType };
1829 }
1830 
1834  assert(vla && "type was not a variable array type!");
1835  return getVLAElements1D(vla);
1836 }
1837 
1840  llvm::Value *VlaSize = VLASizeMap[Vla->getSizeExpr()];
1841  assert(VlaSize && "no size for VLA!");
1842  assert(VlaSize->getType() == SizeTy);
1843  return { VlaSize, Vla->getElementType() };
1844 }
1845 
1847  assert(type->isVariablyModifiedType() &&
1848  "Must pass variably modified type to EmitVLASizes!");
1849 
1851 
1852  // We're going to walk down into the type and look for VLA
1853  // expressions.
1854  do {
1855  assert(type->isVariablyModifiedType());
1856 
1857  const Type *ty = type.getTypePtr();
1858  switch (ty->getTypeClass()) {
1859 
1860 #define TYPE(Class, Base)
1861 #define ABSTRACT_TYPE(Class, Base)
1862 #define NON_CANONICAL_TYPE(Class, Base)
1863 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
1864 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
1865 #include "clang/AST/TypeNodes.def"
1866  llvm_unreachable("unexpected dependent type!");
1867 
1868  // These types are never variably-modified.
1869  case Type::Builtin:
1870  case Type::Complex:
1871  case Type::Vector:
1872  case Type::ExtVector:
1873  case Type::Record:
1874  case Type::Enum:
1875  case Type::Elaborated:
1876  case Type::TemplateSpecialization:
1877  case Type::ObjCTypeParam:
1878  case Type::ObjCObject:
1879  case Type::ObjCInterface:
1880  case Type::ObjCObjectPointer:
1881  llvm_unreachable("type class is never variably-modified!");
1882 
1883  case Type::Adjusted:
1884  type = cast<AdjustedType>(ty)->getAdjustedType();
1885  break;
1886 
1887  case Type::Decayed:
1888  type = cast<DecayedType>(ty)->getPointeeType();
1889  break;
1890 
1891  case Type::Pointer:
1892  type = cast<PointerType>(ty)->getPointeeType();
1893  break;
1894 
1895  case Type::BlockPointer:
1896  type = cast<BlockPointerType>(ty)->getPointeeType();
1897  break;
1898 
1899  case Type::LValueReference:
1900  case Type::RValueReference:
1901  type = cast<ReferenceType>(ty)->getPointeeType();
1902  break;
1903 
1904  case Type::MemberPointer:
1905  type = cast<MemberPointerType>(ty)->getPointeeType();
1906  break;
1907 
1908  case Type::ConstantArray:
1909  case Type::IncompleteArray:
1910  // Losing element qualification here is fine.
1911  type = cast<ArrayType>(ty)->getElementType();
1912  break;
1913 
1914  case Type::VariableArray: {
1915  // Losing element qualification here is fine.
1916  const VariableArrayType *vat = cast<VariableArrayType>(ty);
1917 
1918  // Unknown size indication requires no size computation.
1919  // Otherwise, evaluate and record it.
1920  if (const Expr *size = vat->getSizeExpr()) {
1921  // It's possible that we might have emitted this already,
1922  // e.g. with a typedef and a pointer to it.
1923  llvm::Value *&entry = VLASizeMap[size];
1924  if (!entry) {
1925  llvm::Value *Size = EmitScalarExpr(size);
1926 
1927  // C11 6.7.6.2p5:
1928  // If the size is an expression that is not an integer constant
1929  // expression [...] each time it is evaluated it shall have a value
1930  // greater than zero.
1931  if (SanOpts.has(SanitizerKind::VLABound) &&
1932  size->getType()->isSignedIntegerType()) {
1933  SanitizerScope SanScope(this);
1934  llvm::Value *Zero = llvm::Constant::getNullValue(Size->getType());
1935  llvm::Constant *StaticArgs[] = {
1936  EmitCheckSourceLocation(size->getBeginLoc()),
1937  EmitCheckTypeDescriptor(size->getType())};
1938  EmitCheck(std::make_pair(Builder.CreateICmpSGT(Size, Zero),
1939  SanitizerKind::VLABound),
1940  SanitizerHandler::VLABoundNotPositive, StaticArgs, Size);
1941  }
1942 
1943  // Always zexting here would be wrong if it weren't
1944  // undefined behavior to have a negative bound.
1945  entry = Builder.CreateIntCast(Size, SizeTy, /*signed*/ false);
1946  }
1947  }
1948  type = vat->getElementType();
1949  break;
1950  }
1951 
1952  case Type::FunctionProto:
1953  case Type::FunctionNoProto:
1954  type = cast<FunctionType>(ty)->getReturnType();
1955  break;
1956 
1957  case Type::Paren:
1958  case Type::TypeOf:
1959  case Type::UnaryTransform:
1960  case Type::Attributed:
1961  case Type::SubstTemplateTypeParm:
1962  case Type::PackExpansion:
1963  case Type::MacroQualified:
1964  // Keep walking after single level desugaring.
1965  type = type.getSingleStepDesugaredType(getContext());
1966  break;
1967 
1968  case Type::Typedef:
1969  case Type::Decltype:
1970  case Type::Auto:
1971  case Type::DeducedTemplateSpecialization:
1972  // Stop walking: nothing to do.
1973  return;
1974 
1975  case Type::TypeOfExpr:
1976  // Stop walking: emit typeof expression.
1977  EmitIgnoredExpr(cast<TypeOfExprType>(ty)->getUnderlyingExpr());
1978  return;
1979 
1980  case Type::Atomic:
1981  type = cast<AtomicType>(ty)->getValueType();
1982  break;
1983 
1984  case Type::Pipe:
1985  type = cast<PipeType>(ty)->getElementType();
1986  break;
1987  }
1988  } while (type->isVariablyModifiedType());
1989 }
1990 
1992  if (getContext().getBuiltinVaListType()->isArrayType())
1993  return EmitPointerWithAlignment(E);
1994  return EmitLValue(E).getAddress();
1995 }
1996 
1998  return EmitLValue(E).getAddress();
1999 }
2000 
2002  const APValue &Init) {
2003  assert(Init.hasValue() && "Invalid DeclRefExpr initializer!");
2004  if (CGDebugInfo *Dbg = getDebugInfo())
2005  if (CGM.getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo)
2006  Dbg->EmitGlobalVariable(E->getDecl(), Init);
2007 }
2008 
2011  // At the moment, the only aggressive peephole we do in IR gen
2012  // is trunc(zext) folding, but if we add more, we can easily
2013  // extend this protection.
2014 
2015  if (!rvalue.isScalar()) return PeepholeProtection();
2016  llvm::Value *value = rvalue.getScalarVal();
2017  if (!isa<llvm::ZExtInst>(value)) return PeepholeProtection();
2018 
2019  // Just make an extra bitcast.
2020  assert(HaveInsertPoint());
2021  llvm::Instruction *inst = new llvm::BitCastInst(value, value->getType(), "",
2022  Builder.GetInsertBlock());
2023 
2024  PeepholeProtection protection;
2025  protection.Inst = inst;
2026  return protection;
2027 }
2028 
2030  if (!protection.Inst) return;
2031 
2032  // In theory, we could try to duplicate the peepholes now, but whatever.
2033  protection.Inst->eraseFromParent();
2034 }
2035 
2037  QualType Ty, SourceLocation Loc,
2038  SourceLocation AssumptionLoc,
2039  llvm::Value *Alignment,
2040  llvm::Value *OffsetValue) {
2041  llvm::Value *TheCheck;
2042  llvm::Instruction *Assumption = Builder.CreateAlignmentAssumption(
2043  CGM.getDataLayout(), PtrValue, Alignment, OffsetValue, &TheCheck);
2044  if (SanOpts.has(SanitizerKind::Alignment)) {
2045  EmitAlignmentAssumptionCheck(PtrValue, Ty, Loc, AssumptionLoc, Alignment,
2046  OffsetValue, TheCheck, Assumption);
2047  }
2048 }
2049 
2051  QualType Ty, SourceLocation Loc,
2052  SourceLocation AssumptionLoc,
2053  unsigned Alignment,
2054  llvm::Value *OffsetValue) {
2055  llvm::Value *TheCheck;
2056  llvm::Instruction *Assumption = Builder.CreateAlignmentAssumption(
2057  CGM.getDataLayout(), PtrValue, Alignment, OffsetValue, &TheCheck);
2058  if (SanOpts.has(SanitizerKind::Alignment)) {
2059  llvm::Value *AlignmentVal = llvm::ConstantInt::get(IntPtrTy, Alignment);
2060  EmitAlignmentAssumptionCheck(PtrValue, Ty, Loc, AssumptionLoc, AlignmentVal,
2061  OffsetValue, TheCheck, Assumption);
2062  }
2063 }
2064 
2066  const Expr *E,
2067  SourceLocation AssumptionLoc,
2068  unsigned Alignment,
2069  llvm::Value *OffsetValue) {
2070  if (auto *CE = dyn_cast<CastExpr>(E))
2071  E = CE->getSubExprAsWritten();
2072  QualType Ty = E->getType();
2073  SourceLocation Loc = E->getExprLoc();
2074 
2075  EmitAlignmentAssumption(PtrValue, Ty, Loc, AssumptionLoc, Alignment,
2076  OffsetValue);
2077 }
2078 
2079 llvm::Value *CodeGenFunction::EmitAnnotationCall(llvm::Function *AnnotationFn,
2080  llvm::Value *AnnotatedVal,
2081  StringRef AnnotationStr,
2082  SourceLocation Location) {
2083  llvm::Value *Args[4] = {
2084  AnnotatedVal,
2087  CGM.EmitAnnotationLineNo(Location)
2088  };
2089  return Builder.CreateCall(AnnotationFn, Args);
2090 }
2091 
2093  assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
2094  // FIXME We create a new bitcast for every annotation because that's what
2095  // llvm-gcc was doing.
2096  for (const auto *I : D->specific_attrs<AnnotateAttr>())
2097  EmitAnnotationCall(CGM.getIntrinsic(llvm::Intrinsic::var_annotation),
2098  Builder.CreateBitCast(V, CGM.Int8PtrTy, V->getName()),
2099  I->getAnnotation(), D->getLocation());
2100 }
2101 
2103  Address Addr) {
2104  assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
2105  llvm::Value *V = Addr.getPointer();
2106  llvm::Type *VTy = V->getType();
2107  llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::ptr_annotation,
2108  CGM.Int8PtrTy);
2109 
2110  for (const auto *I : D->specific_attrs<AnnotateAttr>()) {
2111  // FIXME Always emit the cast inst so we can differentiate between
2112  // annotation on the first field of a struct and annotation on the struct
2113  // itself.
2114  if (VTy != CGM.Int8PtrTy)
2116  V = EmitAnnotationCall(F, V, I->getAnnotation(), D->getLocation());
2117  V = Builder.CreateBitCast(V, VTy);
2118  }
2119 
2120  return Address(V, Addr.getAlignment());
2121 }
2122 
2124 
2126  : CGF(CGF) {
2127  assert(!CGF->IsSanitizerScope);
2128  CGF->IsSanitizerScope = true;
2129 }
2130 
2132  CGF->IsSanitizerScope = false;
2133 }
2134 
2135 void CodeGenFunction::InsertHelper(llvm::Instruction *I,
2136  const llvm::Twine &Name,
2137  llvm::BasicBlock *BB,
2138  llvm::BasicBlock::iterator InsertPt) const {
2140  if (IsSanitizerScope)
2142 }
2143 
2145  llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB,
2146  llvm::BasicBlock::iterator InsertPt) const {
2147  llvm::IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt);
2148  if (CGF)
2149  CGF->InsertHelper(I, Name, BB, InsertPt);
2150 }
2151 
2152 static bool hasRequiredFeatures(const SmallVectorImpl<StringRef> &ReqFeatures,
2153  CodeGenModule &CGM, const FunctionDecl *FD,
2154  std::string &FirstMissing) {
2155  // If there aren't any required features listed then go ahead and return.
2156  if (ReqFeatures.empty())
2157  return false;
2158 
2159  // Now build up the set of caller features and verify that all the required
2160  // features are there.
2161  llvm::StringMap<bool> CallerFeatureMap;
2162  CGM.getFunctionFeatureMap(CallerFeatureMap, GlobalDecl().getWithDecl(FD));
2163 
2164  // If we have at least one of the features in the feature list return
2165  // true, otherwise return false.
2166  return std::all_of(
2167  ReqFeatures.begin(), ReqFeatures.end(), [&](StringRef Feature) {
2168  SmallVector<StringRef, 1> OrFeatures;
2169  Feature.split(OrFeatures, '|');
2170  return llvm::any_of(OrFeatures, [&](StringRef Feature) {
2171  if (!CallerFeatureMap.lookup(Feature)) {
2172  FirstMissing = Feature.str();
2173  return false;
2174  }
2175  return true;
2176  });
2177  });
2178 }
2179 
2180 // Emits an error if we don't have a valid set of target features for the
2181 // called function.
2183  const FunctionDecl *TargetDecl) {
2184  return checkTargetFeatures(E->getBeginLoc(), TargetDecl);
2185 }
2186 
2187 // Emits an error if we don't have a valid set of target features for the
2188 // called function.
2190  const FunctionDecl *TargetDecl) {
2191  // Early exit if this is an indirect call.
2192  if (!TargetDecl)
2193  return;
2194 
2195  // Get the current enclosing function if it exists. If it doesn't
2196  // we can't check the target features anyhow.
2197  const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurFuncDecl);
2198  if (!FD)
2199  return;
2200 
2201  // Grab the required features for the call. For a builtin this is listed in
2202  // the td file with the default cpu, for an always_inline function this is any
2203  // listed cpu and any listed features.
2204  unsigned BuiltinID = TargetDecl->getBuiltinID();
2205  std::string MissingFeature;
2206  if (BuiltinID) {
2207  SmallVector<StringRef, 1> ReqFeatures;
2208  const char *FeatureList =
2210  // Return if the builtin doesn't have any required features.
2211  if (!FeatureList || StringRef(FeatureList) == "")
2212  return;
2213  StringRef(FeatureList).split(ReqFeatures, ',');
2214  if (!hasRequiredFeatures(ReqFeatures, CGM, FD, MissingFeature))
2215  CGM.getDiags().Report(Loc, diag::err_builtin_needs_feature)
2216  << TargetDecl->getDeclName()
2218 
2219  } else if (TargetDecl->hasAttr<TargetAttr>() ||
2220  TargetDecl->hasAttr<CPUSpecificAttr>()) {
2221  // Get the required features for the callee.
2222 
2223  const TargetAttr *TD = TargetDecl->getAttr<TargetAttr>();
2224  TargetAttr::ParsedTargetAttr ParsedAttr = CGM.filterFunctionTargetAttrs(TD);
2225 
2226  SmallVector<StringRef, 1> ReqFeatures;
2227  llvm::StringMap<bool> CalleeFeatureMap;
2228  CGM.getFunctionFeatureMap(CalleeFeatureMap, TargetDecl);
2229 
2230  for (const auto &F : ParsedAttr.Features) {
2231  if (F[0] == '+' && CalleeFeatureMap.lookup(F.substr(1)))
2232  ReqFeatures.push_back(StringRef(F).substr(1));
2233  }
2234 
2235  for (const auto &F : CalleeFeatureMap) {
2236  // Only positive features are "required".
2237  if (F.getValue())
2238  ReqFeatures.push_back(F.getKey());
2239  }
2240  if (!hasRequiredFeatures(ReqFeatures, CGM, FD, MissingFeature))
2241  CGM.getDiags().Report(Loc, diag::err_function_needs_feature)
2242  << FD->getDeclName() << TargetDecl->getDeclName() << MissingFeature;
2243  }
2244 }
2245 
2246 void CodeGenFunction::EmitSanitizerStatReport(llvm::SanitizerStatKind SSK) {
2247  if (!CGM.getCodeGenOpts().SanitizeStats)
2248  return;
2249 
2250  llvm::IRBuilder<> IRB(Builder.GetInsertBlock(), Builder.GetInsertPoint());
2251  IRB.SetCurrentDebugLocation(Builder.getCurrentDebugLocation());
2252  CGM.getSanStats().create(IRB, SSK);
2253 }
2254 
2255 llvm::Value *
2256 CodeGenFunction::FormResolverCondition(const MultiVersionResolverOption &RO) {
2257  llvm::Value *Condition = nullptr;
2258 
2259  if (!RO.Conditions.Architecture.empty())
2260  Condition = EmitX86CpuIs(RO.Conditions.Architecture);
2261 
2262  if (!RO.Conditions.Features.empty()) {
2263  llvm::Value *FeatureCond = EmitX86CpuSupports(RO.Conditions.Features);
2264  Condition =
2265  Condition ? Builder.CreateAnd(Condition, FeatureCond) : FeatureCond;
2266  }
2267  return Condition;
2268 }
2269 
2271  llvm::Function *Resolver,
2273  llvm::Function *FuncToReturn,
2274  bool SupportsIFunc) {
2275  if (SupportsIFunc) {
2276  Builder.CreateRet(FuncToReturn);
2277  return;
2278  }
2279 
2281  llvm::for_each(Resolver->args(),
2282  [&](llvm::Argument &Arg) { Args.push_back(&Arg); });
2283 
2284  llvm::CallInst *Result = Builder.CreateCall(FuncToReturn, Args);
2285  Result->setTailCallKind(llvm::CallInst::TCK_MustTail);
2286 
2287  if (Resolver->getReturnType()->isVoidTy())
2288  Builder.CreateRetVoid();
2289  else
2290  Builder.CreateRet(Result);
2291 }
2292 
2294  llvm::Function *Resolver, ArrayRef<MultiVersionResolverOption> Options) {
2295  assert((getContext().getTargetInfo().getTriple().getArch() ==
2296  llvm::Triple::x86 ||
2297  getContext().getTargetInfo().getTriple().getArch() ==
2298  llvm::Triple::x86_64) &&
2299  "Only implemented for x86 targets");
2300 
2301  bool SupportsIFunc = getContext().getTargetInfo().supportsIFunc();
2302 
2303  // Main function's basic block.
2304  llvm::BasicBlock *CurBlock = createBasicBlock("resolver_entry", Resolver);
2305  Builder.SetInsertPoint(CurBlock);
2306  EmitX86CpuInit();
2307 
2308  for (const MultiVersionResolverOption &RO : Options) {
2309  Builder.SetInsertPoint(CurBlock);
2310  llvm::Value *Condition = FormResolverCondition(RO);
2311 
2312  // The 'default' or 'generic' case.
2313  if (!Condition) {
2314  assert(&RO == Options.end() - 1 &&
2315  "Default or Generic case must be last");
2317  SupportsIFunc);
2318  return;
2319  }
2320 
2321  llvm::BasicBlock *RetBlock = createBasicBlock("resolver_return", Resolver);
2322  CGBuilderTy RetBuilder(*this, RetBlock);
2323  CreateMultiVersionResolverReturn(CGM, Resolver, RetBuilder, RO.Function,
2324  SupportsIFunc);
2325  CurBlock = createBasicBlock("resolver_else", Resolver);
2326  Builder.CreateCondBr(Condition, RetBlock, CurBlock);
2327  }
2328 
2329  // If no generic/default, emit an unreachable.
2330  Builder.SetInsertPoint(CurBlock);
2331  llvm::CallInst *TrapCall = EmitTrapCall(llvm::Intrinsic::trap);
2332  TrapCall->setDoesNotReturn();
2333  TrapCall->setDoesNotThrow();
2334  Builder.CreateUnreachable();
2335  Builder.ClearInsertionPoint();
2336 }
2337 
2338 // Loc - where the diagnostic will point, where in the source code this
2339 // alignment has failed.
2340 // SecondaryLoc - if present (will be present if sufficiently different from
2341 // Loc), the diagnostic will additionally point a "Note:" to this location.
2342 // It should be the location where the __attribute__((assume_aligned))
2343 // was written e.g.
2345  llvm::Value *Ptr, QualType Ty, SourceLocation Loc,
2346  SourceLocation SecondaryLoc, llvm::Value *Alignment,
2347  llvm::Value *OffsetValue, llvm::Value *TheCheck,
2348  llvm::Instruction *Assumption) {
2349  assert(Assumption && isa<llvm::CallInst>(Assumption) &&
2350  cast<llvm::CallInst>(Assumption)->getCalledValue() ==
2351  llvm::Intrinsic::getDeclaration(
2352  Builder.GetInsertBlock()->getParent()->getParent(),
2353  llvm::Intrinsic::assume) &&
2354  "Assumption should be a call to llvm.assume().");
2355  assert(&(Builder.GetInsertBlock()->back()) == Assumption &&
2356  "Assumption should be the last instruction of the basic block, "
2357  "since the basic block is still being generated.");
2358 
2359  if (!SanOpts.has(SanitizerKind::Alignment))
2360  return;
2361 
2362  // Don't check pointers to volatile data. The behavior here is implementation-
2363  // defined.
2364  if (Ty->getPointeeType().isVolatileQualified())
2365  return;
2366 
2367  // We need to temorairly remove the assumption so we can insert the
2368  // sanitizer check before it, else the check will be dropped by optimizations.
2369  Assumption->removeFromParent();
2370 
2371  {
2372  SanitizerScope SanScope(this);
2373 
2374  if (!OffsetValue)
2375  OffsetValue = Builder.getInt1(0); // no offset.
2376 
2377  llvm::Constant *StaticData[] = {EmitCheckSourceLocation(Loc),
2378  EmitCheckSourceLocation(SecondaryLoc),
2380  llvm::Value *DynamicData[] = {EmitCheckValue(Ptr),
2381  EmitCheckValue(Alignment),
2382  EmitCheckValue(OffsetValue)};
2383  EmitCheck({std::make_pair(TheCheck, SanitizerKind::Alignment)},
2384  SanitizerHandler::AlignmentAssumption, StaticData, DynamicData);
2385  }
2386 
2387  // We are now in the (new, empty) "cont" basic block.
2388  // Reintroduce the assumption.
2389  Builder.Insert(Assumption);
2390  // FIXME: Assumption still has it's original basic block as it's Parent.
2391 }
2392 
2394  if (CGDebugInfo *DI = getDebugInfo())
2395  return DI->SourceLocToDebugLoc(Location);
2396 
2397  return llvm::DebugLoc();
2398 }
const llvm::DataLayout & getDataLayout() const
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Address CreateStructGEP(Address Addr, unsigned Index, const llvm::Twine &Name="")
Definition: CGBuilder.h:178
Defines the clang::ASTContext interface.
Represents a function declaration or definition.
Definition: Decl.h:1748
LValue MakeNaturalAlignPointeeAddrLValue(llvm::Value *V, QualType T)
Given a value of type T* that may not be to a complete object, construct an l-value with the natural ...
Other implicit parameter.
Definition: Decl.h:1524
no exception specification
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2569
CanQualType VoidPtrTy
Definition: ASTContext.h:1042
A (possibly-)qualified type.
Definition: Type.h:643
llvm::Type * ConvertTypeForMem(QualType T)
void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount)
EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g.
const CodeGenOptions & getCodeGenOpts() const
bool isReturnsRetained() const
In ARC, whether this function retains its return value.
llvm::Constant * EmitCheckTypeDescriptor(QualType T)
Emit a description of a type in a format suitable for passing to a runtime sanitizer handler...
Definition: CGExpr.cpp:2785
bool HaveInsertPoint() const
HaveInsertPoint - True if an insertion point is defined.
llvm::Constant * EncodeAddrForUseInPrologue(llvm::Function *F, llvm::Constant *Addr)
Encode an address into a form suitable for use in a function prologue.
XRayInstrMask Mask
Definition: XRayInstr.h:64
Specialize PointerLikeTypeTraits to allow LazyGenerationalUpdatePtr to be placed into a PointerUnion...
Definition: Dominators.h:30
virtual void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy, FunctionArgList &Params)=0
Insert any ABI-specific implicit parameters into the parameter list for a function.
CharUnits getClassPointerAlignment(const CXXRecordDecl *CD)
Returns the assumed alignment of an opaque pointer to the given class.
Definition: CGClass.cpp:36
Stmt - This represents one statement.
Definition: Stmt.h:66
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3387
SanitizerSet Sanitize
Set of enabled sanitizers.
Definition: LangOptions.h:184
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:505
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program...
Definition: Decl.cpp:2837
static bool endsWithReturn(const Decl *F)
Determine whether the function F ends with a return stmt.
QualType getThisType() const
Return the type of the this pointer.
Definition: DeclCXX.cpp:2275
Checking the &#39;this&#39; pointer for a constructor call.
Address EmitPointerWithAlignment(const Expr *Addr, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
EmitPointerWithAlignment - Given an expression with a pointer type, emit the value and compute our be...
Definition: CGExpr.cpp:1037
constexpr XRayInstrMask Typed
Definition: XRayInstr.h:40
__v8hi zero
Definition: emmintrin.h:1397
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
void EmitLambdaStaticInvokeBody(const CXXMethodDecl *MD)
Definition: CGClass.cpp:2920
void EmitCheck(ArrayRef< std::pair< llvm::Value *, SanitizerMask >> Checked, SanitizerHandler Check, ArrayRef< llvm::Constant *> StaticArgs, ArrayRef< llvm::Value *> DynamicArgs)
Create a basic block that will either trap or call a handler function in the UBSan runtime with the p...
Definition: CGExpr.cpp:2999
The base class of the type hierarchy.
Definition: Type.h:1433
bool ShouldInstrumentFunction()
ShouldInstrumentFunction - Return true if the current function should be instrumented with __cyg_prof...
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1297
bool hasValue() const
Definition: APValue.h:315
bool usesSEHTry() const
Indicates the function uses __try.
Definition: Decl.h:2141
void GenerateCode(GlobalDecl GD, llvm::Function *Fn, const CGFunctionInfo &FnInfo)
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2844
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:115
static bool hasRequiredFeatures(const SmallVectorImpl< StringRef > &ReqFeatures, CodeGenModule &CGM, const FunctionDecl *FD, std::string &FirstMissing)
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
Definition: EHScopeStack.h:378
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:693
void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB, llvm::BasicBlock::iterator InsertPt) const
CGBuilder insert helper.
bool imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc, StringRef Category=StringRef()) const
Imbue XRay attributes to a function, applying the always/never attribute lists in the process...
constexpr XRayInstrMask Function
Definition: XRayInstr.h:38
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2574
bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result, bool AllowLabels=false)
ConstantFoldsToSimpleInteger - If the specified expression does not fold to a constant, or if it does but contains a label, return false.
QualType getElementType() const
Definition: Type.h:2879
bool empty() const
Determines whether the exception-scopes stack is empty.
Definition: EHScopeStack.h:344
This file provides some common utility functions for processing Lambda related AST Constructs...
TypeEvaluationKind
The kind of evaluation to perform on values of a particular type.
Represents a variable declaration or definition.
Definition: Decl.h:812
QualType getReturnType() const
Definition: Decl.h:2329
RAII object to set/unset CodeGenFunction::IsSanitizerScope.
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6851
Extra information about a function prototype.
Definition: Type.h:3799
static bool shouldEmitLifetimeMarkers(const CodeGenOptions &CGOpts, const LangOptions &LangOpts)
shouldEmitLifetimeMarkers - Decide whether we need emit the life-time markers.
uint64_t getProfileCount(const Stmt *S)
Get the profiler&#39;s count for the given statement.
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
Definition: CGDebugInfo.h:54
static bool mightAddDeclToScope(const Stmt *S)
Determine if the given statement might introduce a declaration into the current scope, by being a (possibly-labelled) DeclStmt.
DiagnosticsEngine & getDiags() const
llvm::CallInst * EmitTrapCall(llvm::Intrinsic::ID IntrID)
Emit a call to trap or debugtrap and attach function attribute "trap-func-name" if specified...
Definition: CGExpr.cpp:3296
void EmitVariablyModifiedType(QualType Ty)
EmitVLASize - Capture all the sizes for the VLA expressions in the given variably-modified type and s...
void setCurrentProfileCount(uint64_t Count)
Set the profiler&#39;s current count.
bool ShouldXRayInstrumentFunction() const
ShouldXRayInstrument - Return true if the current function should be instrumented with XRay nop sleds...
llvm::Value * getPointer() const
Definition: Address.h:37
virtual llvm::Constant * getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const
Return a constant used by UBSan as a signature to identify functions possessing type information...
Definition: TargetInfo.h:168
void markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn)
Annotate the function with an attribute that disables TSan checking at runtime.
bool IsSanitizerScope
True if CodeGen currently emits code implementing sanitizer checks.
Defines the Objective-C statement AST node classes.
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:1049
bool supportsIFunc() const
Identify whether this target supports IFuncs.
Definition: TargetInfo.h:1129
Represents a parameter to a function.
Definition: Decl.h:1564
static void destroyBlockInfos(CGBlockInfo *info)
Destroy a chain of block layouts.
Definition: CGBlocks.cpp:890
void emitImplicitAssignmentOperatorBody(FunctionArgList &Args)
Definition: CGClass.cpp:1530
long i
Definition: xmmintrin.h:1456
EHScopeStack::stable_iterator PrologueCleanupDepth
PrologueCleanupDepth - The cleanup depth enclosing all the cleanups associated with the parameters...
A jump destination is an abstract label, branching to which may require a jump out through normal cle...
JumpDest getJumpDestForLabel(const LabelDecl *S)
getBasicBlockForLabel - Return the LLVM basicblock that the specified label maps to.
Definition: CGStmt.cpp:509
llvm::DenseMap< const VarDecl *, FieldDecl * > LambdaCaptureFields
const TargetInfo & getTarget() const
An object to manage conditionally-evaluated expressions.
PeepholeProtection protectFromPeepholes(RValue rvalue)
protectFromPeepholes - Protect a value that we&#39;re intending to store to the side, but which will prob...
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
void EmitAlignmentAssumptionCheck(llvm::Value *Ptr, QualType Ty, SourceLocation Loc, SourceLocation AssumptionLoc, llvm::Value *Alignment, llvm::Value *OffsetValue, llvm::Value *TheCheck, llvm::Instruction *Assumption)
One of these records is kept for each identifier that is lexed.
VlaSizePair getVLAElements1D(const VariableArrayType *vla)
Return the number of elements for a single dimension for the given array type.
CGBlockInfo * FirstBlockInfo
FirstBlockInfo - The head of a singly-linked-list of block layouts.
void EmitFunctionEpilog(const CGFunctionInfo &FI, bool EmitRetDbgLoc, SourceLocation EndLoc)
EmitFunctionEpilog - Emit the target specific LLVM code to return the given temporary.
Definition: CGCall.cpp:2790
static void CreateMultiVersionResolverReturn(CodeGenModule &CGM, llvm::Function *Resolver, CGBuilderTy &Builder, llvm::Function *FuncToReturn, bool SupportsIFunc)
Address getAddress() const
Definition: CGValue.h:326
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
Indirect - Pass the argument indirectly via a hidden pointer with the specified alignment (0 indicate...
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
LValue EmitLValueForLambdaField(const FieldDecl *Field)
Given that we are currently emitting a lambda, emit an l-value for one of its members.
Definition: CGExpr.cpp:3886
bool hasOneOf(SanitizerMask K) const
Check if one or more sanitizers are enabled.
Definition: Sanitizers.h:158
field_range fields() const
Definition: Decl.h:3841
Represents a member of a struct/union/class.
Definition: Decl.h:2607
SanitizerMask Mask
Bitmask of enabled sanitizers.
Definition: Sanitizers.h:173
__DEVICE__ int max(int __a, int __b)
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:49
void InitTempAlloca(Address Alloca, llvm::Value *Value)
InitTempAlloca - Provide an initial value for the given alloca which will be observable at all locati...
Definition: CGExpr.cpp:126
void disableSanitizerForInstruction(llvm::Instruction *I)
bool AlwaysEmitXRayTypedEvents() const
AlwaysEmitXRayTypedEvents - Return true if clang must unconditionally emit XRay typed event handling ...
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2289
Address CreateIRTemp(QualType T, const Twine &Name="tmp")
CreateIRTemp - Create a temporary IR object of the given type, with appropriate alignment.
Definition: CGExpr.cpp:134
virtual void EmitInstanceFunctionProlog(CodeGenFunction &CGF)=0
Emit the ABI-specific prolog for the function.
CGCUDARuntime & getCUDARuntime()
Return a reference to the configured CUDA runtime.
static bool hasScalarEvaluationKind(QualType T)
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:2808
Address CreateElementBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Cast the element type of the given address to a different type, preserving information like the align...
Definition: CGBuilder.h:156
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:37
APValue Val
Val - This is the value the expression can be folded to.
Definition: Expr.h:582
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Definition: Type.cpp:2236
bool AlwaysEmitXRayCustomEvents() const
AlwaysEmitXRayCustomEvents - Return true if we must unconditionally emit XRay custom event handling c...
bool isOne() const
isOne - Test whether the quantity equals one.
Definition: CharUnits.h:118
TBAAAccessInfo getTBAAAccessInfo(QualType AccessType)
getTBAAAccessInfo - Get TBAA information that describes an access to an object of the given type...
CharUnits getAlignment() const
Return the alignment of this pointer.
Definition: Address.h:66
child_range children()
Definition: Stmt.cpp:212
virtual bool hasMostDerivedReturn(GlobalDecl GD) const
Definition: CGCXXABI.h:108
unsigned getInAllocaFieldIndex() const
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3405
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:6212
The l-value was considered opaque, so the alignment was determined from a type, but that type was an ...
CXXCtorType getCtorType() const
Definition: GlobalDecl.h:78
llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:274
bool containsOnlyLifetimeMarkers(stable_iterator Old) const
Definition: CGCleanup.cpp:141
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1198
Values of this type can never be null.
Expr * getSizeExpr() const
Definition: Type.h:3023
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6142
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
void EmitIgnoredExpr(const Expr *E)
EmitIgnoredExpr - Emit an expression in a context which ignores the result.
Definition: CGExpr.cpp:182
void assignRegionCounters(GlobalDecl GD, llvm::Function *Fn)
Assign counters to regions and configure them for PGO of a given function.
Definition: CodeGenPGO.cpp:759
__v16qu mask
Definition: emmintrin.h:2133
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
bool isInstance() const
Definition: DeclCXX.h:2140
static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts=false)
ContainsLabel - Return true if the statement contains a label in it.
bool isAlignmentRequired(const Type *T) const
Determine if the alignment the type has was required using an alignment attribute.
llvm::SanitizerStatReport & getSanStats()
llvm::DebugLoc EmitReturnBlock()
Emit the unified return block, trying to avoid its emission when possible.
bool isLambdaCallOperator(const CXXMethodDecl *MD)
Definition: ASTLambda.h:27
void incrementProfileCounter(const Stmt *S, llvm::Value *StepV=nullptr)
Increment the profiler&#39;s counter for the given statement by StepV.
uint64_t getCurrentProfileCount()
Get the profiler&#39;s current count.
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
Definition: Decl.cpp:3077
Address NormalCleanupDest
i32s containing the indexes of the cleanup destinations.
virtual void emitDeviceStub(CodeGenFunction &CGF, FunctionArgList &Args)=0
Emits a kernel launch stub.
llvm::Value * EmitCheckValue(llvm::Value *V)
Convert a value into a format suitable for passing to a runtime sanitizer handler.
Definition: CGExpr.cpp:2828
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2926
Checking the &#39;this&#39; pointer for a call to a non-static member function.
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)
Create implicit parameter.
Definition: Decl.cpp:4561
void InsertHelper(llvm::Instruction *I) const
Function called by the CodeGenFunction when an instruction is created.
Definition: CGLoopInfo.cpp:728
bool hasAttr() const
Definition: DeclBase.h:542
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3703
CanQualType getReturnType() const
bool isValid() const
Definition: Address.h:35
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:57
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1310
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1636
const TargetCodeGenInfo & getTargetCodeGenInfo()
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any...
Definition: Decl.cpp:3384
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
Definition: CGValue.h:38
void EmitSanitizerStatReport(llvm::SanitizerStatKind SSK)
static void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB)
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:178
llvm::Value * DecodeAddrUsedInPrologue(llvm::Value *F, llvm::Value *EncodedAddr)
Decode an address used in a function prologue, encoded by EncodeAddrForUseInPrologue.
Address CreateDefaultAlignTempAlloca(llvm::Type *Ty, const Twine &Name="tmp")
CreateDefaultAlignedTempAlloca - This creates an alloca with the default ABI alignment of the given L...
Definition: CGExpr.cpp:119
virtual bool HasThisReturn(GlobalDecl GD) const
Returns true if the given constructor or destructor is one of the kinds that the ABI says returns &#39;th...
Definition: CGCXXABI.h:106
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
llvm::Constant * EmitAnnotationUnit(SourceLocation Loc)
Emit the annotation&#39;s translation unit.
llvm::BasicBlock * EHResumeBlock
EHResumeBlock - Unified block containing a call to llvm.eh.resume.
This represents one expression.
Definition: Expr.h:108
Emit only debug info necessary for generating line number tables (-gline-tables-only).
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:2048
static Address invalid()
Definition: Address.h:34
bool isObjCRetainableType() const
Definition: Type.cpp:3984
#define V(N, I)
Definition: ASTContext.h:2907
static void TryMarkNoThrow(llvm::Function *F)
Tries to mark the given function nounwind based on the non-existence of any throwing calls within it...
VlaSizePair getVLASize(const VariableArrayType *vla)
Returns an LLVM value that corresponds to the size, in non-variably-sized elements, of a variable length array type, plus that largest non-variably-sized element type.
const char * getRequiredFeatures(unsigned ID) const
Definition: Builtins.h:210
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:62
const AstTypeMatcher< ArrayType > arrayType
Matches all kinds of arrays.
llvm::LLVMContext & getLLVMContext()
llvm::BasicBlock * GetIndirectGotoBlock()
void GenOpenCLArgMetadata(llvm::Function *FN, const FunctionDecl *FD=nullptr, CodeGenFunction *CGF=nullptr)
OpenCL v1.2 s5.6.4.6 allows the compiler to store kernel argument information in the program executab...
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
Definition: Type.cpp:1875
QualType getType() const
Definition: Expr.h:137
void EmitConstructorBody(FunctionArgList &Args)
EmitConstructorBody - Emits the body of the current constructor.
Definition: CGClass.cpp:818
void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, llvm::Value *V, QualType Type, CharUnits Alignment=CharUnits::Zero(), SanitizerSet SkippedChecks=SanitizerSet(), llvm::Value *ArraySize=nullptr)
Emit a check that V is the address of storage of the appropriate size and alignment for an object of ...
Definition: CGExpr.cpp:653
CharUnits alignmentOfArrayElement(CharUnits elementSize) const
Given that this is the alignment of the first element of an array, return the minimum alignment of an...
Definition: CharUnits.h:196
llvm::Constant * EmitAnnotationString(StringRef Str)
Emit an annotation string.
LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T)
llvm::CallInst * CreateMemSet(Address Dest, llvm::Value *Value, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:296
SourceLocation getEnd() const
QualType getFunctionTypeWithExceptionSpec(QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI)
Get a function type and produce the equivalent function type with the specified exception specificati...
An object which temporarily prevents a value from being destroyed by aggressive peephole optimization...
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:2016
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1382
ValueDecl * getDecl()
Definition: Expr.h:1217
const LangOptions & getLangOpts() const
ASTContext & getContext() const
virtual void startNewFunction()
Definition: Mangle.h:75
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:264
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:40
The l-value was considered opaque, so the alignment was determined from a type.
void PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize, std::initializer_list< llvm::Value **> ValuesToReload={})
Takes the old cleanup stack size and emits the cleanup blocks that have been added.
Definition: CGCleanup.cpp:417
void set(SanitizerMask K, bool Value)
Enable or disable a certain (single) sanitizer.
Definition: Sanitizers.h:161
bool SawAsmBlock
Whether we processed a Microsoft-style asm block during CodeGen.
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:141
QualType getCanonicalType() const
Definition: Type.h:6181
Encodes a location in the source.
void EnsureInsertPoint()
EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go...
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
Definition: Type.h:956
llvm::Value * EvaluateExprAsBool(const Expr *E)
EvaluateExprAsBool - Perform the usual unary conversions on the specified expression and compare the ...
Definition: CGExpr.cpp:164
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:2124
bool inheritingCtorHasParams(const InheritedConstructor &Inherited, CXXCtorType Type)
Determine if a C++ inheriting constructor should have parameters matching those of its inherited cons...
Definition: CGCall.cpp:295
CharUnits getNaturalPointeeTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
QualType getElementType() const
Definition: Type.h:3235
const Decl * getDecl() const
Definition: GlobalDecl.h:76
Represents the declaration of a label.
Definition: Decl.h:468
ParsedAttr - Represents a syntactic attribute.
Definition: ParsedAttr.h:116
A scoped helper to set the current debug location to the specified location or preferred location of ...
Definition: CGDebugInfo.h:711
void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB, llvm::BasicBlock::iterator InsertPt) const
This forwards to CodeGenFunction::InsertHelper.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
TargetAttr::ParsedTargetAttr filterFunctionTargetAttrs(const TargetAttr *TD)
Parses the target attributes passed in, and returns only the ones that are valid feature names...
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2114
void EmitStmt(const Stmt *S, ArrayRef< const Attr *> Attrs=None)
EmitStmt - Emit the code for the statement.
Definition: CGStmt.cpp:44
SanitizerSet SanOpts
Sanitizers enabled for this function.
constexpr XRayInstrMask Custom
Definition: XRayInstr.h:39
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
An aligned address.
Definition: Address.h:24
void StartFunction(GlobalDecl GD, QualType RetTy, llvm::Function *Fn, const CGFunctionInfo &FnInfo, const FunctionArgList &Args, SourceLocation Loc=SourceLocation(), SourceLocation StartLoc=SourceLocation())
Emit code for the start of a function.
Address ReturnValuePointer
ReturnValuePointer - The temporary alloca to hold a pointer to sret.
XRayInstrSet XRayInstrumentationBundle
Set of XRay instrumentation kinds to emit.
TypeClass getTypeClass() const
Definition: Type.h:1839
MangleContext & getMangleContext()
Gets the mangle context.
Definition: CGCXXABI.h:96
JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target)
The given basic block lies in the current EH scope, but may be a target of a potentially scope-crossi...
llvm::Constant * EmitAnnotationLineNo(SourceLocation L)
Emit the annotation line number.
InAlloca - Pass the argument directly using the LLVM inalloca attribute.
CharUnits getNaturalTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, bool forPointeeType=false)
bool hasImplicitReturnZero() const
Whether falling off this function implicitly returns null/zero.
Definition: Decl.h:2066
Address EmitMSVAListRef(const Expr *E)
Emit a "reference" to a __builtin_ms_va_list; this is always the value of the expression, because a __builtin_ms_va_list is a pointer to a char.
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, GlobalDecl GD)
const CGFunctionInfo * CurFnInfo
void EmitStartEHSpec(const Decl *D)
EmitStartEHSpec - Emit the start of the exception spec.
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:215
This is an IRBuilder insertion helper that forwards to CodeGenFunction::InsertHelper, which adds necessary metadata to instructions.
Definition: CGBuilder.h:25
Address EmitVAListRef(const Expr *E)
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type, returning the result.
FunctionArgList - Type for representing both the decl and type of parameters to a function...
Definition: CGCall.h:358
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition: CGValue.h:58
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn&#39;t support the specified stmt yet.
CGFunctionInfo - Class to encapsulate the information about a function definition.
This class organizes the cross-function state that is used while generating LLVM code.
CGOpenMPRuntime & getOpenMPRuntime()
Return a reference to the configured OpenMP runtime.
void EmitDeclRefExprDbgValue(const DeclRefExpr *E, const APValue &Init)
static void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType, Address dest, Address src, llvm::Value *sizeInChars)
emitNonZeroVLAInit - Emit the "zero" initialization of a variable-length array whose elements have a ...
llvm::Value * EmitAnnotationCall(llvm::Function *AnnotationFn, llvm::Value *AnnotatedVal, StringRef AnnotationStr, SourceLocation Location)
Emit an annotation call (intrinsic).
Dataflow Directional Tag Classes.
Address EmitFieldAnnotations(const FieldDecl *D, Address V)
Emit field annotations for the given field & value.
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:580
static bool matchesStlAllocatorFn(const Decl *D, const ASTContext &Ctx)
void Init(const Stmt *Body)
Clear the object and pre-process for the given statement, usually function body statement.
llvm::LoadInst * CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition: CGBuilder.h:90
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:69
FunctionDecl * getTemplateInstantiationPattern() const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
Definition: Decl.cpp:3495
void EmitFunctionBody(const Stmt *Body)
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2237
Decl * getNonClosureContext()
Find the innermost non-closure ancestor of this declaration, walking up through blocks, lambdas, etc.
Definition: DeclBase.cpp:991
bool isMSVCRTEntryPoint() const
Determines whether this function is a MSVCRT user defined entry point.
Definition: Decl.cpp:2845
void buildThisParam(CodeGenFunction &CGF, FunctionArgList &Params)
Build a parameter variable suitable for &#39;this&#39;.
Definition: CGCXXABI.cpp:121
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type *> Tys=None)
llvm::SmallVector< char, 256 > LifetimeExtendedCleanupStack
bool has(XRayInstrMask K) const
Definition: XRayInstr.h:46
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:107
llvm::Module & getModule() const
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
bool hasProfileClangInstr() const
Check if Clang profile instrumenation is on.
JumpDest ReturnBlock
ReturnBlock - Unified return block.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4438
void EmitBlockWithFallThrough(llvm::BasicBlock *BB, const Stmt *S)
When instrumenting to collect profile data, the counts for some blocks such as switch cases need to n...
llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Location)
Converts Location to a DebugLoc, if debug information is enabled.
CodeGenTypes & getTypes() const
CharUnits getIndirectAlign() const
T * getAttr() const
Definition: DeclBase.h:538
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:51
llvm::AssertingVH< llvm::Instruction > AllocaInsertPt
AllocaInsertPoint - This is an instruction in the entry block before which we prefer to insert alloca...
ExtVectorType - Extended vector type.
Definition: Type.h:3319
QualType BuildFunctionArgList(GlobalDecl GD, FunctionArgList &Args)
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:454
void checkTargetFeatures(const CallExpr *E, const FunctionDecl *TargetDecl)
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
Definition: Type.cpp:3755
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:76
void getCaptureFields(llvm::DenseMap< const VarDecl *, FieldDecl *> &Captures, FieldDecl *&ThisCapture) const
For a closure type, retrieve the mapping from captured variables and this to the non-static data memb...
Definition: DeclCXX.cpp:1417
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:2062
llvm::ConstantInt * getSize(CharUnits numChars)
Emit the given number of characters as a value of type size_t.
const Decl * CurFuncDecl
CurFuncDecl - Holds the Decl for the current outermost non-closure context.
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
Definition: DeclBase.h:524
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer...
void unprotectFromPeepholes(PeepholeProtection protection)
void ErrorUnsupported(const Stmt *S, const char *Type)
ErrorUnsupported - Print out an error that codegen doesn&#39;t support the specified stmt yet...
bool hasUnaligned() const
Definition: Type.h:293
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
void EmitBranch(llvm::BasicBlock *Block)
EmitBranch - Emit a branch to the specified basic block from the current insert block, taking care to avoid creation of branches from dummy blocks.
Definition: CGStmt.cpp:474
bool isVoidType() const
Definition: Type.h:6643
llvm::Type * ConvertType(QualType T)
void EmitFunctionProlog(const CGFunctionInfo &FI, llvm::Function *Fn, const FunctionArgList &Args)
EmitFunctionProlog - Emit the target specific LLVM code to load the arguments for the given function...
Definition: CGCall.cpp:2219
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6169
static llvm::Constant * getPrologueSignature(CodeGenModule &CGM, const FunctionDecl *FD)
Return the UBSan prologue signature for FD if one is available.
LambdaCaptureDefault getLambdaCaptureDefault() const
Definition: DeclCXX.h:1230
LValue EmitLValue(const Expr *E)
EmitLValue - Emit code to compute a designator that specifies the location of the expression...
Definition: CGExpr.cpp:1244
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
Builtin::Context & BuiltinInfo
Definition: ASTContext.h:571
bool AutoreleaseResult
In ARC, whether we should autorelease the return value.
RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)
EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...
Definition: CGExpr.cpp:1773
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
Definition: Sanitizers.h:152
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2516
void EmitMultiVersionResolver(llvm::Function *Resolver, ArrayRef< MultiVersionResolverOption > Options)
CGCXXABI & getCXXABI() const
const VariableArrayType * getAsVariableArrayType(QualType T) const
Definition: ASTContext.h:2444
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1141
static bool shouldUseUndefinedBehaviorReturnOptimization(const FunctionDecl *FD, const ASTContext &Context)
void EmitDestructorBody(FunctionArgList &Args)
EmitDestructorBody - Emits the body of the current destructor.
Definition: CGClass.cpp:1417
bool isPointerType() const
Definition: Type.h:6384
This structure provides a set of types that are commonly used during IR emission. ...
void EmitEndEHSpec(const Decl *D)
EmitEndEHSpec - Emit the end of the exception spec.
struct clang::CodeGen::CodeGenFunction::MultiVersionResolverOption::Conds Conditions
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
llvm::Constant * EmitCheckSourceLocation(SourceLocation Loc)
Emit a description of a source location in a format suitable for passing to a runtime sanitizer handl...
Definition: CGExpr.cpp:2866
Address EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
Definition: CGStmt.cpp:380
void EmitAlignmentAssumption(llvm::Value *PtrValue, QualType Ty, SourceLocation Loc, SourceLocation AssumptionLoc, llvm::Value *Alignment, llvm::Value *OffsetValue=nullptr)
QualType getType() const
Definition: Decl.h:647
A trivial tuple used to represent a source range.
LValue - This represents an lvalue references.
Definition: CGValue.h:166
llvm::BlockAddress * GetAddrOfLabel(const LabelDecl *L)
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.cpp:1522
void EmitVarAnnotations(const VarDecl *D, llvm::Value *V)
Emit local annotations for the local variable V, declared by D.
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:3003
SanitizerMetadata * getSanitizerMetadata()
bool CurFuncIsThunk
In C++, whether we are code generating a thunk.
APSInt & getInt()
Definition: APValue.h:336
const LangOptions & getLangOpts() const
Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:163
llvm::Value * emitArrayLength(const ArrayType *arrayType, QualType &baseType, Address &addr)
emitArrayLength - Compute the length of an array, even if it&#39;s a VLA, and drill down to the base elem...
static LValue MakeAddr(Address address, QualType type, ASTContext &Context, LValueBaseInfo BaseInfo, TBAAAccessInfo TBAAInfo)
Definition: CGValue.h:366
static bool containsBreak(const Stmt *S)
containsBreak - Return true if the statement contains a break out of it.
SourceLocation getBegin() const
bool isZeroInitializable(QualType T)
IsZeroInitializable - Return whether a type can be zero-initialized (in the C++ sense) with an LLVM z...
Defines enum values for all the target-independent builtin functions.
void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)
bool isScalar() const
Definition: CGValue.h:51
Attr - This represents one attribute.
Definition: Attr.h:43
SourceLocation getLocation() const
Definition: DeclBase.h:429
void EmitNullInitialization(Address DestPtr, QualType Ty)
EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2938
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.