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