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