clang  3.8.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/Decl.h"
26 #include "clang/AST/DeclCXX.h"
27 #include "clang/AST/StmtCXX.h"
28 #include "clang/Basic/Builtins.h"
29 #include "clang/Basic/TargetInfo.h"
33 #include "llvm/IR/DataLayout.h"
34 #include "llvm/IR/Intrinsics.h"
35 #include "llvm/IR/MDBuilder.h"
36 #include "llvm/IR/Operator.h"
37 using namespace clang;
38 using namespace CodeGen;
39 
40 CodeGenFunction::CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext)
41  : CodeGenTypeCache(cgm), CGM(cgm), Target(cgm.getTarget()),
42  Builder(cgm, cgm.getModule().getContext(), llvm::ConstantFolder(),
43  CGBuilderInserterTy(this)),
44  CurFn(nullptr), ReturnValue(Address::invalid()),
45  CapturedStmtInfo(nullptr),
46  SanOpts(CGM.getLangOpts().Sanitize), IsSanitizerScope(false),
47  CurFuncIsThunk(false), AutoreleaseResult(false), SawAsmBlock(false),
48  IsOutlinedSEHHelper(false),
49  BlockInfo(nullptr), BlockPointer(nullptr),
50  LambdaThisCaptureField(nullptr), NormalCleanupDest(nullptr),
51  NextCleanupDestIndex(1), FirstBlockInfo(nullptr), EHResumeBlock(nullptr),
52  ExceptionSlot(nullptr), EHSelectorSlot(nullptr),
53  DebugInfo(CGM.getModuleDebugInfo()),
54  DisableDebugInfo(false), DidCallStackSave(false), IndirectBranch(nullptr),
55  PGO(cgm), SwitchInsn(nullptr), SwitchWeights(nullptr),
56  CaseRangeBlock(nullptr), UnreachableBlock(nullptr), NumReturnExprs(0),
57  NumSimpleReturnExprs(0), CXXABIThisDecl(nullptr),
58  CXXABIThisValue(nullptr), CXXThisValue(nullptr),
59  CXXStructorImplicitParamDecl(nullptr),
60  CXXStructorImplicitParamValue(nullptr), OutermostConditional(nullptr),
61  CurLexicalScope(nullptr), TerminateLandingPad(nullptr),
62  TerminateHandler(nullptr), TrapBB(nullptr) {
63  if (!suppressNewContext)
65 
66  llvm::FastMathFlags FMF;
67  if (CGM.getLangOpts().FastMath)
68  FMF.setUnsafeAlgebra();
69  if (CGM.getLangOpts().FiniteMathOnly) {
70  FMF.setNoNaNs();
71  FMF.setNoInfs();
72  }
73  if (CGM.getCodeGenOpts().NoNaNsFPMath) {
74  FMF.setNoNaNs();
75  }
76  if (CGM.getCodeGenOpts().NoSignedZeros) {
77  FMF.setNoSignedZeros();
78  }
79  if (CGM.getCodeGenOpts().ReciprocalMath) {
80  FMF.setAllowReciprocal();
81  }
82  Builder.setFastMathFlags(FMF);
83 }
84 
86  assert(LifetimeExtendedCleanupStack.empty() && "failed to emit a cleanup");
87 
88  // If there are any unclaimed block infos, go ahead and destroy them
89  // now. This can happen if IR-gen gets clever and skips evaluating
90  // something.
91  if (FirstBlockInfo)
93 
94  if (getLangOpts().OpenMP) {
95  CGM.getOpenMPRuntime().functionFinished(*this);
96  }
97 }
98 
100  AlignmentSource *Source) {
101  return getNaturalTypeAlignment(T->getPointeeType(), Source,
102  /*forPointee*/ true);
103 }
104 
106  AlignmentSource *Source,
107  bool forPointeeType) {
108  // Honor alignment typedef attributes even on incomplete types.
109  // We also honor them straight for C++ class types, even as pointees;
110  // there's an expressivity gap here.
111  if (auto TT = T->getAs<TypedefType>()) {
112  if (auto Align = TT->getDecl()->getMaxAlignment()) {
113  if (Source) *Source = AlignmentSource::AttributedType;
114  return getContext().toCharUnitsFromBits(Align);
115  }
116  }
117 
118  if (Source) *Source = AlignmentSource::Type;
119 
120  CharUnits Alignment;
121  if (T->isIncompleteType()) {
122  Alignment = CharUnits::One(); // Shouldn't be used, but pessimistic is best.
123  } else {
124  // For C++ class pointees, we don't know whether we're pointing at a
125  // base or a complete object, so we generally need to use the
126  // non-virtual alignment.
127  const CXXRecordDecl *RD;
128  if (forPointeeType && (RD = T->getAsCXXRecordDecl())) {
129  Alignment = CGM.getClassPointerAlignment(RD);
130  } else {
131  Alignment = getContext().getTypeAlignInChars(T);
132  }
133 
134  // Cap to the global maximum type alignment unless the alignment
135  // was somehow explicit on the type.
136  if (unsigned MaxAlign = getLangOpts().MaxTypeAlign) {
137  if (Alignment.getQuantity() > MaxAlign &&
139  Alignment = CharUnits::fromQuantity(MaxAlign);
140  }
141  }
142  return Alignment;
143 }
144 
146  AlignmentSource AlignSource;
147  CharUnits Alignment = getNaturalTypeAlignment(T, &AlignSource);
148  return LValue::MakeAddr(Address(V, Alignment), T, getContext(), AlignSource,
149  CGM.getTBAAInfo(T));
150 }
151 
152 /// Given a value of type T* that may not be to a complete object,
153 /// construct an l-value with the natural pointee alignment of T.
154 LValue
156  AlignmentSource AlignSource;
157  CharUnits Align = getNaturalTypeAlignment(T, &AlignSource, /*pointee*/ true);
158  return MakeAddrLValue(Address(V, Align), T, AlignSource);
159 }
160 
161 
163  return CGM.getTypes().ConvertTypeForMem(T);
164 }
165 
167  return CGM.getTypes().ConvertType(T);
168 }
169 
171  type = type.getCanonicalType();
172  while (true) {
173  switch (type->getTypeClass()) {
174 #define TYPE(name, parent)
175 #define ABSTRACT_TYPE(name, parent)
176 #define NON_CANONICAL_TYPE(name, parent) case Type::name:
177 #define DEPENDENT_TYPE(name, parent) case Type::name:
178 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(name, parent) case Type::name:
179 #include "clang/AST/TypeNodes.def"
180  llvm_unreachable("non-canonical or dependent type in IR-generation");
181 
182  case Type::Auto:
183  llvm_unreachable("undeduced auto type in IR-generation");
184 
185  // Various scalar types.
186  case Type::Builtin:
187  case Type::Pointer:
188  case Type::BlockPointer:
189  case Type::LValueReference:
190  case Type::RValueReference:
191  case Type::MemberPointer:
192  case Type::Vector:
193  case Type::ExtVector:
194  case Type::FunctionProto:
195  case Type::FunctionNoProto:
196  case Type::Enum:
197  case Type::ObjCObjectPointer:
198  case Type::Pipe:
199  return TEK_Scalar;
200 
201  // Complexes.
202  case Type::Complex:
203  return TEK_Complex;
204 
205  // Arrays, records, and Objective-C objects.
206  case Type::ConstantArray:
207  case Type::IncompleteArray:
208  case Type::VariableArray:
209  case Type::Record:
210  case Type::ObjCObject:
211  case Type::ObjCInterface:
212  return TEK_Aggregate;
213 
214  // We operate on atomic values according to their underlying type.
215  case Type::Atomic:
216  type = cast<AtomicType>(type)->getValueType();
217  continue;
218  }
219  llvm_unreachable("unknown type kind!");
220  }
221 }
222 
224  // For cleanliness, we try to avoid emitting the return block for
225  // simple cases.
226  llvm::BasicBlock *CurBB = Builder.GetInsertBlock();
227 
228  if (CurBB) {
229  assert(!CurBB->getTerminator() && "Unexpected terminated block.");
230 
231  // We have a valid insert point, reuse it if it is empty or there are no
232  // explicit jumps to the return block.
233  if (CurBB->empty() || ReturnBlock.getBlock()->use_empty()) {
234  ReturnBlock.getBlock()->replaceAllUsesWith(CurBB);
235  delete ReturnBlock.getBlock();
236  } else
238  return llvm::DebugLoc();
239  }
240 
241  // Otherwise, if the return block is the target of a single direct
242  // branch then we can just put the code in that block instead. This
243  // cleans up functions which started with a unified return block.
244  if (ReturnBlock.getBlock()->hasOneUse()) {
245  llvm::BranchInst *BI =
246  dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->user_begin());
247  if (BI && BI->isUnconditional() &&
248  BI->getSuccessor(0) == ReturnBlock.getBlock()) {
249  // Record/return the DebugLoc of the simple 'return' expression to be used
250  // later by the actual 'ret' instruction.
251  llvm::DebugLoc Loc = BI->getDebugLoc();
252  Builder.SetInsertPoint(BI->getParent());
253  BI->eraseFromParent();
254  delete ReturnBlock.getBlock();
255  return Loc;
256  }
257  }
258 
259  // FIXME: We are at an unreachable point, there is no reason to emit the block
260  // unless it has uses. However, we still need a place to put the debug
261  // region.end for now.
262 
264  return llvm::DebugLoc();
265 }
266 
267 static void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) {
268  if (!BB) return;
269  if (!BB->use_empty())
270  return CGF.CurFn->getBasicBlockList().push_back(BB);
271  delete BB;
272 }
273 
275  assert(BreakContinueStack.empty() &&
276  "mismatched push/pop in break/continue stack!");
277 
278  bool OnlySimpleReturnStmts = NumSimpleReturnExprs > 0
279  && NumSimpleReturnExprs == NumReturnExprs
280  && ReturnBlock.getBlock()->use_empty();
281  // Usually the return expression is evaluated before the cleanup
282  // code. If the function contains only a simple return statement,
283  // such as a constant, the location before the cleanup code becomes
284  // the last useful breakpoint in the function, because the simple
285  // return expression will be evaluated after the cleanup code. To be
286  // safe, set the debug location for cleanup code to the location of
287  // the return statement. Otherwise the cleanup code should be at the
288  // end of the function's lexical scope.
289  //
290  // If there are multiple branches to the return block, the branch
291  // instructions will get the location of the return statements and
292  // all will be fine.
293  if (CGDebugInfo *DI = getDebugInfo()) {
294  if (OnlySimpleReturnStmts)
295  DI->EmitLocation(Builder, LastStopPoint);
296  else
297  DI->EmitLocation(Builder, EndLoc);
298  }
299 
300  // Pop any cleanups that might have been associated with the
301  // parameters. Do this in whatever block we're currently in; it's
302  // important to do this before we enter the return block or return
303  // edges will be *really* confused.
304  bool HasCleanups = EHStack.stable_begin() != PrologueCleanupDepth;
305  bool HasOnlyLifetimeMarkers =
307  bool EmitRetDbgLoc = !HasCleanups || HasOnlyLifetimeMarkers;
308  if (HasCleanups) {
309  // Make sure the line table doesn't jump back into the body for
310  // the ret after it's been at EndLoc.
311  if (CGDebugInfo *DI = getDebugInfo())
312  if (OnlySimpleReturnStmts)
313  DI->EmitLocation(Builder, EndLoc);
314 
316  }
317 
318  // Emit function epilog (to return).
319  llvm::DebugLoc Loc = EmitReturnBlock();
320 
322  EmitFunctionInstrumentation("__cyg_profile_func_exit");
323 
324  // Emit debug descriptor for function end.
325  if (CGDebugInfo *DI = getDebugInfo())
326  DI->EmitFunctionEnd(Builder);
327 
328  // Reset the debug location to that of the simple 'return' expression, if any
329  // rather than that of the end of the function's scope '}'.
330  ApplyDebugLocation AL(*this, Loc);
331  EmitFunctionEpilog(*CurFnInfo, EmitRetDbgLoc, EndLoc);
333 
334  assert(EHStack.empty() &&
335  "did not remove all scopes from cleanup stack!");
336 
337  // If someone did an indirect goto, emit the indirect goto block at the end of
338  // the function.
339  if (IndirectBranch) {
340  EmitBlock(IndirectBranch->getParent());
341  Builder.ClearInsertionPoint();
342  }
343 
344  // If some of our locals escaped, insert a call to llvm.localescape in the
345  // entry block.
346  if (!EscapedLocals.empty()) {
347  // Invert the map from local to index into a simple vector. There should be
348  // no holes.
350  EscapeArgs.resize(EscapedLocals.size());
351  for (auto &Pair : EscapedLocals)
352  EscapeArgs[Pair.second] = Pair.first;
353  llvm::Function *FrameEscapeFn = llvm::Intrinsic::getDeclaration(
354  &CGM.getModule(), llvm::Intrinsic::localescape);
355  CGBuilderTy(*this, AllocaInsertPt).CreateCall(FrameEscapeFn, EscapeArgs);
356  }
357 
358  // Remove the AllocaInsertPt instruction, which is just a convenience for us.
359  llvm::Instruction *Ptr = AllocaInsertPt;
360  AllocaInsertPt = nullptr;
361  Ptr->eraseFromParent();
362 
363  // If someone took the address of a label but never did an indirect goto, we
364  // made a zero entry PHI node, which is illegal, zap it now.
365  if (IndirectBranch) {
366  llvm::PHINode *PN = cast<llvm::PHINode>(IndirectBranch->getAddress());
367  if (PN->getNumIncomingValues() == 0) {
368  PN->replaceAllUsesWith(llvm::UndefValue::get(PN->getType()));
369  PN->eraseFromParent();
370  }
371  }
372 
373  EmitIfUsed(*this, EHResumeBlock);
374  EmitIfUsed(*this, TerminateLandingPad);
375  EmitIfUsed(*this, TerminateHandler);
376  EmitIfUsed(*this, UnreachableBlock);
377 
378  if (CGM.getCodeGenOpts().EmitDeclMetadata)
379  EmitDeclMetadata();
380 
381  for (SmallVectorImpl<std::pair<llvm::Instruction *, llvm::Value *> >::iterator
382  I = DeferredReplacements.begin(),
383  E = DeferredReplacements.end();
384  I != E; ++I) {
385  I->first->replaceAllUsesWith(I->second);
386  I->first->eraseFromParent();
387  }
388 }
389 
390 /// ShouldInstrumentFunction - Return true if the current function should be
391 /// instrumented with __cyg_profile_func_* calls
393  if (!CGM.getCodeGenOpts().InstrumentFunctions)
394  return false;
395  if (!CurFuncDecl || CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>())
396  return false;
397  return true;
398 }
399 
400 /// EmitFunctionInstrumentation - Emit LLVM code to call the specified
401 /// instrumentation function with the current function and the call site, if
402 /// function instrumentation is enabled.
404  // void __cyg_profile_func_{enter,exit} (void *this_fn, void *call_site);
405  llvm::PointerType *PointerTy = Int8PtrTy;
406  llvm::Type *ProfileFuncArgs[] = { PointerTy, PointerTy };
407  llvm::FunctionType *FunctionTy =
408  llvm::FunctionType::get(VoidTy, ProfileFuncArgs, false);
409 
410  llvm::Constant *F = CGM.CreateRuntimeFunction(FunctionTy, Fn);
411  llvm::CallInst *CallSite = Builder.CreateCall(
412  CGM.getIntrinsic(llvm::Intrinsic::returnaddress),
413  llvm::ConstantInt::get(Int32Ty, 0),
414  "callsite");
415 
416  llvm::Value *args[] = {
417  llvm::ConstantExpr::getBitCast(CurFn, PointerTy),
418  CallSite
419  };
420 
421  EmitNounwindRuntimeCall(F, args);
422 }
423 
425  llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
426 
427  llvm::Constant *MCountFn =
428  CGM.CreateRuntimeFunction(FTy, getTarget().getMCountName());
429  EmitNounwindRuntimeCall(MCountFn);
430 }
431 
432 // OpenCL v1.2 s5.6.4.6 allows the compiler to store kernel argument
433 // information in the program executable. The argument information stored
434 // includes the argument name, its type, the address and access qualifiers used.
435 static void GenOpenCLArgMetadata(const FunctionDecl *FD, llvm::Function *Fn,
436  CodeGenModule &CGM, llvm::LLVMContext &Context,
437  SmallVector<llvm::Metadata *, 5> &kernelMDArgs,
438  CGBuilderTy &Builder, ASTContext &ASTCtx) {
439  // Create MDNodes that represent the kernel arg metadata.
440  // Each MDNode is a list in the form of "key", N number of values which is
441  // the same number of values as their are kernel arguments.
442 
443  const PrintingPolicy &Policy = ASTCtx.getPrintingPolicy();
444 
445  // MDNode for the kernel argument address space qualifiers.
447  addressQuals.push_back(llvm::MDString::get(Context, "kernel_arg_addr_space"));
448 
449  // MDNode for the kernel argument access qualifiers (images only).
451  accessQuals.push_back(llvm::MDString::get(Context, "kernel_arg_access_qual"));
452 
453  // MDNode for the kernel argument type names.
455  argTypeNames.push_back(llvm::MDString::get(Context, "kernel_arg_type"));
456 
457  // MDNode for the kernel argument base type names.
458  SmallVector<llvm::Metadata *, 8> argBaseTypeNames;
459  argBaseTypeNames.push_back(
460  llvm::MDString::get(Context, "kernel_arg_base_type"));
461 
462  // MDNode for the kernel argument type qualifiers.
464  argTypeQuals.push_back(llvm::MDString::get(Context, "kernel_arg_type_qual"));
465 
466  // MDNode for the kernel argument names.
468  argNames.push_back(llvm::MDString::get(Context, "kernel_arg_name"));
469 
470  for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) {
471  const ParmVarDecl *parm = FD->getParamDecl(i);
472  QualType ty = parm->getType();
473  std::string typeQuals;
474 
475  if (ty->isPointerType()) {
476  QualType pointeeTy = ty->getPointeeType();
477 
478  // Get address qualifier.
479  addressQuals.push_back(llvm::ConstantAsMetadata::get(Builder.getInt32(
480  ASTCtx.getTargetAddressSpace(pointeeTy.getAddressSpace()))));
481 
482  // Get argument type name.
483  std::string typeName =
484  pointeeTy.getUnqualifiedType().getAsString(Policy) + "*";
485 
486  // Turn "unsigned type" to "utype"
487  std::string::size_type pos = typeName.find("unsigned");
488  if (pointeeTy.isCanonical() && pos != std::string::npos)
489  typeName.erase(pos+1, 8);
490 
491  argTypeNames.push_back(llvm::MDString::get(Context, typeName));
492 
493  std::string baseTypeName =
495  Policy) +
496  "*";
497 
498  // Turn "unsigned type" to "utype"
499  pos = baseTypeName.find("unsigned");
500  if (pos != std::string::npos)
501  baseTypeName.erase(pos+1, 8);
502 
503  argBaseTypeNames.push_back(llvm::MDString::get(Context, baseTypeName));
504 
505  // Get argument type qualifiers:
506  if (ty.isRestrictQualified())
507  typeQuals = "restrict";
508  if (pointeeTy.isConstQualified() ||
509  (pointeeTy.getAddressSpace() == LangAS::opencl_constant))
510  typeQuals += typeQuals.empty() ? "const" : " const";
511  if (pointeeTy.isVolatileQualified())
512  typeQuals += typeQuals.empty() ? "volatile" : " volatile";
513  } else {
514  uint32_t AddrSpc = 0;
515  bool isPipe = ty->isPipeType();
516  if (ty->isImageType() || isPipe)
517  AddrSpc =
519 
520  addressQuals.push_back(
521  llvm::ConstantAsMetadata::get(Builder.getInt32(AddrSpc)));
522 
523  // Get argument type name.
524  std::string typeName;
525  if (isPipe)
526  typeName = cast<PipeType>(ty)->getElementType().getAsString(Policy);
527  else
528  typeName = ty.getUnqualifiedType().getAsString(Policy);
529 
530  // Turn "unsigned type" to "utype"
531  std::string::size_type pos = typeName.find("unsigned");
532  if (ty.isCanonical() && pos != std::string::npos)
533  typeName.erase(pos+1, 8);
534 
535  argTypeNames.push_back(llvm::MDString::get(Context, typeName));
536 
537  std::string baseTypeName;
538  if (isPipe)
539  baseTypeName =
540  cast<PipeType>(ty)->getElementType().getCanonicalType().getAsString(Policy);
541  else
542  baseTypeName =
544 
545  // Turn "unsigned type" to "utype"
546  pos = baseTypeName.find("unsigned");
547  if (pos != std::string::npos)
548  baseTypeName.erase(pos+1, 8);
549 
550  argBaseTypeNames.push_back(llvm::MDString::get(Context, baseTypeName));
551 
552  // Get argument type qualifiers:
553  if (ty.isConstQualified())
554  typeQuals = "const";
555  if (ty.isVolatileQualified())
556  typeQuals += typeQuals.empty() ? "volatile" : " volatile";
557  if (isPipe)
558  typeQuals = "pipe";
559  }
560 
561  argTypeQuals.push_back(llvm::MDString::get(Context, typeQuals));
562 
563  // Get image and pipe access qualifier:
564  // FIXME: now image and pipe share the same access qualifier maybe we can
565  // refine it to OpenCL access qualifier and also handle write_read
566  if (ty->isImageType()|| ty->isPipeType()) {
567  const OpenCLImageAccessAttr *A = parm->getAttr<OpenCLImageAccessAttr>();
568  if (A && A->isWriteOnly())
569  accessQuals.push_back(llvm::MDString::get(Context, "write_only"));
570  else
571  accessQuals.push_back(llvm::MDString::get(Context, "read_only"));
572  // FIXME: what about read_write?
573  } else
574  accessQuals.push_back(llvm::MDString::get(Context, "none"));
575 
576  // Get argument name.
577  argNames.push_back(llvm::MDString::get(Context, parm->getName()));
578  }
579 
580  kernelMDArgs.push_back(llvm::MDNode::get(Context, addressQuals));
581  kernelMDArgs.push_back(llvm::MDNode::get(Context, accessQuals));
582  kernelMDArgs.push_back(llvm::MDNode::get(Context, argTypeNames));
583  kernelMDArgs.push_back(llvm::MDNode::get(Context, argBaseTypeNames));
584  kernelMDArgs.push_back(llvm::MDNode::get(Context, argTypeQuals));
585  if (CGM.getCodeGenOpts().EmitOpenCLArgMetadata)
586  kernelMDArgs.push_back(llvm::MDNode::get(Context, argNames));
587 }
588 
589 void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,
590  llvm::Function *Fn)
591 {
592  if (!FD->hasAttr<OpenCLKernelAttr>())
593  return;
594 
595  llvm::LLVMContext &Context = getLLVMContext();
596 
598  kernelMDArgs.push_back(llvm::ConstantAsMetadata::get(Fn));
599 
600  GenOpenCLArgMetadata(FD, Fn, CGM, Context, kernelMDArgs, Builder,
601  getContext());
602 
603  if (const VecTypeHintAttr *A = FD->getAttr<VecTypeHintAttr>()) {
604  QualType hintQTy = A->getTypeHint();
605  const ExtVectorType *hintEltQTy = hintQTy->getAs<ExtVectorType>();
606  bool isSignedInteger =
607  hintQTy->isSignedIntegerType() ||
608  (hintEltQTy && hintEltQTy->getElementType()->isSignedIntegerType());
609  llvm::Metadata *attrMDArgs[] = {
610  llvm::MDString::get(Context, "vec_type_hint"),
611  llvm::ConstantAsMetadata::get(llvm::UndefValue::get(
612  CGM.getTypes().ConvertType(A->getTypeHint()))),
613  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
614  llvm::IntegerType::get(Context, 32),
615  llvm::APInt(32, (uint64_t)(isSignedInteger ? 1 : 0))))};
616  kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs));
617  }
618 
619  if (const WorkGroupSizeHintAttr *A = FD->getAttr<WorkGroupSizeHintAttr>()) {
620  llvm::Metadata *attrMDArgs[] = {
621  llvm::MDString::get(Context, "work_group_size_hint"),
622  llvm::ConstantAsMetadata::get(Builder.getInt32(A->getXDim())),
623  llvm::ConstantAsMetadata::get(Builder.getInt32(A->getYDim())),
624  llvm::ConstantAsMetadata::get(Builder.getInt32(A->getZDim()))};
625  kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs));
626  }
627 
628  if (const ReqdWorkGroupSizeAttr *A = FD->getAttr<ReqdWorkGroupSizeAttr>()) {
629  llvm::Metadata *attrMDArgs[] = {
630  llvm::MDString::get(Context, "reqd_work_group_size"),
631  llvm::ConstantAsMetadata::get(Builder.getInt32(A->getXDim())),
632  llvm::ConstantAsMetadata::get(Builder.getInt32(A->getYDim())),
633  llvm::ConstantAsMetadata::get(Builder.getInt32(A->getZDim()))};
634  kernelMDArgs.push_back(llvm::MDNode::get(Context, attrMDArgs));
635  }
636 
637  llvm::MDNode *kernelMDNode = llvm::MDNode::get(Context, kernelMDArgs);
638  llvm::NamedMDNode *OpenCLKernelMetadata =
639  CGM.getModule().getOrInsertNamedMetadata("opencl.kernels");
640  OpenCLKernelMetadata->addOperand(kernelMDNode);
641 }
642 
643 /// Determine whether the function F ends with a return stmt.
644 static bool endsWithReturn(const Decl* F) {
645  const Stmt *Body = nullptr;
646  if (auto *FD = dyn_cast_or_null<FunctionDecl>(F))
647  Body = FD->getBody();
648  else if (auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(F))
649  Body = OMD->getBody();
650 
651  if (auto *CS = dyn_cast_or_null<CompoundStmt>(Body)) {
652  auto LastStmt = CS->body_rbegin();
653  if (LastStmt != CS->body_rend())
654  return isa<ReturnStmt>(*LastStmt);
655  }
656  return false;
657 }
658 
660  QualType RetTy,
661  llvm::Function *Fn,
662  const CGFunctionInfo &FnInfo,
663  const FunctionArgList &Args,
664  SourceLocation Loc,
665  SourceLocation StartLoc) {
666  assert(!CurFn &&
667  "Do not use a CodeGenFunction object for more than one function");
668 
669  const Decl *D = GD.getDecl();
670 
671  DidCallStackSave = false;
672  CurCodeDecl = D;
673  CurFuncDecl = (D ? D->getNonClosureContext() : nullptr);
674  FnRetTy = RetTy;
675  CurFn = Fn;
676  CurFnInfo = &FnInfo;
677  assert(CurFn->isDeclaration() && "Function already has body?");
678 
679  if (CGM.isInSanitizerBlacklist(Fn, Loc))
680  SanOpts.clear();
681 
682  if (D) {
683  // Apply the no_sanitize* attributes to SanOpts.
684  for (auto Attr : D->specific_attrs<NoSanitizeAttr>())
685  SanOpts.Mask &= ~Attr->getMask();
686  }
687 
688  // Apply sanitizer attributes to the function.
689  if (SanOpts.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress))
690  Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
691  if (SanOpts.has(SanitizerKind::Thread))
692  Fn->addFnAttr(llvm::Attribute::SanitizeThread);
693  if (SanOpts.has(SanitizerKind::Memory))
694  Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
695  if (SanOpts.has(SanitizerKind::SafeStack))
696  Fn->addFnAttr(llvm::Attribute::SafeStack);
697 
698  // Pass inline keyword to optimizer if it appears explicitly on any
699  // declaration. Also, in the case of -fno-inline attach NoInline
700  // attribute to all function that are not marked AlwaysInline.
701  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
702  if (!CGM.getCodeGenOpts().NoInline) {
703  for (auto RI : FD->redecls())
704  if (RI->isInlineSpecified()) {
705  Fn->addFnAttr(llvm::Attribute::InlineHint);
706  break;
707  }
708  } else if (!FD->hasAttr<AlwaysInlineAttr>())
709  Fn->addFnAttr(llvm::Attribute::NoInline);
710  }
711 
712  if (getLangOpts().OpenCL) {
713  // Add metadata for a kernel function.
714  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
715  EmitOpenCLKernelMetadata(FD, Fn);
716  }
717 
718  // If we are checking function types, emit a function type signature as
719  // prologue data.
720  if (getLangOpts().CPlusPlus && SanOpts.has(SanitizerKind::Function)) {
721  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
722  if (llvm::Constant *PrologueSig =
724  llvm::Constant *FTRTTIConst =
725  CGM.GetAddrOfRTTIDescriptor(FD->getType(), /*ForEH=*/true);
726  llvm::Constant *PrologueStructElems[] = { PrologueSig, FTRTTIConst };
727  llvm::Constant *PrologueStructConst =
728  llvm::ConstantStruct::getAnon(PrologueStructElems, /*Packed=*/true);
729  Fn->setPrologueData(PrologueStructConst);
730  }
731  }
732  }
733 
734  // If we're in C++ mode and the function name is "main", it is guaranteed
735  // to be norecurse by the standard (3.6.1.3 "The function main shall not be
736  // used within a program").
737  if (getLangOpts().CPlusPlus)
738  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
739  if (FD->isMain())
740  Fn->addFnAttr(llvm::Attribute::NoRecurse);
741 
742  llvm::BasicBlock *EntryBB = createBasicBlock("entry", CurFn);
743 
744  // Create a marker to make it easy to insert allocas into the entryblock
745  // later. Don't create this with the builder, because we don't want it
746  // folded.
747  llvm::Value *Undef = llvm::UndefValue::get(Int32Ty);
748  AllocaInsertPt = new llvm::BitCastInst(Undef, Int32Ty, "", EntryBB);
749  if (Builder.isNamePreserving())
750  AllocaInsertPt->setName("allocapt");
751 
753 
754  Builder.SetInsertPoint(EntryBB);
755 
756  // Emit subprogram debug descriptor.
757  if (CGDebugInfo *DI = getDebugInfo()) {
758  SmallVector<QualType, 16> ArgTypes;
759  for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
760  i != e; ++i) {
761  ArgTypes.push_back((*i)->getType());
762  }
763 
764  QualType FnType =
765  getContext().getFunctionType(RetTy, ArgTypes,
767  DI->EmitFunctionStart(GD, Loc, StartLoc, FnType, CurFn, Builder);
768  }
769 
771  EmitFunctionInstrumentation("__cyg_profile_func_enter");
772 
773  if (CGM.getCodeGenOpts().InstrumentForProfiling)
775 
776  if (RetTy->isVoidType()) {
777  // Void type; nothing to return.
779 
780  // Count the implicit return.
781  if (!endsWithReturn(D))
782  ++NumReturnExprs;
785  // Indirect aggregate return; emit returned value directly into sret slot.
786  // This reduces code size, and affects correctness in C++.
787  auto AI = CurFn->arg_begin();
789  ++AI;
793  // Load the sret pointer from the argument struct and return into that.
794  unsigned Idx = CurFnInfo->getReturnInfo().getInAllocaFieldIndex();
795  llvm::Function::arg_iterator EI = CurFn->arg_end();
796  --EI;
797  llvm::Value *Addr = Builder.CreateStructGEP(nullptr, &*EI, Idx);
798  Addr = Builder.CreateAlignedLoad(Addr, getPointerAlign(), "agg.result");
800  } else {
801  ReturnValue = CreateIRTemp(RetTy, "retval");
802 
803  // Tell the epilog emitter to autorelease the result. We do this
804  // now so that various specialized functions can suppress it
805  // during their IR-generation.
806  if (getLangOpts().ObjCAutoRefCount &&
808  RetTy->isObjCRetainableType())
809  AutoreleaseResult = true;
810  }
811 
813 
816 
817  if (D && isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) {
819  const CXXMethodDecl *MD = cast<CXXMethodDecl>(D);
820  if (MD->getParent()->isLambda() &&
821  MD->getOverloadedOperator() == OO_Call) {
822  // We're in a lambda; figure out the captures.
826  // If this lambda captures this, load it.
828  CXXThisValue = EmitLoadOfLValue(ThisLValue,
830  }
831  for (auto *FD : MD->getParent()->fields()) {
832  if (FD->hasCapturedVLAType()) {
833  auto *ExprArg = EmitLoadOfLValue(EmitLValueForLambdaField(FD),
835  auto VAT = FD->getCapturedVLAType();
836  VLASizeMap[VAT->getSizeExpr()] = ExprArg;
837  }
838  }
839  } else {
840  // Not in a lambda; just use 'this' from the method.
841  // FIXME: Should we generate a new load for each use of 'this'? The
842  // fast register allocator would be happier...
843  CXXThisValue = CXXABIThisValue;
844  }
845  }
846 
847  // If any of the arguments have a variably modified type, make sure to
848  // emit the type size.
849  for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
850  i != e; ++i) {
851  const VarDecl *VD = *i;
852 
853  // Dig out the type as written from ParmVarDecls; it's unclear whether
854  // the standard (C99 6.9.1p10) requires this, but we're following the
855  // precedent set by gcc.
856  QualType Ty;
857  if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD))
858  Ty = PVD->getOriginalType();
859  else
860  Ty = VD->getType();
861 
862  if (Ty->isVariablyModifiedType())
864  }
865  // Emit a location at the end of the prologue.
866  if (CGDebugInfo *DI = getDebugInfo())
867  DI->EmitLocation(Builder, StartLoc);
868 }
869 
871  const Stmt *Body) {
873  if (const CompoundStmt *S = dyn_cast<CompoundStmt>(Body))
875  else
876  EmitStmt(Body);
877 }
878 
879 /// When instrumenting to collect profile data, the counts for some blocks
880 /// such as switch cases need to not include the fall-through counts, so
881 /// emit a branch around the instrumentation code. When not instrumenting,
882 /// this just calls EmitBlock().
884  const Stmt *S) {
885  llvm::BasicBlock *SkipCountBB = nullptr;
886  if (HaveInsertPoint() && CGM.getCodeGenOpts().ProfileInstrGenerate) {
887  // When instrumenting for profiling, the fallthrough to certain
888  // statements needs to skip over the instrumentation code so that we
889  // get an accurate count.
890  SkipCountBB = createBasicBlock("skipcount");
891  EmitBranch(SkipCountBB);
892  }
893  EmitBlock(BB);
894  uint64_t CurrentCount = getCurrentProfileCount();
897  if (SkipCountBB)
898  EmitBlock(SkipCountBB);
899 }
900 
901 /// Tries to mark the given function nounwind based on the
902 /// non-existence of any throwing calls within it. We believe this is
903 /// lightweight enough to do at -O0.
904 static void TryMarkNoThrow(llvm::Function *F) {
905  // LLVM treats 'nounwind' on a function as part of the type, so we
906  // can't do this on functions that can be overwritten.
907  if (F->mayBeOverridden()) return;
908 
909  for (llvm::BasicBlock &BB : *F)
910  for (llvm::Instruction &I : BB)
911  if (I.mayThrow())
912  return;
913 
914  F->setDoesNotThrow();
915 }
916 
917 void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn,
918  const CGFunctionInfo &FnInfo) {
919  const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
920 
921  // Check if we should generate debug info for this function.
922  if (FD->hasAttr<NoDebugAttr>())
923  DebugInfo = nullptr; // disable debug info indefinitely for this function
924 
925  FunctionArgList Args;
926  QualType ResTy = FD->getReturnType();
927 
928  CurGD = GD;
929  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
930  if (MD && MD->isInstance()) {
931  if (CGM.getCXXABI().HasThisReturn(GD))
932  ResTy = MD->getThisType(getContext());
933  else if (CGM.getCXXABI().hasMostDerivedReturn(GD))
934  ResTy = CGM.getContext().VoidPtrTy;
935  CGM.getCXXABI().buildThisParam(*this, Args);
936  }
937 
938  for (auto *Param : FD->params()) {
939  Args.push_back(Param);
940  if (!Param->hasAttr<PassObjectSizeAttr>())
941  continue;
942 
943  IdentifierInfo *NoID = nullptr;
944  auto *Implicit = ImplicitParamDecl::Create(
945  getContext(), Param->getDeclContext(), Param->getLocation(), NoID,
946  getContext().getSizeType());
947  SizeArguments[Param] = Implicit;
948  Args.push_back(Implicit);
949  }
950 
951  if (MD && (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)))
952  CGM.getCXXABI().addImplicitStructorParams(*this, ResTy, Args);
953 
954  SourceRange BodyRange;
955  if (Stmt *Body = FD->getBody()) BodyRange = Body->getSourceRange();
956  CurEHLocation = BodyRange.getEnd();
957 
958  // Use the location of the start of the function to determine where
959  // the function definition is located. By default use the location
960  // of the declaration as the location for the subprogram. A function
961  // may lack a declaration in the source code if it is created by code
962  // gen. (examples: _GLOBAL__I_a, __cxx_global_array_dtor, thunk).
963  SourceLocation Loc = FD->getLocation();
964 
965  // If this is a function specialization then use the pattern body
966  // as the location for the function.
967  if (const FunctionDecl *SpecDecl = FD->getTemplateInstantiationPattern())
968  if (SpecDecl->hasBody(SpecDecl))
969  Loc = SpecDecl->getLocation();
970 
971  // Emit the standard function prologue.
972  StartFunction(GD, ResTy, Fn, FnInfo, Args, Loc, BodyRange.getBegin());
973 
974  // Generate the body of the function.
975  PGO.assignRegionCounters(GD, CurFn);
976  if (isa<CXXDestructorDecl>(FD))
977  EmitDestructorBody(Args);
978  else if (isa<CXXConstructorDecl>(FD))
979  EmitConstructorBody(Args);
980  else if (getLangOpts().CUDA &&
981  !getLangOpts().CUDAIsDevice &&
982  FD->hasAttr<CUDAGlobalAttr>())
983  CGM.getCUDARuntime().emitDeviceStub(*this, Args);
984  else if (isa<CXXConversionDecl>(FD) &&
985  cast<CXXConversionDecl>(FD)->isLambdaToBlockPointerConversion()) {
986  // The lambda conversion to block pointer is special; the semantics can't be
987  // expressed in the AST, so IRGen needs to special-case it.
989  } else if (isa<CXXMethodDecl>(FD) &&
990  cast<CXXMethodDecl>(FD)->isLambdaStaticInvoker()) {
991  // The lambda static invoker function is special, because it forwards or
992  // clones the body of the function call operator (but is actually static).
993  EmitLambdaStaticInvokeFunction(cast<CXXMethodDecl>(FD));
994  } else if (FD->isDefaulted() && isa<CXXMethodDecl>(FD) &&
995  (cast<CXXMethodDecl>(FD)->isCopyAssignmentOperator() ||
996  cast<CXXMethodDecl>(FD)->isMoveAssignmentOperator())) {
997  // Implicit copy-assignment gets the same special treatment as implicit
998  // copy-constructors.
1000  } else if (Stmt *Body = FD->getBody()) {
1001  EmitFunctionBody(Args, Body);
1002  } else
1003  llvm_unreachable("no definition for emitted function");
1004 
1005  // C++11 [stmt.return]p2:
1006  // Flowing off the end of a function [...] results in undefined behavior in
1007  // a value-returning function.
1008  // C11 6.9.1p12:
1009  // If the '}' that terminates a function is reached, and the value of the
1010  // function call is used by the caller, the behavior is undefined.
1012  !FD->getReturnType()->isVoidType() && Builder.GetInsertBlock()) {
1013  if (SanOpts.has(SanitizerKind::Return)) {
1014  SanitizerScope SanScope(this);
1015  llvm::Value *IsFalse = Builder.getFalse();
1016  EmitCheck(std::make_pair(IsFalse, SanitizerKind::Return),
1017  "missing_return", EmitCheckSourceLocation(FD->getLocation()),
1018  None);
1019  } else if (CGM.getCodeGenOpts().OptimizationLevel == 0) {
1020  EmitTrapCall(llvm::Intrinsic::trap);
1021  }
1022  Builder.CreateUnreachable();
1023  Builder.ClearInsertionPoint();
1024  }
1025 
1026  // Emit the standard function epilogue.
1027  FinishFunction(BodyRange.getEnd());
1028 
1029  // If we haven't marked the function nothrow through other means, do
1030  // a quick pass now to see if we can.
1031  if (!CurFn->doesNotThrow())
1033 }
1034 
1035 /// ContainsLabel - Return true if the statement contains a label in it. If
1036 /// this statement is not executed normally, it not containing a label means
1037 /// that we can just remove the code.
1038 bool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) {
1039  // Null statement, not a label!
1040  if (!S) return false;
1041 
1042  // If this is a label, we have to emit the code, consider something like:
1043  // if (0) { ... foo: bar(); } goto foo;
1044  //
1045  // TODO: If anyone cared, we could track __label__'s, since we know that you
1046  // can't jump to one from outside their declared region.
1047  if (isa<LabelStmt>(S))
1048  return true;
1049 
1050  // If this is a case/default statement, and we haven't seen a switch, we have
1051  // to emit the code.
1052  if (isa<SwitchCase>(S) && !IgnoreCaseStmts)
1053  return true;
1054 
1055  // If this is a switch statement, we want to ignore cases below it.
1056  if (isa<SwitchStmt>(S))
1057  IgnoreCaseStmts = true;
1058 
1059  // Scan subexpressions for verboten labels.
1060  for (const Stmt *SubStmt : S->children())
1061  if (ContainsLabel(SubStmt, IgnoreCaseStmts))
1062  return true;
1063 
1064  return false;
1065 }
1066 
1067 /// containsBreak - Return true if the statement contains a break out of it.
1068 /// If the statement (recursively) contains a switch or loop with a break
1069 /// inside of it, this is fine.
1071  // Null statement, not a label!
1072  if (!S) return false;
1073 
1074  // If this is a switch or loop that defines its own break scope, then we can
1075  // include it and anything inside of it.
1076  if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || isa<DoStmt>(S) ||
1077  isa<ForStmt>(S))
1078  return false;
1079 
1080  if (isa<BreakStmt>(S))
1081  return true;
1082 
1083  // Scan subexpressions for verboten breaks.
1084  for (const Stmt *SubStmt : S->children())
1085  if (containsBreak(SubStmt))
1086  return true;
1087 
1088  return false;
1089 }
1090 
1091 
1092 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
1093 /// to a constant, or if it does but contains a label, return false. If it
1094 /// constant folds return true and set the boolean result in Result.
1096  bool &ResultBool) {
1097  llvm::APSInt ResultInt;
1098  if (!ConstantFoldsToSimpleInteger(Cond, ResultInt))
1099  return false;
1100 
1101  ResultBool = ResultInt.getBoolValue();
1102  return true;
1103 }
1104 
1105 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
1106 /// to a constant, or if it does but contains a label, return false. If it
1107 /// constant folds return true and set the folded value.
1108 bool CodeGenFunction::
1109 ConstantFoldsToSimpleInteger(const Expr *Cond, llvm::APSInt &ResultInt) {
1110  // FIXME: Rename and handle conversion of other evaluatable things
1111  // to bool.
1112  llvm::APSInt Int;
1113  if (!Cond->EvaluateAsInt(Int, getContext()))
1114  return false; // Not foldable, not integer or not fully evaluatable.
1115 
1117  return false; // Contains a label.
1118 
1119  ResultInt = Int;
1120  return true;
1121 }
1122 
1123 
1124 
1125 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an if
1126 /// statement) to the specified blocks. Based on the condition, this might try
1127 /// to simplify the codegen of the conditional based on the branch.
1128 ///
1130  llvm::BasicBlock *TrueBlock,
1131  llvm::BasicBlock *FalseBlock,
1132  uint64_t TrueCount) {
1133  Cond = Cond->IgnoreParens();
1134 
1135  if (const BinaryOperator *CondBOp = dyn_cast<BinaryOperator>(Cond)) {
1136 
1137  // Handle X && Y in a condition.
1138  if (CondBOp->getOpcode() == BO_LAnd) {
1139  // If we have "1 && X", simplify the code. "0 && X" would have constant
1140  // folded if the case was simple enough.
1141  bool ConstantBool = false;
1142  if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) &&
1143  ConstantBool) {
1144  // br(1 && X) -> br(X).
1145  incrementProfileCounter(CondBOp);
1146  return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock,
1147  TrueCount);
1148  }
1149 
1150  // If we have "X && 1", simplify the code to use an uncond branch.
1151  // "X && 0" would have been constant folded to 0.
1152  if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) &&
1153  ConstantBool) {
1154  // br(X && 1) -> br(X).
1155  return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock,
1156  TrueCount);
1157  }
1158 
1159  // Emit the LHS as a conditional. If the LHS conditional is false, we
1160  // want to jump to the FalseBlock.
1161  llvm::BasicBlock *LHSTrue = createBasicBlock("land.lhs.true");
1162  // The counter tells us how often we evaluate RHS, and all of TrueCount
1163  // can be propagated to that branch.
1164  uint64_t RHSCount = getProfileCount(CondBOp->getRHS());
1165 
1166  ConditionalEvaluation eval(*this);
1167  {
1168  ApplyDebugLocation DL(*this, Cond);
1169  EmitBranchOnBoolExpr(CondBOp->getLHS(), LHSTrue, FalseBlock, RHSCount);
1170  EmitBlock(LHSTrue);
1171  }
1172 
1173  incrementProfileCounter(CondBOp);
1174  setCurrentProfileCount(getProfileCount(CondBOp->getRHS()));
1175 
1176  // Any temporaries created here are conditional.
1177  eval.begin(*this);
1178  EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock, TrueCount);
1179  eval.end(*this);
1180 
1181  return;
1182  }
1183 
1184  if (CondBOp->getOpcode() == BO_LOr) {
1185  // If we have "0 || X", simplify the code. "1 || X" would have constant
1186  // folded if the case was simple enough.
1187  bool ConstantBool = false;
1188  if (ConstantFoldsToSimpleInteger(CondBOp->getLHS(), ConstantBool) &&
1189  !ConstantBool) {
1190  // br(0 || X) -> br(X).
1191  incrementProfileCounter(CondBOp);
1192  return EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock,
1193  TrueCount);
1194  }
1195 
1196  // If we have "X || 0", simplify the code to use an uncond branch.
1197  // "X || 1" would have been constant folded to 1.
1198  if (ConstantFoldsToSimpleInteger(CondBOp->getRHS(), ConstantBool) &&
1199  !ConstantBool) {
1200  // br(X || 0) -> br(X).
1201  return EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, FalseBlock,
1202  TrueCount);
1203  }
1204 
1205  // Emit the LHS as a conditional. If the LHS conditional is true, we
1206  // want to jump to the TrueBlock.
1207  llvm::BasicBlock *LHSFalse = createBasicBlock("lor.lhs.false");
1208  // We have the count for entry to the RHS and for the whole expression
1209  // being true, so we can divy up True count between the short circuit and
1210  // the RHS.
1211  uint64_t LHSCount =
1212  getCurrentProfileCount() - getProfileCount(CondBOp->getRHS());
1213  uint64_t RHSCount = TrueCount - LHSCount;
1214 
1215  ConditionalEvaluation eval(*this);
1216  {
1217  ApplyDebugLocation DL(*this, Cond);
1218  EmitBranchOnBoolExpr(CondBOp->getLHS(), TrueBlock, LHSFalse, LHSCount);
1219  EmitBlock(LHSFalse);
1220  }
1221 
1222  incrementProfileCounter(CondBOp);
1223  setCurrentProfileCount(getProfileCount(CondBOp->getRHS()));
1224 
1225  // Any temporaries created here are conditional.
1226  eval.begin(*this);
1227  EmitBranchOnBoolExpr(CondBOp->getRHS(), TrueBlock, FalseBlock, RHSCount);
1228 
1229  eval.end(*this);
1230 
1231  return;
1232  }
1233  }
1234 
1235  if (const UnaryOperator *CondUOp = dyn_cast<UnaryOperator>(Cond)) {
1236  // br(!x, t, f) -> br(x, f, t)
1237  if (CondUOp->getOpcode() == UO_LNot) {
1238  // Negate the count.
1239  uint64_t FalseCount = getCurrentProfileCount() - TrueCount;
1240  // Negate the condition and swap the destination blocks.
1241  return EmitBranchOnBoolExpr(CondUOp->getSubExpr(), FalseBlock, TrueBlock,
1242  FalseCount);
1243  }
1244  }
1245 
1246  if (const ConditionalOperator *CondOp = dyn_cast<ConditionalOperator>(Cond)) {
1247  // br(c ? x : y, t, f) -> br(c, br(x, t, f), br(y, t, f))
1248  llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true");
1249  llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false");
1250 
1251  ConditionalEvaluation cond(*this);
1252  EmitBranchOnBoolExpr(CondOp->getCond(), LHSBlock, RHSBlock,
1253  getProfileCount(CondOp));
1254 
1255  // When computing PGO branch weights, we only know the overall count for
1256  // the true block. This code is essentially doing tail duplication of the
1257  // naive code-gen, introducing new edges for which counts are not
1258  // available. Divide the counts proportionally between the LHS and RHS of
1259  // the conditional operator.
1260  uint64_t LHSScaledTrueCount = 0;
1261  if (TrueCount) {
1262  double LHSRatio =
1263  getProfileCount(CondOp) / (double)getCurrentProfileCount();
1264  LHSScaledTrueCount = TrueCount * LHSRatio;
1265  }
1266 
1267  cond.begin(*this);
1268  EmitBlock(LHSBlock);
1269  incrementProfileCounter(CondOp);
1270  {
1271  ApplyDebugLocation DL(*this, Cond);
1272  EmitBranchOnBoolExpr(CondOp->getLHS(), TrueBlock, FalseBlock,
1273  LHSScaledTrueCount);
1274  }
1275  cond.end(*this);
1276 
1277  cond.begin(*this);
1278  EmitBlock(RHSBlock);
1279  EmitBranchOnBoolExpr(CondOp->getRHS(), TrueBlock, FalseBlock,
1280  TrueCount - LHSScaledTrueCount);
1281  cond.end(*this);
1282 
1283  return;
1284  }
1285 
1286  if (const CXXThrowExpr *Throw = dyn_cast<CXXThrowExpr>(Cond)) {
1287  // Conditional operator handling can give us a throw expression as a
1288  // condition for a case like:
1289  // br(c ? throw x : y, t, f) -> br(c, br(throw x, t, f), br(y, t, f)
1290  // Fold this to:
1291  // br(c, throw x, br(y, t, f))
1292  EmitCXXThrowExpr(Throw, /*KeepInsertionPoint*/false);
1293  return;
1294  }
1295 
1296  // If the branch has a condition wrapped by __builtin_unpredictable,
1297  // create metadata that specifies that the branch is unpredictable.
1298  // Don't bother if not optimizing because that metadata would not be used.
1299  llvm::MDNode *Unpredictable = nullptr;
1300  if (CGM.getCodeGenOpts().OptimizationLevel != 0) {
1301  if (const CallExpr *Call = dyn_cast<CallExpr>(Cond)) {
1302  const Decl *TargetDecl = Call->getCalleeDecl();
1303  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl)) {
1304  if (FD->getBuiltinID() == Builtin::BI__builtin_unpredictable) {
1305  llvm::MDBuilder MDHelper(getLLVMContext());
1306  Unpredictable = MDHelper.createUnpredictable();
1307  }
1308  }
1309  }
1310  }
1311 
1312  // Create branch weights based on the number of times we get here and the
1313  // number of times the condition should be true.
1314  uint64_t CurrentCount = std::max(getCurrentProfileCount(), TrueCount);
1315  llvm::MDNode *Weights =
1316  createProfileWeights(TrueCount, CurrentCount - TrueCount);
1317 
1318  // Emit the code with the fully general case.
1319  llvm::Value *CondV;
1320  {
1321  ApplyDebugLocation DL(*this, Cond);
1322  CondV = EvaluateExprAsBool(Cond);
1323  }
1324  Builder.CreateCondBr(CondV, TrueBlock, FalseBlock, Weights, Unpredictable);
1325 }
1326 
1327 /// ErrorUnsupported - Print out an error that codegen doesn't support the
1328 /// specified stmt yet.
1329 void CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type) {
1330  CGM.ErrorUnsupported(S, Type);
1331 }
1332 
1333 /// emitNonZeroVLAInit - Emit the "zero" initialization of a
1334 /// variable-length array whose elements have a non-zero bit-pattern.
1335 ///
1336 /// \param baseType the inner-most element type of the array
1337 /// \param src - a char* pointing to the bit-pattern for a single
1338 /// base element of the array
1339 /// \param sizeInChars - the total size of the VLA, in chars
1340 static void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType,
1341  Address dest, Address src,
1342  llvm::Value *sizeInChars) {
1343  CGBuilderTy &Builder = CGF.Builder;
1344 
1345  CharUnits baseSize = CGF.getContext().getTypeSizeInChars(baseType);
1346  llvm::Value *baseSizeInChars
1347  = llvm::ConstantInt::get(CGF.IntPtrTy, baseSize.getQuantity());
1348 
1349  Address begin =
1350  Builder.CreateElementBitCast(dest, CGF.Int8Ty, "vla.begin");
1351  llvm::Value *end =
1352  Builder.CreateInBoundsGEP(begin.getPointer(), sizeInChars, "vla.end");
1353 
1354  llvm::BasicBlock *originBB = CGF.Builder.GetInsertBlock();
1355  llvm::BasicBlock *loopBB = CGF.createBasicBlock("vla-init.loop");
1356  llvm::BasicBlock *contBB = CGF.createBasicBlock("vla-init.cont");
1357 
1358  // Make a loop over the VLA. C99 guarantees that the VLA element
1359  // count must be nonzero.
1360  CGF.EmitBlock(loopBB);
1361 
1362  llvm::PHINode *cur = Builder.CreatePHI(begin.getType(), 2, "vla.cur");
1363  cur->addIncoming(begin.getPointer(), originBB);
1364 
1365  CharUnits curAlign =
1366  dest.getAlignment().alignmentOfArrayElement(baseSize);
1367 
1368  // memcpy the individual element bit-pattern.
1369  Builder.CreateMemCpy(Address(cur, curAlign), src, baseSizeInChars,
1370  /*volatile*/ false);
1371 
1372  // Go to the next element.
1373  llvm::Value *next =
1374  Builder.CreateInBoundsGEP(CGF.Int8Ty, cur, baseSizeInChars, "vla.next");
1375 
1376  // Leave if that's the end of the VLA.
1377  llvm::Value *done = Builder.CreateICmpEQ(next, end, "vla-init.isdone");
1378  Builder.CreateCondBr(done, contBB, loopBB);
1379  cur->addIncoming(next, loopBB);
1380 
1381  CGF.EmitBlock(contBB);
1382 }
1383 
1384 void
1386  // Ignore empty classes in C++.
1387  if (getLangOpts().CPlusPlus) {
1388  if (const RecordType *RT = Ty->getAs<RecordType>()) {
1389  if (cast<CXXRecordDecl>(RT->getDecl())->isEmpty())
1390  return;
1391  }
1392  }
1393 
1394  // Cast the dest ptr to the appropriate i8 pointer type.
1395  if (DestPtr.getElementType() != Int8Ty)
1396  DestPtr = Builder.CreateElementBitCast(DestPtr, Int8Ty);
1397 
1398  // Get size and alignment info for this aggregate.
1400 
1401  llvm::Value *SizeVal;
1402  const VariableArrayType *vla;
1403 
1404  // Don't bother emitting a zero-byte memset.
1405  if (size.isZero()) {
1406  // But note that getTypeInfo returns 0 for a VLA.
1407  if (const VariableArrayType *vlaType =
1408  dyn_cast_or_null<VariableArrayType>(
1409  getContext().getAsArrayType(Ty))) {
1410  QualType eltType;
1411  llvm::Value *numElts;
1412  std::tie(numElts, eltType) = getVLASize(vlaType);
1413 
1414  SizeVal = numElts;
1415  CharUnits eltSize = getContext().getTypeSizeInChars(eltType);
1416  if (!eltSize.isOne())
1417  SizeVal = Builder.CreateNUWMul(SizeVal, CGM.getSize(eltSize));
1418  vla = vlaType;
1419  } else {
1420  return;
1421  }
1422  } else {
1423  SizeVal = CGM.getSize(size);
1424  vla = nullptr;
1425  }
1426 
1427  // If the type contains a pointer to data member we can't memset it to zero.
1428  // Instead, create a null constant and copy it to the destination.
1429  // TODO: there are other patterns besides zero that we can usefully memset,
1430  // like -1, which happens to be the pattern used by member-pointers.
1431  if (!CGM.getTypes().isZeroInitializable(Ty)) {
1432  // For a VLA, emit a single element, then splat that over the VLA.
1433  if (vla) Ty = getContext().getBaseElementType(vla);
1434 
1435  llvm::Constant *NullConstant = CGM.EmitNullConstant(Ty);
1436 
1437  llvm::GlobalVariable *NullVariable =
1438  new llvm::GlobalVariable(CGM.getModule(), NullConstant->getType(),
1439  /*isConstant=*/true,
1440  llvm::GlobalVariable::PrivateLinkage,
1441  NullConstant, Twine());
1442  CharUnits NullAlign = DestPtr.getAlignment();
1443  NullVariable->setAlignment(NullAlign.getQuantity());
1444  Address SrcPtr(Builder.CreateBitCast(NullVariable, Builder.getInt8PtrTy()),
1445  NullAlign);
1446 
1447  if (vla) return emitNonZeroVLAInit(*this, Ty, DestPtr, SrcPtr, SizeVal);
1448 
1449  // Get and call the appropriate llvm.memcpy overload.
1450  Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, false);
1451  return;
1452  }
1453 
1454  // Otherwise, just memset the whole thing to zero. This is legal
1455  // because in LLVM, all default initializers (other than the ones we just
1456  // handled above) are guaranteed to have a bit pattern of all zeros.
1457  Builder.CreateMemSet(DestPtr, Builder.getInt8(0), SizeVal, false);
1458 }
1459 
1460 llvm::BlockAddress *CodeGenFunction::GetAddrOfLabel(const LabelDecl *L) {
1461  // Make sure that there is a block for the indirect goto.
1462  if (!IndirectBranch)
1464 
1465  llvm::BasicBlock *BB = getJumpDestForLabel(L).getBlock();
1466 
1467  // Make sure the indirect branch includes all of the address-taken blocks.
1468  IndirectBranch->addDestination(BB);
1469  return llvm::BlockAddress::get(CurFn, BB);
1470 }
1471 
1473  // If we already made the indirect branch for indirect goto, return its block.
1474  if (IndirectBranch) return IndirectBranch->getParent();
1475 
1476  CGBuilderTy TmpBuilder(*this, createBasicBlock("indirectgoto"));
1477 
1478  // Create the PHI node that indirect gotos will add entries to.
1479  llvm::Value *DestVal = TmpBuilder.CreatePHI(Int8PtrTy, 0,
1480  "indirect.goto.dest");
1481 
1482  // Create the indirect branch instruction.
1483  IndirectBranch = TmpBuilder.CreateIndirectBr(DestVal);
1484  return IndirectBranch->getParent();
1485 }
1486 
1487 /// Computes the length of an array in elements, as well as the base
1488 /// element type and a properly-typed first element pointer.
1490  QualType &baseType,
1491  Address &addr) {
1492  const ArrayType *arrayType = origArrayType;
1493 
1494  // If it's a VLA, we have to load the stored size. Note that
1495  // this is the size of the VLA in bytes, not its size in elements.
1496  llvm::Value *numVLAElements = nullptr;
1497  if (isa<VariableArrayType>(arrayType)) {
1498  numVLAElements = getVLASize(cast<VariableArrayType>(arrayType)).first;
1499 
1500  // Walk into all VLAs. This doesn't require changes to addr,
1501  // which has type T* where T is the first non-VLA element type.
1502  do {
1503  QualType elementType = arrayType->getElementType();
1504  arrayType = getContext().getAsArrayType(elementType);
1505 
1506  // If we only have VLA components, 'addr' requires no adjustment.
1507  if (!arrayType) {
1508  baseType = elementType;
1509  return numVLAElements;
1510  }
1511  } while (isa<VariableArrayType>(arrayType));
1512 
1513  // We get out here only if we find a constant array type
1514  // inside the VLA.
1515  }
1516 
1517  // We have some number of constant-length arrays, so addr should
1518  // have LLVM type [M x [N x [...]]]*. Build a GEP that walks
1519  // down to the first element of addr.
1520  SmallVector<llvm::Value*, 8> gepIndices;
1521 
1522  // GEP down to the array type.
1523  llvm::ConstantInt *zero = Builder.getInt32(0);
1524  gepIndices.push_back(zero);
1525 
1526  uint64_t countFromCLAs = 1;
1527  QualType eltType;
1528 
1529  llvm::ArrayType *llvmArrayType =
1530  dyn_cast<llvm::ArrayType>(addr.getElementType());
1531  while (llvmArrayType) {
1532  assert(isa<ConstantArrayType>(arrayType));
1533  assert(cast<ConstantArrayType>(arrayType)->getSize().getZExtValue()
1534  == llvmArrayType->getNumElements());
1535 
1536  gepIndices.push_back(zero);
1537  countFromCLAs *= llvmArrayType->getNumElements();
1538  eltType = arrayType->getElementType();
1539 
1540  llvmArrayType =
1541  dyn_cast<llvm::ArrayType>(llvmArrayType->getElementType());
1542  arrayType = getContext().getAsArrayType(arrayType->getElementType());
1543  assert((!llvmArrayType || arrayType) &&
1544  "LLVM and Clang types are out-of-synch");
1545  }
1546 
1547  if (arrayType) {
1548  // From this point onwards, the Clang array type has been emitted
1549  // as some other type (probably a packed struct). Compute the array
1550  // size, and just emit the 'begin' expression as a bitcast.
1551  while (arrayType) {
1552  countFromCLAs *=
1553  cast<ConstantArrayType>(arrayType)->getSize().getZExtValue();
1554  eltType = arrayType->getElementType();
1555  arrayType = getContext().getAsArrayType(eltType);
1556  }
1557 
1558  llvm::Type *baseType = ConvertType(eltType);
1559  addr = Builder.CreateElementBitCast(addr, baseType, "array.begin");
1560  } else {
1561  // Create the actual GEP.
1562  addr = Address(Builder.CreateInBoundsGEP(addr.getPointer(),
1563  gepIndices, "array.begin"),
1564  addr.getAlignment());
1565  }
1566 
1567  baseType = eltType;
1568 
1569  llvm::Value *numElements
1570  = llvm::ConstantInt::get(SizeTy, countFromCLAs);
1571 
1572  // If we had any VLA dimensions, factor them in.
1573  if (numVLAElements)
1574  numElements = Builder.CreateNUWMul(numVLAElements, numElements);
1575 
1576  return numElements;
1577 }
1578 
1579 std::pair<llvm::Value*, QualType>
1582  assert(vla && "type was not a variable array type!");
1583  return getVLASize(vla);
1584 }
1585 
1586 std::pair<llvm::Value*, QualType>
1588  // The number of elements so far; always size_t.
1589  llvm::Value *numElements = nullptr;
1590 
1591  QualType elementType;
1592  do {
1593  elementType = type->getElementType();
1594  llvm::Value *vlaSize = VLASizeMap[type->getSizeExpr()];
1595  assert(vlaSize && "no size for VLA!");
1596  assert(vlaSize->getType() == SizeTy);
1597 
1598  if (!numElements) {
1599  numElements = vlaSize;
1600  } else {
1601  // It's undefined behavior if this wraps around, so mark it that way.
1602  // FIXME: Teach -fsanitize=undefined to trap this.
1603  numElements = Builder.CreateNUWMul(numElements, vlaSize);
1604  }
1605  } while ((type = getContext().getAsVariableArrayType(elementType)));
1606 
1607  return std::pair<llvm::Value*,QualType>(numElements, elementType);
1608 }
1609 
1611  assert(type->isVariablyModifiedType() &&
1612  "Must pass variably modified type to EmitVLASizes!");
1613 
1615 
1616  // We're going to walk down into the type and look for VLA
1617  // expressions.
1618  do {
1619  assert(type->isVariablyModifiedType());
1620 
1621  const Type *ty = type.getTypePtr();
1622  switch (ty->getTypeClass()) {
1623 
1624 #define TYPE(Class, Base)
1625 #define ABSTRACT_TYPE(Class, Base)
1626 #define NON_CANONICAL_TYPE(Class, Base)
1627 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
1628 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
1629 #include "clang/AST/TypeNodes.def"
1630  llvm_unreachable("unexpected dependent type!");
1631 
1632  // These types are never variably-modified.
1633  case Type::Builtin:
1634  case Type::Complex:
1635  case Type::Vector:
1636  case Type::ExtVector:
1637  case Type::Record:
1638  case Type::Enum:
1639  case Type::Elaborated:
1640  case Type::TemplateSpecialization:
1641  case Type::ObjCObject:
1642  case Type::ObjCInterface:
1643  case Type::ObjCObjectPointer:
1644  llvm_unreachable("type class is never variably-modified!");
1645 
1646  case Type::Adjusted:
1647  type = cast<AdjustedType>(ty)->getAdjustedType();
1648  break;
1649 
1650  case Type::Decayed:
1651  type = cast<DecayedType>(ty)->getPointeeType();
1652  break;
1653 
1654  case Type::Pointer:
1655  type = cast<PointerType>(ty)->getPointeeType();
1656  break;
1657 
1658  case Type::BlockPointer:
1659  type = cast<BlockPointerType>(ty)->getPointeeType();
1660  break;
1661 
1662  case Type::LValueReference:
1663  case Type::RValueReference:
1664  type = cast<ReferenceType>(ty)->getPointeeType();
1665  break;
1666 
1667  case Type::MemberPointer:
1668  type = cast<MemberPointerType>(ty)->getPointeeType();
1669  break;
1670 
1671  case Type::ConstantArray:
1672  case Type::IncompleteArray:
1673  // Losing element qualification here is fine.
1674  type = cast<ArrayType>(ty)->getElementType();
1675  break;
1676 
1677  case Type::VariableArray: {
1678  // Losing element qualification here is fine.
1679  const VariableArrayType *vat = cast<VariableArrayType>(ty);
1680 
1681  // Unknown size indication requires no size computation.
1682  // Otherwise, evaluate and record it.
1683  if (const Expr *size = vat->getSizeExpr()) {
1684  // It's possible that we might have emitted this already,
1685  // e.g. with a typedef and a pointer to it.
1686  llvm::Value *&entry = VLASizeMap[size];
1687  if (!entry) {
1688  llvm::Value *Size = EmitScalarExpr(size);
1689 
1690  // C11 6.7.6.2p5:
1691  // If the size is an expression that is not an integer constant
1692  // expression [...] each time it is evaluated it shall have a value
1693  // greater than zero.
1694  if (SanOpts.has(SanitizerKind::VLABound) &&
1695  size->getType()->isSignedIntegerType()) {
1696  SanitizerScope SanScope(this);
1697  llvm::Value *Zero = llvm::Constant::getNullValue(Size->getType());
1698  llvm::Constant *StaticArgs[] = {
1699  EmitCheckSourceLocation(size->getLocStart()),
1700  EmitCheckTypeDescriptor(size->getType())
1701  };
1702  EmitCheck(std::make_pair(Builder.CreateICmpSGT(Size, Zero),
1703  SanitizerKind::VLABound),
1704  "vla_bound_not_positive", StaticArgs, Size);
1705  }
1706 
1707  // Always zexting here would be wrong if it weren't
1708  // undefined behavior to have a negative bound.
1709  entry = Builder.CreateIntCast(Size, SizeTy, /*signed*/ false);
1710  }
1711  }
1712  type = vat->getElementType();
1713  break;
1714  }
1715 
1716  case Type::FunctionProto:
1717  case Type::FunctionNoProto:
1718  type = cast<FunctionType>(ty)->getReturnType();
1719  break;
1720 
1721  case Type::Paren:
1722  case Type::TypeOf:
1723  case Type::UnaryTransform:
1724  case Type::Attributed:
1725  case Type::SubstTemplateTypeParm:
1726  case Type::PackExpansion:
1727  // Keep walking after single level desugaring.
1728  type = type.getSingleStepDesugaredType(getContext());
1729  break;
1730 
1731  case Type::Typedef:
1732  case Type::Decltype:
1733  case Type::Auto:
1734  // Stop walking: nothing to do.
1735  return;
1736 
1737  case Type::TypeOfExpr:
1738  // Stop walking: emit typeof expression.
1739  EmitIgnoredExpr(cast<TypeOfExprType>(ty)->getUnderlyingExpr());
1740  return;
1741 
1742  case Type::Atomic:
1743  type = cast<AtomicType>(ty)->getValueType();
1744  break;
1745 
1746  case Type::Pipe:
1747  type = cast<PipeType>(ty)->getElementType();
1748  break;
1749  }
1750  } while (type->isVariablyModifiedType());
1751 }
1752 
1754  if (getContext().getBuiltinVaListType()->isArrayType())
1755  return EmitPointerWithAlignment(E);
1756  return EmitLValue(E).getAddress();
1757 }
1758 
1760  return EmitLValue(E).getAddress();
1761 }
1762 
1764  llvm::Constant *Init) {
1765  assert (Init && "Invalid DeclRefExpr initializer!");
1766  if (CGDebugInfo *Dbg = getDebugInfo())
1767  if (CGM.getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
1768  Dbg->EmitGlobalVariable(E->getDecl(), Init);
1769 }
1770 
1773  // At the moment, the only aggressive peephole we do in IR gen
1774  // is trunc(zext) folding, but if we add more, we can easily
1775  // extend this protection.
1776 
1777  if (!rvalue.isScalar()) return PeepholeProtection();
1778  llvm::Value *value = rvalue.getScalarVal();
1779  if (!isa<llvm::ZExtInst>(value)) return PeepholeProtection();
1780 
1781  // Just make an extra bitcast.
1782  assert(HaveInsertPoint());
1783  llvm::Instruction *inst = new llvm::BitCastInst(value, value->getType(), "",
1784  Builder.GetInsertBlock());
1785 
1786  PeepholeProtection protection;
1787  protection.Inst = inst;
1788  return protection;
1789 }
1790 
1792  if (!protection.Inst) return;
1793 
1794  // In theory, we could try to duplicate the peepholes now, but whatever.
1795  protection.Inst->eraseFromParent();
1796 }
1797 
1799  llvm::Value *AnnotatedVal,
1800  StringRef AnnotationStr,
1801  SourceLocation Location) {
1802  llvm::Value *Args[4] = {
1803  AnnotatedVal,
1806  CGM.EmitAnnotationLineNo(Location)
1807  };
1808  return Builder.CreateCall(AnnotationFn, Args);
1809 }
1810 
1812  assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
1813  // FIXME We create a new bitcast for every annotation because that's what
1814  // llvm-gcc was doing.
1815  for (const auto *I : D->specific_attrs<AnnotateAttr>())
1816  EmitAnnotationCall(CGM.getIntrinsic(llvm::Intrinsic::var_annotation),
1817  Builder.CreateBitCast(V, CGM.Int8PtrTy, V->getName()),
1818  I->getAnnotation(), D->getLocation());
1819 }
1820 
1822  Address Addr) {
1823  assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
1824  llvm::Value *V = Addr.getPointer();
1825  llvm::Type *VTy = V->getType();
1826  llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::ptr_annotation,
1827  CGM.Int8PtrTy);
1828 
1829  for (const auto *I : D->specific_attrs<AnnotateAttr>()) {
1830  // FIXME Always emit the cast inst so we can differentiate between
1831  // annotation on the first field of a struct and annotation on the struct
1832  // itself.
1833  if (VTy != CGM.Int8PtrTy)
1834  V = Builder.Insert(new llvm::BitCastInst(V, CGM.Int8PtrTy));
1835  V = EmitAnnotationCall(F, V, I->getAnnotation(), D->getLocation());
1836  V = Builder.CreateBitCast(V, VTy);
1837  }
1838 
1839  return Address(V, Addr.getAlignment());
1840 }
1841 
1843 
1845  : CGF(CGF) {
1846  assert(!CGF->IsSanitizerScope);
1847  CGF->IsSanitizerScope = true;
1848 }
1849 
1851  CGF->IsSanitizerScope = false;
1852 }
1853 
1854 void CodeGenFunction::InsertHelper(llvm::Instruction *I,
1855  const llvm::Twine &Name,
1856  llvm::BasicBlock *BB,
1857  llvm::BasicBlock::iterator InsertPt) const {
1859  if (IsSanitizerScope)
1861 }
1862 
1863 template <bool PreserveNames>
1865  llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB,
1866  llvm::BasicBlock::iterator InsertPt) const {
1867  llvm::IRBuilderDefaultInserter<PreserveNames>::InsertHelper(I, Name, BB,
1868  InsertPt);
1869  if (CGF)
1870  CGF->InsertHelper(I, Name, BB, InsertPt);
1871 }
1872 
1873 #ifdef NDEBUG
1874 #define PreserveNames false
1875 #else
1876 #define PreserveNames true
1877 #endif
1879  llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB,
1880  llvm::BasicBlock::iterator InsertPt) const;
1881 #undef PreserveNames
1882 
1883 static bool hasRequiredFeatures(const SmallVectorImpl<StringRef> &ReqFeatures,
1884  CodeGenModule &CGM, const FunctionDecl *FD,
1885  std::string &FirstMissing) {
1886  // If there aren't any required features listed then go ahead and return.
1887  if (ReqFeatures.empty())
1888  return false;
1889 
1890  // Now build up the set of caller features and verify that all the required
1891  // features are there.
1892  llvm::StringMap<bool> CallerFeatureMap;
1893  CGM.getFunctionFeatureMap(CallerFeatureMap, FD);
1894 
1895  // If we have at least one of the features in the feature list return
1896  // true, otherwise return false.
1897  return std::all_of(
1898  ReqFeatures.begin(), ReqFeatures.end(), [&](StringRef Feature) {
1899  SmallVector<StringRef, 1> OrFeatures;
1900  Feature.split(OrFeatures, "|");
1901  return std::any_of(OrFeatures.begin(), OrFeatures.end(),
1902  [&](StringRef Feature) {
1903  if (!CallerFeatureMap.lookup(Feature)) {
1904  FirstMissing = Feature.str();
1905  return false;
1906  }
1907  return true;
1908  });
1909  });
1910 }
1911 
1912 // Emits an error if we don't have a valid set of target features for the
1913 // called function.
1915  const FunctionDecl *TargetDecl) {
1916  // Early exit if this is an indirect call.
1917  if (!TargetDecl)
1918  return;
1919 
1920  // Get the current enclosing function if it exists. If it doesn't
1921  // we can't check the target features anyhow.
1922  const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurFuncDecl);
1923  if (!FD)
1924  return;
1925 
1926  // Grab the required features for the call. For a builtin this is listed in
1927  // the td file with the default cpu, for an always_inline function this is any
1928  // listed cpu and any listed features.
1929  unsigned BuiltinID = TargetDecl->getBuiltinID();
1930  std::string MissingFeature;
1931  if (BuiltinID) {
1932  SmallVector<StringRef, 1> ReqFeatures;
1933  const char *FeatureList =
1935  // Return if the builtin doesn't have any required features.
1936  if (!FeatureList || StringRef(FeatureList) == "")
1937  return;
1938  StringRef(FeatureList).split(ReqFeatures, ",");
1939  if (!hasRequiredFeatures(ReqFeatures, CGM, FD, MissingFeature))
1940  CGM.getDiags().Report(E->getLocStart(), diag::err_builtin_needs_feature)
1941  << TargetDecl->getDeclName()
1943 
1944  } else if (TargetDecl->hasAttr<TargetAttr>()) {
1945  // Get the required features for the callee.
1946  SmallVector<StringRef, 1> ReqFeatures;
1947  llvm::StringMap<bool> CalleeFeatureMap;
1948  CGM.getFunctionFeatureMap(CalleeFeatureMap, TargetDecl);
1949  for (const auto &F : CalleeFeatureMap) {
1950  // Only positive features are "required".
1951  if (F.getValue())
1952  ReqFeatures.push_back(F.getKey());
1953  }
1954  if (!hasRequiredFeatures(ReqFeatures, CGM, FD, MissingFeature))
1955  CGM.getDiags().Report(E->getLocStart(), diag::err_function_needs_feature)
1956  << FD->getDeclName() << TargetDecl->getDeclName() << MissingFeature;
1957  }
1958 }
unsigned getAddressSpace() const
Return the address space of this type.
Definition: Type.h:5204
Defines the clang::ASTContext interface.
SourceLocation getEnd() const
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1483
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 ...
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:169
CanQualType VoidPtrTy
Definition: ASTContext.h:895
A (possibly-)qualified type.
Definition: Type.h:575
llvm::Type * ConvertTypeForMem(QualType T)
void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount)
EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g.
CanQualType getReturnType() const
unsigned getInAllocaFieldIndex() const
llvm::Constant * EmitCheckTypeDescriptor(QualType T)
Emit a description of a type in a format suitable for passing to a runtime sanitizer handler...
Definition: CGExpr.cpp:2271
llvm::Module & getModule() const
AlignmentSource
The source of the alignment of an l-value; an expression of confidence in the alignment actually matc...
Definition: CGValue.h:125
void EmitFunctionInstrumentation(const char *Fn)
EmitFunctionInstrumentation - Emit LLVM code to call the specified instrumentation function with the ...
bool isOne() const
isOne - Test whether the quantity equals one.
Definition: CharUnits.h:119
virtual void addImplicitStructorParams(CodeGenFunction &CGF, QualType &ResTy, FunctionArgList &Params)=0
Insert any ABI-specific implicit parameters into the parameter list for a function.
CharUnits getClassPointerAlignment(const CXXRecordDecl *CD)
Returns the assumed alignment of an opaque pointer to the given class.
Definition: CGClass.cpp:35
const TargetInfo & getTarget() const
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program...
Definition: Decl.cpp:2526
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
static bool endsWithReturn(const Decl *F)
Determine whether the function F ends with a return stmt.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:171
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:77
Address getAddress() const
Definition: CGValue.h:331
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
bool isAlignmentRequired(const Type *T) const
Determine if the alignment the type has was required using an alignment attribute.
std::string getAsString() const
Definition: Type.h:901
The base class of the type hierarchy.
Definition: Type.h:1249
bool ShouldInstrumentFunction()
ShouldInstrumentFunction - Return true if the current function should be instrumented with __cyg_prof...
Emit only debug info necessary for generating line number tables (-gline-tables-only).
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1117
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:2424
static bool hasRequiredFeatures(const SmallVectorImpl< StringRef > &ReqFeatures, CodeGenModule &CGM, const FunctionDecl *FD, std::string &FirstMissing)
const LangOptions & getLangOpts() const
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
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:699
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:52
RAII object to set/unset CodeGenFunction::IsSanitizerScope.
Extra information about a function prototype.
Definition: Type.h:3067
uint64_t getProfileCount(const Stmt *S)
Get the profiler's count for the given statement.
bool isCanonical() const
Definition: Type.h:5133
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
Definition: CGDebugInfo.h:51
QualType getThisType(ASTContext &C) const
Returns the type of the this pointer.
Definition: DeclCXX.cpp:1598
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:2583
void EmitVariablyModifiedType(QualType Ty)
EmitVLASize - Capture all the sizes for the VLA expressions in the given variably-modified type and s...
CharUnits getNaturalTypeAlignment(QualType T, AlignmentSource *Source=nullptr, bool forPointeeType=false)
void setCurrentProfileCount(uint64_t Count)
Set the profiler's current count.
bool IsSanitizerScope
True if CodeGen currently emits code implementing sanitizer checks.
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:35
bool isImageType() const
Definition: Type.h:5492
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:900
iterator begin() const
Definition: Type.h:4072
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1299
bool isObjCRetainableType() const
Definition: Type.cpp:3704
static void destroyBlockInfos(CGBlockInfo *info)
Destroy a chain of block layouts.
Definition: CGBlocks.cpp:659
void emitImplicitAssignmentOperatorBody(FunctionArgList &Args)
Definition: CGClass.cpp:1601
bool isVoidType() const
Definition: Type.h:5546
EHScopeStack::stable_iterator PrologueCleanupDepth
PrologueCleanupDepth - The cleanup depth enclosing all the cleanups associated with the parameters...
virtual bool hasMostDerivedReturn(GlobalDecl GD) const
Definition: CGCXXABI.h:107
JumpDest getJumpDestForLabel(const LabelDecl *S)
getBasicBlockForLabel - Return the LLVM basicblock that the specified label maps to.
Definition: CGStmt.cpp:422
llvm::DenseMap< const VarDecl *, FieldDecl * > LambdaCaptureFields
An object to manage conditionally-evaluated expressions.
PeepholeProtection protectFromPeepholes(RValue rvalue)
protectFromPeepholes - Protect a value that we're intending to store to the side, but which will prob...
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:2363
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4381
bool hasAttr() const
Definition: DeclBase.h:498
Indirect - Pass the argument indirectly via a hidden pointer with the specified alignment (0 indicate...
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
Expr * getSizeExpr() const
Definition: Type.h:2591
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:1766
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:91
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:3065
QualType getReturnType() const
Definition: Decl.h:1956
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2209
void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB, llvm::BasicBlock::iterator InsertPt) const
CGBuilder insert helper.
SanitizerMask Mask
Bitmask of enabled sanitizers.
Definition: Sanitizers.h:73
const Decl * getDecl() const
Definition: GlobalDecl.h:60
void disableSanitizerForInstruction(llvm::Instruction *I)
Address CreateIRTemp(QualType T, const Twine &Name="tmp")
CreateIRTemp - Create a temporary IR object of the given type, with appropriate alignment.
Definition: CGExpr.cpp:92
T * getAttr() const
Definition: DeclBase.h:495
virtual void EmitInstanceFunctionProlog(CodeGenFunction &CGF)=0
Emit the ABI-specific prolog for the function.
CGCUDARuntime & getCUDARuntime()
Return a reference to the configured CUDA runtime.
static bool hasScalarEvaluationKind(QualType T)
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:176
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:1801
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:1764
field_range fields() const
Definition: Decl.h:3295
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2875
The l-value was considered opaque, so the alignment was determined from a type, but that type was an ...
FunctionDecl * getTemplateInstantiationPattern() const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
Definition: Decl.cpp:3123
llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:272
void incrementProfileCounter(const Stmt *S)
Increment the profiler's counter for the given statement.
void EmitStmt(const Stmt *S)
EmitStmt - Emit the code for the statement.
Definition: CGStmt.cpp:48
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
void EmitIgnoredExpr(const Expr *E)
EmitIgnoredExpr - Emit an expression in a context which ignores the result.
Definition: CGExpr.cpp:127
void assignRegionCounters(GlobalDecl GD, llvm::Function *Fn)
Assign counters to regions and configure them for PGO of a given function.
Definition: CodeGenPGO.cpp:608
TypeClass getTypeClass() const
Definition: Type.h:1501
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:1886
iterator end() const
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts=false)
ContainsLabel - Return true if the statement contains a label in it.
llvm::DebugLoc EmitReturnBlock()
Emit the unified return block, trying to avoid its emission when possible.
uint64_t getCurrentProfileCount()
Get the profiler's current count.
detail::InMemoryDirectory::const_iterator I
virtual void emitDeviceStub(CodeGenFunction &CGF, FunctionArgList &Args)=0
Emits a kernel launch stub.
QualType getType() const
Definition: Decl.h:530
void EmitDeclRefExprDbgValue(const DeclRefExpr *E, llvm::Constant *Init)
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource AlignSource=AlignmentSource::Type)
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3148
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:58
void EmitCheck(ArrayRef< std::pair< llvm::Value *, SanitizerMask >> Checked, StringRef CheckName, 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:2432
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:539
llvm::CallInst * EmitNounwindRuntimeCall(llvm::Value *callee, const Twine &name="")
const TargetCodeGenInfo & getTargetCodeGenInfo()
void clear()
Disable all sanitizers.
Definition: Sanitizers.h:67
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
Definition: CGValue.h:38
static void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB)
ASTContext * Context
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:415
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *FD)
static TypeEvaluationKind getEvaluationKind(QualType T)
hasAggregateLLVMType - Return true if the specified AST type will map into an aggregate LLVM type or ...
llvm::Constant * EmitAnnotationUnit(SourceLocation Loc)
Emit the annotation's translation unit.
static void GenOpenCLArgMetadata(const FunctionDecl *FD, llvm::Function *Fn, CodeGenModule &CGM, llvm::LLVMContext &Context, SmallVector< llvm::Metadata *, 5 > &kernelMDArgs, CGBuilderTy &Builder, ASTContext &ASTCtx)
llvm::Value * getPointer() const
Definition: Address.h:38
llvm::BasicBlock * EHResumeBlock
EHResumeBlock - Unified block containing a call to llvm.eh.resume.
bool empty() const
Determines whether the exception-scopes stack is empty.
Definition: EHScopeStack.h:342
Expr - This represents one expression.
Definition: Expr.h:104
static Address invalid()
Definition: Address.h:35
bool isInstance() const
Definition: DeclCXX.h:1728
CGCXXABI & getCXXABI() const
CharUnits getIndirectAlign() const
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:1927
static void TryMarkNoThrow(llvm::Function *F)
Tries to mark the given function nounwind based on the non-existence of any throwing calls within it...
ASTContext & getContext() const
CharUnits getNaturalPointeeTypeAlignment(QualType T, AlignmentSource *Source=nullptr)
llvm::BasicBlock * getBlock() const
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
static LValue MakeAddr(Address address, QualType type, ASTContext &Context, AlignmentSource alignSource, llvm::MDNode *TBAAInfo=nullptr)
Definition: CGValue.h:371
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
Definition: EHScopeStack.h:378
llvm::LLVMContext & getLLVMContext()
llvm::BasicBlock * GetIndirectGotoBlock()
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
void EmitConstructorBody(FunctionArgList &Args)
EmitConstructorBody - Emits the body of the current constructor.
Definition: CGClass.cpp:916
Address EmitPointerWithAlignment(const Expr *Addr, AlignmentSource *Source=nullptr)
EmitPointerWithAlignment - Given an expression with a pointer type, emit the value and compute our be...
Definition: CGExpr.cpp:795
llvm::Constant * EmitAnnotationString(StringRef Str)
Emit an annotation string.
bool EvaluateAsInt(llvm::APSInt &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer...
virtual llvm::Constant * getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const
Return a constant used by UBSan as a signature to identify functions possessing type information...
virtual bool HasThisReturn(GlobalDecl GD) const
Returns true if the given constructor or destructor is one of the kinds that the ABI says returns 'th...
Definition: CGCXXABI.h:105
LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T)
bool containsOnlyLifetimeMarkers(stable_iterator Old) const
Definition: CGCleanup.cpp:149
llvm::CallInst * CreateMemSet(Address Dest, llvm::Value *Value, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:294
void EmitMCountInstrumentation()
EmitMCountInstrumentation - Emit call to .mcount.
An object which temporarily prevents a value from being destroyed by aggressive peephole optimization...
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1654
void EmitLambdaToBlockPointerBody(FunctionArgList &Args)
Definition: CGClass.cpp:2742
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys=None)
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:190
ValueDecl * getDecl()
Definition: Expr.h:1007
QualType getElementType() const
Definition: Type.h:2748
virtual void startNewFunction()
Definition: Mangle.h:73
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:28
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:545
The l-value was considered opaque, so the alignment was determined from a type.
Stmt * getBody(const FunctionDecl *&Definition) const
getBody - Retrieve the body (definition) of the function.
Definition: Decl.cpp:2497
bool HaveInsertPoint() const
HaveInsertPoint - True if an insertion point is defined.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:236
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:168
#define false
Definition: stdbool.h:33
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
bool hasOneOf(SanitizerMask K) const
Check if one or more sanitizers are enabled.
Definition: Sanitizers.h:58
llvm::Constant * CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeSet ExtraAttrs=llvm::AttributeSet())
Create a new runtime function with the specified type and name.
ASTContext & getContext() const
Encodes a location in the source.
void EnsureInsertPoint()
EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go...
unsigned getNumParams() const
getNumParams - Return the number of parameters this function must have based on its FunctionType...
Definition: Decl.cpp:2743
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5089
const TemplateArgument * iterator
Definition: Type.h:4070
llvm::Value * EvaluateExprAsBool(const Expr *E)
EvaluateExprAsBool - Perform the usual unary conversions on the specified expression and compare the ...
Definition: CGExpr.cpp:109
bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result)
ConstantFoldsToSimpleInteger - If the specified expression does not fold to a constant, or if it does but contains a label, return false.
const char * getRequiredFeatures(unsigned ID) const
Definition: Builtins.h:182
LabelDecl - Represents the declaration of a label.
Definition: Decl.h:355
A scoped helper to set the current debug location to the specified location or preferred location of ...
Definition: CGDebugInfo.h:531
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1701
bool isReturnsRetained() const
In ARC, whether this function retains its return value.
SanitizerSet SanOpts
Sanitizers enabled for this function.
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
CharUnits alignmentOfArrayElement(CharUnits elementSize) const
Given that this is the alignment of the first element of an array, return the minimum alignment of an...
Definition: CharUnits.h:190
const CodeGenOptions & getCodeGenOpts() const
An aligned address.
Definition: Address.h:25
void StartFunction(GlobalDecl GD, QualType RetTy, llvm::Function *Fn, const CGFunctionInfo &FnInfo, const FunctionArgList &Args, SourceLocation Loc=SourceLocation(), SourceLocation StartLoc=SourceLocation())
Emit code for the start of a function.
const LangOptions & getLangOpts() const
SourceLocation getBegin() const
void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB, llvm::BasicBlock::iterator InsertPt) const
This forwards to CodeGenFunction::InsertHelper.
MangleContext & getMangleContext()
Gets the mangle context.
Definition: CGCXXABI.h:95
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:1016
JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target)
The given basic block lies in the current EH scope, but may be a target of a potentially scope-crossi...
llvm::Constant * EmitAnnotationLineNo(SourceLocation L)
Emit the annotation line number.
unsigned getBuiltinID() const
Returns a value indicating whether this function corresponds to a builtin function.
Definition: Decl.cpp:2693
InAlloca - Pass the argument directly using the LLVM inalloca attribute.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5159
Address EmitMSVAListRef(const Expr *E)
Emit a "reference" to a __builtin_ms_va_list; this is always the value of the expression, because a __builtin_ms_va_list is a pointer to a char.
const CGFunctionInfo * CurFnInfo
void EmitStartEHSpec(const Decl *D)
EmitStartEHSpec - Emit the start of the exception spec.
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
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:146
param_range params()
Definition: Decl.h:1910
Represents a template argument.
Definition: TemplateBase.h:40
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn't support the specified stmt yet.
CGFunctionInfo - Class to encapsulate the information about a function definition.
CharUnits getAlignment() const
Return the alignment of this pointer.
Definition: Address.h:67
This class organizes the cross-function state that is used while generating LLVM code.
CGOpenMPRuntime & getOpenMPRuntime()
Return a reference to the configured OpenMP runtime.
static const Type * getElementType(const Expr *BaseExpr)
static void emitNonZeroVLAInit(CodeGenFunction &CGF, QualType baseType, Address dest, Address src, llvm::Value *sizeInChars)
emitNonZeroVLAInit - Emit the "zero" initialization of a variable-length array whose elements have a ...
bool isScalar() const
Definition: CGValue.h:51
Address EmitFieldAnnotations(const FieldDecl *D, Address V)
Emit field annotations for the given field & value.
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1723
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition: CGValue.h:58
Address CreateStructGEP(Address Addr, unsigned Index, CharUnits Offset, const llvm::Twine &Name="")
Definition: CGBuilder.h:191
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:99
Decl * getNonClosureContext()
Find the innermost non-closure ancestor of this declaration, walking up through blocks, lambdas, etc.
Definition: DeclBase.cpp:815
void buildThisParam(CodeGenFunction &CGF, FunctionArgList &Params)
Build a parameter variable suitable for 'this'.
Definition: CGCXXABI.cpp:156
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
detail::InMemoryDirectory::const_iterator E
llvm::SmallVector< char, 256 > LifetimeExtendedCleanupStack
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1022
bool isInSanitizerBlacklist(llvm::Function *Fn, SourceLocation Loc) const
const VariableArrayType * getAsVariableArrayType(QualType T) const
Definition: ASTContext.h:2097
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:3544
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...
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5675
QualType getCanonicalType() const
Definition: Type.h:5128
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T)
Definition: Decl.cpp:3948
void EmitLambdaStaticInvokeFunction(const CXXMethodDecl *MD)
Definition: CGClass.cpp:2783
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1292
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
Definition: Sanitizers.h:52
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:2784
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1522
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
Definition: Type.h:5153
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:367
void checkTargetFeatures(const CallExpr *E, const FunctionDecl *TargetDecl)
void EmitFunctionBody(FunctionArgList &Args, const Stmt *Body)
llvm::ConstantInt * getSize(CharUnits numChars)
Emit the given number of characters as a value of type size_t.
const Decl * CurFuncDecl
CurFuncDecl - Holds the Decl for the current outermost non-closure context.
void InsertHelper(llvm::Instruction *I) const
Function called by the CodeGenFunction when an instruction is created.
Definition: CGLoopInfo.cpp:229
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
void unprotectFromPeepholes(PeepholeProtection protection)
DiagnosticsEngine & getDiags() const
void ErrorUnsupported(const Stmt *S, const char *Type)
ErrorUnsupported - Print out an error that codegen doesn't support the specified stmt yet...
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5169
Represents a C++ struct/union/class.
Definition: DeclCXX.h:285
BoundNodesTreeBuilder *const Builder
void EmitBranch(llvm::BasicBlock *Block)
EmitBranch - Emit a branch to the specified basic block from the current insert block, taking care to avoid creation of branches from dummy blocks.
Definition: CGStmt.cpp:387
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
Definition: DeclBase.h:482
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:1813
void PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize)
Takes the old cleanup stack size and emits the cleanup blocks that have been added.
Definition: CGCleanup.cpp:404
LValue EmitLValue(const Expr *E)
EmitLValue - Emit code to compute a designator that specifies the location of the expression...
Definition: CGExpr.cpp:944
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
bool isPipeType() const
Definition: Type.h:5500
Builtin::Context & BuiltinInfo
Definition: ASTContext.h:453
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:1415
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:2134
llvm::MDNode * getTBAAInfo(QualType QTy)
unsigned getTargetAddressSpace(QualType T) const
Definition: ASTContext.h:2180
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:922
void EmitDestructorBody(FunctionArgList &Args)
EmitDestructorBody - Emits the body of the current destructor.
Definition: CGClass.cpp:1506
QualType getElementType() const
Definition: Type.h:2458
This structure provides a set of types that are commonly used during IR emission. ...
void EmitEndEHSpec(const Decl *D)
EmitEndEHSpec - Emit the end of the exception spec.
llvm::Constant * EmitCheckSourceLocation(SourceLocation Loc)
Emit a description of a source location in a format suitable for passing to a runtime sanitizer handl...
Definition: CGExpr.cpp:2349
Address EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
Definition: CGStmt.cpp:306
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:384
LValue - This represents an lvalue references.
Definition: CGValue.h:152
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:2575
SanitizerMetadata * getSanitizerMetadata()
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
Definition: Type.cpp:1700
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5148
bool hasImplicitReturnZero() const
Whether falling off this function implicitly returns null/zero.
Definition: Decl.h:1775
llvm::Value * emitArrayLength(const ArrayType *arrayType, QualType &baseType, Address &addr)
emitArrayLength - Compute the length of an array, even if it's a VLA, and drill down to the base elem...
static bool containsBreak(const Stmt *S)
containsBreak - Return true if the statement contains a break out of it.
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
Definition: Type.h:882
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
bool isZeroInitializable(QualType T)
IsZeroInitializable - Return whether a type can be zero-initialized (in the C++ sense) with an LLVM z...
Defines enum values for all the target-independent builtin functions.
void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)
Attr - This represents one attribute.
Definition: Attr.h:44
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:2433
bool isPointerType() const
Definition: Type.h:5305
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any...
Definition: Decl.cpp:3009