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