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