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