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