clang  3.7.0
CGExprCXX.cpp
Go to the documentation of this file.
1 //===--- CGExprCXX.cpp - Emit LLVM Code for C++ expressions ---------------===//
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 contains code dealing with code generation of C++ expressions
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CodeGenFunction.h"
15 #include "CGCUDARuntime.h"
16 #include "CGCXXABI.h"
17 #include "CGDebugInfo.h"
18 #include "CGObjCRuntime.h"
21 #include "llvm/IR/CallSite.h"
22 #include "llvm/IR/Intrinsics.h"
23 
24 using namespace clang;
25 using namespace CodeGen;
26 
28  CodeGenFunction &CGF, const CXXMethodDecl *MD, llvm::Value *Callee,
29  ReturnValueSlot ReturnValue, llvm::Value *This, llvm::Value *ImplicitParam,
30  QualType ImplicitParamTy, const CallExpr *CE, CallArgList &Args) {
31  assert(CE == nullptr || isa<CXXMemberCallExpr>(CE) ||
32  isa<CXXOperatorCallExpr>(CE));
33  assert(MD->isInstance() &&
34  "Trying to emit a member or operator call expr on a static method!");
35 
36  // C++11 [class.mfct.non-static]p2:
37  // If a non-static member function of a class X is called for an object that
38  // is not of type X, or of a type derived from X, the behavior is undefined.
39  SourceLocation CallLoc;
40  if (CE)
41  CallLoc = CE->getExprLoc();
42  CGF.EmitTypeCheck(
43  isa<CXXConstructorDecl>(MD) ? CodeGenFunction::TCK_ConstructorCall
45  CallLoc, This, CGF.getContext().getRecordType(MD->getParent()));
46 
47  // Push the this ptr.
48  Args.add(RValue::get(This), MD->getThisType(CGF.getContext()));
49 
50  // If there is an implicit parameter (e.g. VTT), emit it.
51  if (ImplicitParam) {
52  Args.add(RValue::get(ImplicitParam), ImplicitParamTy);
53  }
54 
55  const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
56  RequiredArgs required = RequiredArgs::forPrototypePlus(FPT, Args.size());
57 
58  // And the rest of the call args.
59  if (CE) {
60  // Special case: skip first argument of CXXOperatorCall (it is "this").
61  unsigned ArgsToSkip = isa<CXXOperatorCallExpr>(CE) ? 1 : 0;
62  CGF.EmitCallArgs(Args, FPT, CE->arg_begin() + ArgsToSkip, CE->arg_end(),
63  CE->getDirectCallee());
64  } else {
65  assert(
66  FPT->getNumParams() == 0 &&
67  "No CallExpr specified for function with non-zero number of arguments");
68  }
69  return required;
70 }
71 
73  const CXXMethodDecl *MD, llvm::Value *Callee, ReturnValueSlot ReturnValue,
74  llvm::Value *This, llvm::Value *ImplicitParam, QualType ImplicitParamTy,
75  const CallExpr *CE) {
76  const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
77  CallArgList Args;
79  *this, MD, Callee, ReturnValue, This, ImplicitParam, ImplicitParamTy, CE,
80  Args);
81  return EmitCall(CGM.getTypes().arrangeCXXMethodCall(Args, FPT, required),
82  Callee, ReturnValue, Args, MD);
83 }
84 
86  const CXXMethodDecl *MD, llvm::Value *Callee, ReturnValueSlot ReturnValue,
87  llvm::Value *This, llvm::Value *ImplicitParam, QualType ImplicitParamTy,
88  const CallExpr *CE, StructorType Type) {
89  CallArgList Args;
90  commonEmitCXXMemberOrOperatorCall(*this, MD, Callee, ReturnValue, This,
91  ImplicitParam, ImplicitParamTy, CE, Args);
93  Callee, ReturnValue, Args, MD);
94 }
95 
96 static CXXRecordDecl *getCXXRecord(const Expr *E) {
97  QualType T = E->getType();
98  if (const PointerType *PTy = T->getAs<PointerType>())
99  T = PTy->getPointeeType();
100  const RecordType *Ty = T->castAs<RecordType>();
101  return cast<CXXRecordDecl>(Ty->getDecl());
102 }
103 
104 // Note: This function also emit constructor calls to support a MSVC
105 // extensions allowing explicit constructor function call.
107  ReturnValueSlot ReturnValue) {
108  const Expr *callee = CE->getCallee()->IgnoreParens();
109 
110  if (isa<BinaryOperator>(callee))
111  return EmitCXXMemberPointerCallExpr(CE, ReturnValue);
112 
113  const MemberExpr *ME = cast<MemberExpr>(callee);
114  const CXXMethodDecl *MD = cast<CXXMethodDecl>(ME->getMemberDecl());
115 
116  if (MD->isStatic()) {
117  // The method is static, emit it as we would a regular call.
118  llvm::Value *Callee = CGM.GetAddrOfFunction(MD);
119  return EmitCall(getContext().getPointerType(MD->getType()), Callee, CE,
120  ReturnValue);
121  }
122 
123  bool HasQualifier = ME->hasQualifier();
124  NestedNameSpecifier *Qualifier = HasQualifier ? ME->getQualifier() : nullptr;
125  bool IsArrow = ME->isArrow();
126  const Expr *Base = ME->getBase();
127 
129  CE, MD, ReturnValue, HasQualifier, Qualifier, IsArrow, Base);
130 }
131 
133  const CallExpr *CE, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue,
134  bool HasQualifier, NestedNameSpecifier *Qualifier, bool IsArrow,
135  const Expr *Base) {
136  assert(isa<CXXMemberCallExpr>(CE) || isa<CXXOperatorCallExpr>(CE));
137 
138  // Compute the object pointer.
139  bool CanUseVirtualCall = MD->isVirtual() && !HasQualifier;
140 
141  const CXXMethodDecl *DevirtualizedMethod = nullptr;
142  if (CanUseVirtualCall && CanDevirtualizeMemberFunctionCall(Base, MD)) {
143  const CXXRecordDecl *BestDynamicDecl = Base->getBestDynamicClassType();
144  DevirtualizedMethod = MD->getCorrespondingMethodInClass(BestDynamicDecl);
145  assert(DevirtualizedMethod);
146  const CXXRecordDecl *DevirtualizedClass = DevirtualizedMethod->getParent();
147  const Expr *Inner = Base->ignoreParenBaseCasts();
148  if (DevirtualizedMethod->getReturnType().getCanonicalType() !=
150  // If the return types are not the same, this might be a case where more
151  // code needs to run to compensate for it. For example, the derived
152  // method might return a type that inherits form from the return
153  // type of MD and has a prefix.
154  // For now we just avoid devirtualizing these covariant cases.
155  DevirtualizedMethod = nullptr;
156  else if (getCXXRecord(Inner) == DevirtualizedClass)
157  // If the class of the Inner expression is where the dynamic method
158  // is defined, build the this pointer from it.
159  Base = Inner;
160  else if (getCXXRecord(Base) != DevirtualizedClass) {
161  // If the method is defined in a class that is not the best dynamic
162  // one or the one of the full expression, we would have to build
163  // a derived-to-base cast to compute the correct this pointer, but
164  // we don't have support for that yet, so do a virtual call.
165  DevirtualizedMethod = nullptr;
166  }
167  }
168 
169  llvm::Value *This;
170  if (IsArrow)
171  This = EmitScalarExpr(Base);
172  else
173  This = EmitLValue(Base).getAddress();
174 
175 
176  if (MD->isTrivial() || (MD->isDefaulted() && MD->getParent()->isUnion())) {
177  if (isa<CXXDestructorDecl>(MD)) return RValue::get(nullptr);
178  if (isa<CXXConstructorDecl>(MD) &&
179  cast<CXXConstructorDecl>(MD)->isDefaultConstructor())
180  return RValue::get(nullptr);
181 
182  if (!MD->getParent()->mayInsertExtraPadding()) {
184  // We don't like to generate the trivial copy/move assignment operator
185  // when it isn't necessary; just produce the proper effect here.
186  // Special case: skip first argument of CXXOperatorCall (it is "this").
187  unsigned ArgsToSkip = isa<CXXOperatorCallExpr>(CE) ? 1 : 0;
188  llvm::Value *RHS =
189  EmitLValue(*(CE->arg_begin() + ArgsToSkip)).getAddress();
190  EmitAggregateAssign(This, RHS, CE->getType());
191  return RValue::get(This);
192  }
193 
194  if (isa<CXXConstructorDecl>(MD) &&
195  cast<CXXConstructorDecl>(MD)->isCopyOrMoveConstructor()) {
196  // Trivial move and copy ctor are the same.
197  assert(CE->getNumArgs() == 1 && "unexpected argcount for trivial ctor");
198  llvm::Value *RHS = EmitLValue(*CE->arg_begin()).getAddress();
199  EmitAggregateCopy(This, RHS, CE->arg_begin()->getType());
200  return RValue::get(This);
201  }
202  llvm_unreachable("unknown trivial member function");
203  }
204  }
205 
206  // Compute the function type we're calling.
207  const CXXMethodDecl *CalleeDecl =
208  DevirtualizedMethod ? DevirtualizedMethod : MD;
209  const CGFunctionInfo *FInfo = nullptr;
210  if (const auto *Dtor = dyn_cast<CXXDestructorDecl>(CalleeDecl))
212  Dtor, StructorType::Complete);
213  else if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(CalleeDecl))
215  Ctor, StructorType::Complete);
216  else
217  FInfo = &CGM.getTypes().arrangeCXXMethodDeclaration(CalleeDecl);
218 
219  llvm::FunctionType *Ty = CGM.getTypes().GetFunctionType(*FInfo);
220 
221  // C++ [class.virtual]p12:
222  // Explicit qualification with the scope operator (5.1) suppresses the
223  // virtual call mechanism.
224  //
225  // We also don't emit a virtual call if the base expression has a record type
226  // because then we know what the type is.
227  bool UseVirtualCall = CanUseVirtualCall && !DevirtualizedMethod;
228  llvm::Value *Callee;
229 
230  if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(MD)) {
231  assert(CE->arg_begin() == CE->arg_end() &&
232  "Destructor shouldn't have explicit parameters");
233  assert(ReturnValue.isNull() && "Destructor shouldn't have return value");
234  if (UseVirtualCall) {
236  *this, Dtor, Dtor_Complete, This, cast<CXXMemberCallExpr>(CE));
237  } else {
238  if (getLangOpts().AppleKext && MD->isVirtual() && HasQualifier)
239  Callee = BuildAppleKextVirtualCall(MD, Qualifier, Ty);
240  else if (!DevirtualizedMethod)
241  Callee =
243  else {
244  const CXXDestructorDecl *DDtor =
245  cast<CXXDestructorDecl>(DevirtualizedMethod);
246  Callee = CGM.GetAddrOfFunction(GlobalDecl(DDtor, Dtor_Complete), Ty);
247  }
248  EmitCXXMemberOrOperatorCall(MD, Callee, ReturnValue, This,
249  /*ImplicitParam=*/nullptr, QualType(), CE);
250  }
251  return RValue::get(nullptr);
252  }
253 
254  if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
255  Callee = CGM.GetAddrOfFunction(GlobalDecl(Ctor, Ctor_Complete), Ty);
256  } else if (UseVirtualCall) {
257  Callee = CGM.getCXXABI().getVirtualFunctionPointer(*this, MD, This, Ty,
258  CE->getLocStart());
259  } else {
260  if (SanOpts.has(SanitizerKind::CFINVCall) &&
261  MD->getParent()->isDynamicClass()) {
262  llvm::Value *VTable = GetVTablePtr(This, Int8PtrTy);
264  }
265 
266  if (getLangOpts().AppleKext && MD->isVirtual() && HasQualifier)
267  Callee = BuildAppleKextVirtualCall(MD, Qualifier, Ty);
268  else if (!DevirtualizedMethod)
269  Callee = CGM.GetAddrOfFunction(MD, Ty);
270  else {
271  Callee = CGM.GetAddrOfFunction(DevirtualizedMethod, Ty);
272  }
273  }
274 
275  if (MD->isVirtual()) {
277  *this, MD, This, UseVirtualCall);
278  }
279 
280  return EmitCXXMemberOrOperatorCall(MD, Callee, ReturnValue, This,
281  /*ImplicitParam=*/nullptr, QualType(), CE);
282 }
283 
284 RValue
286  ReturnValueSlot ReturnValue) {
287  const BinaryOperator *BO =
288  cast<BinaryOperator>(E->getCallee()->IgnoreParens());
289  const Expr *BaseExpr = BO->getLHS();
290  const Expr *MemFnExpr = BO->getRHS();
291 
292  const MemberPointerType *MPT =
293  MemFnExpr->getType()->castAs<MemberPointerType>();
294 
295  const FunctionProtoType *FPT =
297  const CXXRecordDecl *RD =
298  cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
299 
300  // Get the member function pointer.
301  llvm::Value *MemFnPtr = EmitScalarExpr(MemFnExpr);
302 
303  // Emit the 'this' pointer.
304  llvm::Value *This;
305 
306  if (BO->getOpcode() == BO_PtrMemI)
307  This = EmitScalarExpr(BaseExpr);
308  else
309  This = EmitLValue(BaseExpr).getAddress();
310 
312  QualType(MPT->getClass(), 0));
313 
314  // Ask the ABI to load the callee. Note that This is modified.
315  llvm::Value *Callee =
316  CGM.getCXXABI().EmitLoadOfMemberFunctionPointer(*this, BO, This, MemFnPtr, MPT);
317 
318  CallArgList Args;
319 
320  QualType ThisType =
321  getContext().getPointerType(getContext().getTagDeclType(RD));
322 
323  // Push the this ptr.
324  Args.add(RValue::get(This), ThisType);
325 
326  RequiredArgs required = RequiredArgs::forPrototypePlus(FPT, 1);
327 
328  // And the rest of the call args
329  EmitCallArgs(Args, FPT, E->arg_begin(), E->arg_end(), E->getDirectCallee());
330  return EmitCall(CGM.getTypes().arrangeCXXMethodCall(Args, FPT, required),
331  Callee, ReturnValue, Args);
332 }
333 
334 RValue
336  const CXXMethodDecl *MD,
337  ReturnValueSlot ReturnValue) {
338  assert(MD->isInstance() &&
339  "Trying to emit a member call expr on a static method!");
341  E, MD, ReturnValue, /*HasQualifier=*/false, /*Qualifier=*/nullptr,
342  /*IsArrow=*/false, E->getArg(0));
343 }
344 
346  ReturnValueSlot ReturnValue) {
347  return CGM.getCUDARuntime().EmitCUDAKernelCallExpr(*this, E, ReturnValue);
348 }
349 
351  llvm::Value *DestPtr,
352  const CXXRecordDecl *Base) {
353  if (Base->isEmpty())
354  return;
355 
356  DestPtr = CGF.EmitCastToVoidPtr(DestPtr);
357 
358  const ASTRecordLayout &Layout = CGF.getContext().getASTRecordLayout(Base);
359  CharUnits Size = Layout.getNonVirtualSize();
360  CharUnits Align = Layout.getNonVirtualAlignment();
361 
362  llvm::Value *SizeVal = CGF.CGM.getSize(Size);
363 
364  // If the type contains a pointer to data member we can't memset it to zero.
365  // Instead, create a null constant and copy it to the destination.
366  // TODO: there are other patterns besides zero that we can usefully memset,
367  // like -1, which happens to be the pattern used by member-pointers.
368  // TODO: isZeroInitializable can be over-conservative in the case where a
369  // virtual base contains a member pointer.
370  if (!CGF.CGM.getTypes().isZeroInitializable(Base)) {
371  llvm::Constant *NullConstant = CGF.CGM.EmitNullConstantForBase(Base);
372 
373  llvm::GlobalVariable *NullVariable =
374  new llvm::GlobalVariable(CGF.CGM.getModule(), NullConstant->getType(),
375  /*isConstant=*/true,
376  llvm::GlobalVariable::PrivateLinkage,
377  NullConstant, Twine());
378  NullVariable->setAlignment(Align.getQuantity());
379  llvm::Value *SrcPtr = CGF.EmitCastToVoidPtr(NullVariable);
380 
381  // Get and call the appropriate llvm.memcpy overload.
382  CGF.Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, Align.getQuantity());
383  return;
384  }
385 
386  // Otherwise, just memset the whole thing to zero. This is legal
387  // because in LLVM, all default initializers (other than the ones we just
388  // handled above) are guaranteed to have a bit pattern of all zeros.
389  CGF.Builder.CreateMemSet(DestPtr, CGF.Builder.getInt8(0), SizeVal,
390  Align.getQuantity());
391 }
392 
393 void
395  AggValueSlot Dest) {
396  assert(!Dest.isIgnored() && "Must have a destination!");
397  const CXXConstructorDecl *CD = E->getConstructor();
398 
399  // If we require zero initialization before (or instead of) calling the
400  // constructor, as can be the case with a non-user-provided default
401  // constructor, emit the zero initialization now, unless destination is
402  // already zeroed.
403  if (E->requiresZeroInitialization() && !Dest.isZeroed()) {
404  switch (E->getConstructionKind()) {
407  EmitNullInitialization(Dest.getAddr(), E->getType());
408  break;
411  EmitNullBaseClassInitialization(*this, Dest.getAddr(), CD->getParent());
412  break;
413  }
414  }
415 
416  // If this is a call to a trivial default constructor, do nothing.
417  if (CD->isTrivial() && CD->isDefaultConstructor())
418  return;
419 
420  // Elide the constructor if we're constructing from a temporary.
421  // The temporary check is required because Sema sets this on NRVO
422  // returns.
423  if (getLangOpts().ElideConstructors && E->isElidable()) {
424  assert(getContext().hasSameUnqualifiedType(E->getType(),
425  E->getArg(0)->getType()));
426  if (E->getArg(0)->isTemporaryObject(getContext(), CD->getParent())) {
427  EmitAggExpr(E->getArg(0), Dest);
428  return;
429  }
430  }
431 
432  if (const ConstantArrayType *arrayType
434  EmitCXXAggrConstructorCall(CD, arrayType, Dest.getAddr(), E);
435  } else {
437  bool ForVirtualBase = false;
438  bool Delegating = false;
439 
440  switch (E->getConstructionKind()) {
442  // We should be emitting a constructor; GlobalDecl will assert this
443  Type = CurGD.getCtorType();
444  Delegating = true;
445  break;
446 
448  Type = Ctor_Complete;
449  break;
450 
452  ForVirtualBase = true;
453  // fall-through
454 
456  Type = Ctor_Base;
457  }
458 
459  // Call the constructor.
460  EmitCXXConstructorCall(CD, Type, ForVirtualBase, Delegating, Dest.getAddr(),
461  E);
462  }
463 }
464 
465 void
467  llvm::Value *Src,
468  const Expr *Exp) {
469  if (const ExprWithCleanups *E = dyn_cast<ExprWithCleanups>(Exp))
470  Exp = E->getSubExpr();
471  assert(isa<CXXConstructExpr>(Exp) &&
472  "EmitSynthesizedCXXCopyCtor - unknown copy ctor expr");
473  const CXXConstructExpr* E = cast<CXXConstructExpr>(Exp);
474  const CXXConstructorDecl *CD = E->getConstructor();
475  RunCleanupsScope Scope(*this);
476 
477  // If we require zero initialization before (or instead of) calling the
478  // constructor, as can be the case with a non-user-provided default
479  // constructor, emit the zero initialization now.
480  // FIXME. Do I still need this for a copy ctor synthesis?
482  EmitNullInitialization(Dest, E->getType());
483 
484  assert(!getContext().getAsConstantArrayType(E->getType())
485  && "EmitSynthesizedCXXCopyCtor - Copied-in Array");
486  EmitSynthesizedCXXCopyCtorCall(CD, Dest, Src, E);
487 }
488 
490  const CXXNewExpr *E) {
491  if (!E->isArray())
492  return CharUnits::Zero();
493 
494  // No cookie is required if the operator new[] being used is the
495  // reserved placement operator new[].
497  return CharUnits::Zero();
498 
499  return CGF.CGM.getCXXABI().GetArrayCookieSize(E);
500 }
501 
503  const CXXNewExpr *e,
504  unsigned minElements,
505  llvm::Value *&numElements,
506  llvm::Value *&sizeWithoutCookie) {
508 
509  if (!e->isArray()) {
510  CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type);
511  sizeWithoutCookie
512  = llvm::ConstantInt::get(CGF.SizeTy, typeSize.getQuantity());
513  return sizeWithoutCookie;
514  }
515 
516  // The width of size_t.
517  unsigned sizeWidth = CGF.SizeTy->getBitWidth();
518 
519  // Figure out the cookie size.
520  llvm::APInt cookieSize(sizeWidth,
521  CalculateCookiePadding(CGF, e).getQuantity());
522 
523  // Emit the array size expression.
524  // We multiply the size of all dimensions for NumElements.
525  // e.g for 'int[2][3]', ElemType is 'int' and NumElements is 6.
526  numElements = CGF.EmitScalarExpr(e->getArraySize());
527  assert(isa<llvm::IntegerType>(numElements->getType()));
528 
529  // The number of elements can be have an arbitrary integer type;
530  // essentially, we need to multiply it by a constant factor, add a
531  // cookie size, and verify that the result is representable as a
532  // size_t. That's just a gloss, though, and it's wrong in one
533  // important way: if the count is negative, it's an error even if
534  // the cookie size would bring the total size >= 0.
535  bool isSigned
537  llvm::IntegerType *numElementsType
538  = cast<llvm::IntegerType>(numElements->getType());
539  unsigned numElementsWidth = numElementsType->getBitWidth();
540 
541  // Compute the constant factor.
542  llvm::APInt arraySizeMultiplier(sizeWidth, 1);
543  while (const ConstantArrayType *CAT
544  = CGF.getContext().getAsConstantArrayType(type)) {
545  type = CAT->getElementType();
546  arraySizeMultiplier *= CAT->getSize();
547  }
548 
549  CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type);
550  llvm::APInt typeSizeMultiplier(sizeWidth, typeSize.getQuantity());
551  typeSizeMultiplier *= arraySizeMultiplier;
552 
553  // This will be a size_t.
554  llvm::Value *size;
555 
556  // If someone is doing 'new int[42]' there is no need to do a dynamic check.
557  // Don't bloat the -O0 code.
558  if (llvm::ConstantInt *numElementsC =
559  dyn_cast<llvm::ConstantInt>(numElements)) {
560  const llvm::APInt &count = numElementsC->getValue();
561 
562  bool hasAnyOverflow = false;
563 
564  // If 'count' was a negative number, it's an overflow.
565  if (isSigned && count.isNegative())
566  hasAnyOverflow = true;
567 
568  // We want to do all this arithmetic in size_t. If numElements is
569  // wider than that, check whether it's already too big, and if so,
570  // overflow.
571  else if (numElementsWidth > sizeWidth &&
572  numElementsWidth - sizeWidth > count.countLeadingZeros())
573  hasAnyOverflow = true;
574 
575  // Okay, compute a count at the right width.
576  llvm::APInt adjustedCount = count.zextOrTrunc(sizeWidth);
577 
578  // If there is a brace-initializer, we cannot allocate fewer elements than
579  // there are initializers. If we do, that's treated like an overflow.
580  if (adjustedCount.ult(minElements))
581  hasAnyOverflow = true;
582 
583  // Scale numElements by that. This might overflow, but we don't
584  // care because it only overflows if allocationSize does, too, and
585  // if that overflows then we shouldn't use this.
586  numElements = llvm::ConstantInt::get(CGF.SizeTy,
587  adjustedCount * arraySizeMultiplier);
588 
589  // Compute the size before cookie, and track whether it overflowed.
590  bool overflow;
591  llvm::APInt allocationSize
592  = adjustedCount.umul_ov(typeSizeMultiplier, overflow);
593  hasAnyOverflow |= overflow;
594 
595  // Add in the cookie, and check whether it's overflowed.
596  if (cookieSize != 0) {
597  // Save the current size without a cookie. This shouldn't be
598  // used if there was overflow.
599  sizeWithoutCookie = llvm::ConstantInt::get(CGF.SizeTy, allocationSize);
600 
601  allocationSize = allocationSize.uadd_ov(cookieSize, overflow);
602  hasAnyOverflow |= overflow;
603  }
604 
605  // On overflow, produce a -1 so operator new will fail.
606  if (hasAnyOverflow) {
607  size = llvm::Constant::getAllOnesValue(CGF.SizeTy);
608  } else {
609  size = llvm::ConstantInt::get(CGF.SizeTy, allocationSize);
610  }
611 
612  // Otherwise, we might need to use the overflow intrinsics.
613  } else {
614  // There are up to five conditions we need to test for:
615  // 1) if isSigned, we need to check whether numElements is negative;
616  // 2) if numElementsWidth > sizeWidth, we need to check whether
617  // numElements is larger than something representable in size_t;
618  // 3) if minElements > 0, we need to check whether numElements is smaller
619  // than that.
620  // 4) we need to compute
621  // sizeWithoutCookie := numElements * typeSizeMultiplier
622  // and check whether it overflows; and
623  // 5) if we need a cookie, we need to compute
624  // size := sizeWithoutCookie + cookieSize
625  // and check whether it overflows.
626 
627  llvm::Value *hasOverflow = nullptr;
628 
629  // If numElementsWidth > sizeWidth, then one way or another, we're
630  // going to have to do a comparison for (2), and this happens to
631  // take care of (1), too.
632  if (numElementsWidth > sizeWidth) {
633  llvm::APInt threshold(numElementsWidth, 1);
634  threshold <<= sizeWidth;
635 
636  llvm::Value *thresholdV
637  = llvm::ConstantInt::get(numElementsType, threshold);
638 
639  hasOverflow = CGF.Builder.CreateICmpUGE(numElements, thresholdV);
640  numElements = CGF.Builder.CreateTrunc(numElements, CGF.SizeTy);
641 
642  // Otherwise, if we're signed, we want to sext up to size_t.
643  } else if (isSigned) {
644  if (numElementsWidth < sizeWidth)
645  numElements = CGF.Builder.CreateSExt(numElements, CGF.SizeTy);
646 
647  // If there's a non-1 type size multiplier, then we can do the
648  // signedness check at the same time as we do the multiply
649  // because a negative number times anything will cause an
650  // unsigned overflow. Otherwise, we have to do it here. But at least
651  // in this case, we can subsume the >= minElements check.
652  if (typeSizeMultiplier == 1)
653  hasOverflow = CGF.Builder.CreateICmpSLT(numElements,
654  llvm::ConstantInt::get(CGF.SizeTy, minElements));
655 
656  // Otherwise, zext up to size_t if necessary.
657  } else if (numElementsWidth < sizeWidth) {
658  numElements = CGF.Builder.CreateZExt(numElements, CGF.SizeTy);
659  }
660 
661  assert(numElements->getType() == CGF.SizeTy);
662 
663  if (minElements) {
664  // Don't allow allocation of fewer elements than we have initializers.
665  if (!hasOverflow) {
666  hasOverflow = CGF.Builder.CreateICmpULT(numElements,
667  llvm::ConstantInt::get(CGF.SizeTy, minElements));
668  } else if (numElementsWidth > sizeWidth) {
669  // The other existing overflow subsumes this check.
670  // We do an unsigned comparison, since any signed value < -1 is
671  // taken care of either above or below.
672  hasOverflow = CGF.Builder.CreateOr(hasOverflow,
673  CGF.Builder.CreateICmpULT(numElements,
674  llvm::ConstantInt::get(CGF.SizeTy, minElements)));
675  }
676  }
677 
678  size = numElements;
679 
680  // Multiply by the type size if necessary. This multiplier
681  // includes all the factors for nested arrays.
682  //
683  // This step also causes numElements to be scaled up by the
684  // nested-array factor if necessary. Overflow on this computation
685  // can be ignored because the result shouldn't be used if
686  // allocation fails.
687  if (typeSizeMultiplier != 1) {
688  llvm::Value *umul_with_overflow
689  = CGF.CGM.getIntrinsic(llvm::Intrinsic::umul_with_overflow, CGF.SizeTy);
690 
691  llvm::Value *tsmV =
692  llvm::ConstantInt::get(CGF.SizeTy, typeSizeMultiplier);
693  llvm::Value *result =
694  CGF.Builder.CreateCall(umul_with_overflow, {size, tsmV});
695 
696  llvm::Value *overflowed = CGF.Builder.CreateExtractValue(result, 1);
697  if (hasOverflow)
698  hasOverflow = CGF.Builder.CreateOr(hasOverflow, overflowed);
699  else
700  hasOverflow = overflowed;
701 
702  size = CGF.Builder.CreateExtractValue(result, 0);
703 
704  // Also scale up numElements by the array size multiplier.
705  if (arraySizeMultiplier != 1) {
706  // If the base element type size is 1, then we can re-use the
707  // multiply we just did.
708  if (typeSize.isOne()) {
709  assert(arraySizeMultiplier == typeSizeMultiplier);
710  numElements = size;
711 
712  // Otherwise we need a separate multiply.
713  } else {
714  llvm::Value *asmV =
715  llvm::ConstantInt::get(CGF.SizeTy, arraySizeMultiplier);
716  numElements = CGF.Builder.CreateMul(numElements, asmV);
717  }
718  }
719  } else {
720  // numElements doesn't need to be scaled.
721  assert(arraySizeMultiplier == 1);
722  }
723 
724  // Add in the cookie size if necessary.
725  if (cookieSize != 0) {
726  sizeWithoutCookie = size;
727 
728  llvm::Value *uadd_with_overflow
729  = CGF.CGM.getIntrinsic(llvm::Intrinsic::uadd_with_overflow, CGF.SizeTy);
730 
731  llvm::Value *cookieSizeV = llvm::ConstantInt::get(CGF.SizeTy, cookieSize);
732  llvm::Value *result =
733  CGF.Builder.CreateCall(uadd_with_overflow, {size, cookieSizeV});
734 
735  llvm::Value *overflowed = CGF.Builder.CreateExtractValue(result, 1);
736  if (hasOverflow)
737  hasOverflow = CGF.Builder.CreateOr(hasOverflow, overflowed);
738  else
739  hasOverflow = overflowed;
740 
741  size = CGF.Builder.CreateExtractValue(result, 0);
742  }
743 
744  // If we had any possibility of dynamic overflow, make a select to
745  // overwrite 'size' with an all-ones value, which should cause
746  // operator new to throw.
747  if (hasOverflow)
748  size = CGF.Builder.CreateSelect(hasOverflow,
749  llvm::Constant::getAllOnesValue(CGF.SizeTy),
750  size);
751  }
752 
753  if (cookieSize == 0)
754  sizeWithoutCookie = size;
755  else
756  assert(sizeWithoutCookie && "didn't set sizeWithoutCookie?");
757 
758  return size;
759 }
760 
761 static void StoreAnyExprIntoOneUnit(CodeGenFunction &CGF, const Expr *Init,
762  QualType AllocType, llvm::Value *NewPtr) {
763  // FIXME: Refactor with EmitExprAsInit.
764  CharUnits Alignment = CGF.getContext().getTypeAlignInChars(AllocType);
765  switch (CGF.getEvaluationKind(AllocType)) {
766  case TEK_Scalar:
767  CGF.EmitScalarInit(Init, nullptr,
768  CGF.MakeAddrLValue(NewPtr, AllocType, Alignment), false);
769  return;
770  case TEK_Complex:
771  CGF.EmitComplexExprIntoLValue(Init, CGF.MakeAddrLValue(NewPtr, AllocType,
772  Alignment),
773  /*isInit*/ true);
774  return;
775  case TEK_Aggregate: {
776  AggValueSlot Slot
777  = AggValueSlot::forAddr(NewPtr, Alignment, AllocType.getQualifiers(),
781  CGF.EmitAggExpr(Init, Slot);
782  return;
783  }
784  }
785  llvm_unreachable("bad evaluation kind");
786 }
787 
789  const CXXNewExpr *E, QualType ElementType, llvm::Type *ElementTy,
790  llvm::Value *BeginPtr, llvm::Value *NumElements,
791  llvm::Value *AllocSizeWithoutCookie) {
792  // If we have a type with trivial initialization and no initializer,
793  // there's nothing to do.
794  if (!E->hasInitializer())
795  return;
796 
797  llvm::Value *CurPtr = BeginPtr;
798 
799  unsigned InitListElements = 0;
800 
801  const Expr *Init = E->getInitializer();
802  llvm::AllocaInst *EndOfInit = nullptr;
803  QualType::DestructionKind DtorKind = ElementType.isDestructedType();
805  llvm::Instruction *CleanupDominator = nullptr;
806 
807  // If the initializer is an initializer list, first do the explicit elements.
808  if (const InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
809  InitListElements = ILE->getNumInits();
810 
811  // If this is a multi-dimensional array new, we will initialize multiple
812  // elements with each init list element.
813  QualType AllocType = E->getAllocatedType();
814  if (const ConstantArrayType *CAT = dyn_cast_or_null<ConstantArrayType>(
815  AllocType->getAsArrayTypeUnsafe())) {
816  unsigned AS = CurPtr->getType()->getPointerAddressSpace();
817  ElementTy = ConvertTypeForMem(AllocType);
818  llvm::Type *AllocPtrTy = ElementTy->getPointerTo(AS);
819  CurPtr = Builder.CreateBitCast(CurPtr, AllocPtrTy);
820  InitListElements *= getContext().getConstantArrayElementCount(CAT);
821  }
822 
823  // Enter a partial-destruction Cleanup if necessary.
824  if (needsEHCleanup(DtorKind)) {
825  // In principle we could tell the Cleanup where we are more
826  // directly, but the control flow can get so varied here that it
827  // would actually be quite complex. Therefore we go through an
828  // alloca.
829  EndOfInit = CreateTempAlloca(BeginPtr->getType(), "array.init.end");
830  CleanupDominator = Builder.CreateStore(BeginPtr, EndOfInit);
831  pushIrregularPartialArrayCleanup(BeginPtr, EndOfInit, ElementType,
832  getDestroyer(DtorKind));
833  Cleanup = EHStack.stable_begin();
834  }
835 
836  for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i) {
837  // Tell the cleanup that it needs to destroy up to this
838  // element. TODO: some of these stores can be trivially
839  // observed to be unnecessary.
840  if (EndOfInit)
841  Builder.CreateStore(Builder.CreateBitCast(CurPtr, BeginPtr->getType()),
842  EndOfInit);
843  // FIXME: If the last initializer is an incomplete initializer list for
844  // an array, and we have an array filler, we can fold together the two
845  // initialization loops.
846  StoreAnyExprIntoOneUnit(*this, ILE->getInit(i),
847  ILE->getInit(i)->getType(), CurPtr);
848  CurPtr = Builder.CreateConstInBoundsGEP1_32(ElementTy, CurPtr, 1,
849  "array.exp.next");
850  }
851 
852  // The remaining elements are filled with the array filler expression.
853  Init = ILE->getArrayFiller();
854 
855  // Extract the initializer for the individual array elements by pulling
856  // out the array filler from all the nested initializer lists. This avoids
857  // generating a nested loop for the initialization.
858  while (Init && Init->getType()->isConstantArrayType()) {
859  auto *SubILE = dyn_cast<InitListExpr>(Init);
860  if (!SubILE)
861  break;
862  assert(SubILE->getNumInits() == 0 && "explicit inits in array filler?");
863  Init = SubILE->getArrayFiller();
864  }
865 
866  // Switch back to initializing one base element at a time.
867  CurPtr = Builder.CreateBitCast(CurPtr, BeginPtr->getType());
868  }
869 
870  // Attempt to perform zero-initialization using memset.
871  auto TryMemsetInitialization = [&]() -> bool {
872  // FIXME: If the type is a pointer-to-data-member under the Itanium ABI,
873  // we can initialize with a memset to -1.
874  if (!CGM.getTypes().isZeroInitializable(ElementType))
875  return false;
876 
877  // Optimization: since zero initialization will just set the memory
878  // to all zeroes, generate a single memset to do it in one shot.
879 
880  // Subtract out the size of any elements we've already initialized.
881  auto *RemainingSize = AllocSizeWithoutCookie;
882  if (InitListElements) {
883  // We know this can't overflow; we check this when doing the allocation.
884  auto *InitializedSize = llvm::ConstantInt::get(
885  RemainingSize->getType(),
886  getContext().getTypeSizeInChars(ElementType).getQuantity() *
887  InitListElements);
888  RemainingSize = Builder.CreateSub(RemainingSize, InitializedSize);
889  }
890 
891  // Create the memset.
892  CharUnits Alignment = getContext().getTypeAlignInChars(ElementType);
893  Builder.CreateMemSet(CurPtr, Builder.getInt8(0), RemainingSize,
894  Alignment.getQuantity(), false);
895  return true;
896  };
897 
898  // If all elements have already been initialized, skip any further
899  // initialization.
900  llvm::ConstantInt *ConstNum = dyn_cast<llvm::ConstantInt>(NumElements);
901  if (ConstNum && ConstNum->getZExtValue() <= InitListElements) {
902  // If there was a Cleanup, deactivate it.
903  if (CleanupDominator)
904  DeactivateCleanupBlock(Cleanup, CleanupDominator);
905  return;
906  }
907 
908  assert(Init && "have trailing elements to initialize but no initializer");
909 
910  // If this is a constructor call, try to optimize it out, and failing that
911  // emit a single loop to initialize all remaining elements.
912  if (const CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init)) {
913  CXXConstructorDecl *Ctor = CCE->getConstructor();
914  if (Ctor->isTrivial()) {
915  // If new expression did not specify value-initialization, then there
916  // is no initialization.
917  if (!CCE->requiresZeroInitialization() || Ctor->getParent()->isEmpty())
918  return;
919 
920  if (TryMemsetInitialization())
921  return;
922  }
923 
924  // Store the new Cleanup position for irregular Cleanups.
925  //
926  // FIXME: Share this cleanup with the constructor call emission rather than
927  // having it create a cleanup of its own.
928  if (EndOfInit) Builder.CreateStore(CurPtr, EndOfInit);
929 
930  // Emit a constructor call loop to initialize the remaining elements.
931  if (InitListElements)
932  NumElements = Builder.CreateSub(
933  NumElements,
934  llvm::ConstantInt::get(NumElements->getType(), InitListElements));
935  EmitCXXAggrConstructorCall(Ctor, NumElements, CurPtr, CCE,
936  CCE->requiresZeroInitialization());
937  return;
938  }
939 
940  // If this is value-initialization, we can usually use memset.
941  ImplicitValueInitExpr IVIE(ElementType);
942  if (isa<ImplicitValueInitExpr>(Init)) {
943  if (TryMemsetInitialization())
944  return;
945 
946  // Switch to an ImplicitValueInitExpr for the element type. This handles
947  // only one case: multidimensional array new of pointers to members. In
948  // all other cases, we already have an initializer for the array element.
949  Init = &IVIE;
950  }
951 
952  // At this point we should have found an initializer for the individual
953  // elements of the array.
954  assert(getContext().hasSameUnqualifiedType(ElementType, Init->getType()) &&
955  "got wrong type of element to initialize");
956 
957  // If we have an empty initializer list, we can usually use memset.
958  if (auto *ILE = dyn_cast<InitListExpr>(Init))
959  if (ILE->getNumInits() == 0 && TryMemsetInitialization())
960  return;
961 
962  // If we have a struct whose every field is value-initialized, we can
963  // usually use memset.
964  if (auto *ILE = dyn_cast<InitListExpr>(Init)) {
965  if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
966  if (RType->getDecl()->isStruct()) {
967  unsigned NumFields = 0;
968  for (auto *Field : RType->getDecl()->fields())
969  if (!Field->isUnnamedBitfield())
970  ++NumFields;
971  if (ILE->getNumInits() == NumFields)
972  for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i)
973  if (!isa<ImplicitValueInitExpr>(ILE->getInit(i)))
974  --NumFields;
975  if (ILE->getNumInits() == NumFields && TryMemsetInitialization())
976  return;
977  }
978  }
979  }
980 
981  // Create the loop blocks.
982  llvm::BasicBlock *EntryBB = Builder.GetInsertBlock();
983  llvm::BasicBlock *LoopBB = createBasicBlock("new.loop");
984  llvm::BasicBlock *ContBB = createBasicBlock("new.loop.end");
985 
986  // Find the end of the array, hoisted out of the loop.
987  llvm::Value *EndPtr =
988  Builder.CreateInBoundsGEP(BeginPtr, NumElements, "array.end");
989 
990  // If the number of elements isn't constant, we have to now check if there is
991  // anything left to initialize.
992  if (!ConstNum) {
993  llvm::Value *IsEmpty = Builder.CreateICmpEQ(CurPtr, EndPtr,
994  "array.isempty");
995  Builder.CreateCondBr(IsEmpty, ContBB, LoopBB);
996  }
997 
998  // Enter the loop.
999  EmitBlock(LoopBB);
1000 
1001  // Set up the current-element phi.
1002  llvm::PHINode *CurPtrPhi =
1003  Builder.CreatePHI(CurPtr->getType(), 2, "array.cur");
1004  CurPtrPhi->addIncoming(CurPtr, EntryBB);
1005  CurPtr = CurPtrPhi;
1006 
1007  // Store the new Cleanup position for irregular Cleanups.
1008  if (EndOfInit) Builder.CreateStore(CurPtr, EndOfInit);
1009 
1010  // Enter a partial-destruction Cleanup if necessary.
1011  if (!CleanupDominator && needsEHCleanup(DtorKind)) {
1012  pushRegularPartialArrayCleanup(BeginPtr, CurPtr, ElementType,
1013  getDestroyer(DtorKind));
1014  Cleanup = EHStack.stable_begin();
1015  CleanupDominator = Builder.CreateUnreachable();
1016  }
1017 
1018  // Emit the initializer into this element.
1019  StoreAnyExprIntoOneUnit(*this, Init, Init->getType(), CurPtr);
1020 
1021  // Leave the Cleanup if we entered one.
1022  if (CleanupDominator) {
1023  DeactivateCleanupBlock(Cleanup, CleanupDominator);
1024  CleanupDominator->eraseFromParent();
1025  }
1026 
1027  // Advance to the next element by adjusting the pointer type as necessary.
1028  llvm::Value *NextPtr =
1029  Builder.CreateConstInBoundsGEP1_32(ElementTy, CurPtr, 1, "array.next");
1030 
1031  // Check whether we've gotten to the end of the array and, if so,
1032  // exit the loop.
1033  llvm::Value *IsEnd = Builder.CreateICmpEQ(NextPtr, EndPtr, "array.atend");
1034  Builder.CreateCondBr(IsEnd, ContBB, LoopBB);
1035  CurPtrPhi->addIncoming(NextPtr, Builder.GetInsertBlock());
1036 
1037  EmitBlock(ContBB);
1038 }
1039 
1040 static void EmitNewInitializer(CodeGenFunction &CGF, const CXXNewExpr *E,
1041  QualType ElementType, llvm::Type *ElementTy,
1042  llvm::Value *NewPtr, llvm::Value *NumElements,
1043  llvm::Value *AllocSizeWithoutCookie) {
1044  ApplyDebugLocation DL(CGF, E);
1045  if (E->isArray())
1046  CGF.EmitNewArrayInitializer(E, ElementType, ElementTy, NewPtr, NumElements,
1047  AllocSizeWithoutCookie);
1048  else if (const Expr *Init = E->getInitializer())
1049  StoreAnyExprIntoOneUnit(CGF, Init, E->getAllocatedType(), NewPtr);
1050 }
1051 
1052 /// Emit a call to an operator new or operator delete function, as implicitly
1053 /// created by new-expressions and delete-expressions.
1055  const FunctionDecl *Callee,
1056  const FunctionProtoType *CalleeType,
1057  const CallArgList &Args) {
1058  llvm::Instruction *CallOrInvoke;
1059  llvm::Value *CalleeAddr = CGF.CGM.GetAddrOfFunction(Callee);
1060  RValue RV =
1062  Args, CalleeType, /*chainCall=*/false),
1063  CalleeAddr, ReturnValueSlot(), Args, Callee, &CallOrInvoke);
1064 
1065  /// C++1y [expr.new]p10:
1066  /// [In a new-expression,] an implementation is allowed to omit a call
1067  /// to a replaceable global allocation function.
1068  ///
1069  /// We model such elidable calls with the 'builtin' attribute.
1070  llvm::Function *Fn = dyn_cast<llvm::Function>(CalleeAddr);
1071  if (Callee->isReplaceableGlobalAllocationFunction() &&
1072  Fn && Fn->hasFnAttribute(llvm::Attribute::NoBuiltin)) {
1073  // FIXME: Add addAttribute to CallSite.
1074  if (llvm::CallInst *CI = dyn_cast<llvm::CallInst>(CallOrInvoke))
1075  CI->addAttribute(llvm::AttributeSet::FunctionIndex,
1076  llvm::Attribute::Builtin);
1077  else if (llvm::InvokeInst *II = dyn_cast<llvm::InvokeInst>(CallOrInvoke))
1078  II->addAttribute(llvm::AttributeSet::FunctionIndex,
1079  llvm::Attribute::Builtin);
1080  else
1081  llvm_unreachable("unexpected kind of call instruction");
1082  }
1083 
1084  return RV;
1085 }
1086 
1088  const Expr *Arg,
1089  bool IsDelete) {
1090  CallArgList Args;
1091  const Stmt *ArgS = Arg;
1092  EmitCallArgs(Args, *Type->param_type_begin(),
1093  ConstExprIterator(&ArgS), ConstExprIterator(&ArgS + 1));
1094  // Find the allocation or deallocation function that we're calling.
1095  ASTContext &Ctx = getContext();
1096  DeclarationName Name = Ctx.DeclarationNames
1097  .getCXXOperatorName(IsDelete ? OO_Delete : OO_New);
1098  for (auto *Decl : Ctx.getTranslationUnitDecl()->lookup(Name))
1099  if (auto *FD = dyn_cast<FunctionDecl>(Decl))
1100  if (Ctx.hasSameType(FD->getType(), QualType(Type, 0)))
1101  return EmitNewDeleteCall(*this, cast<FunctionDecl>(Decl), Type, Args);
1102  llvm_unreachable("predeclared global operator new/delete is missing");
1103 }
1104 
1105 namespace {
1106  /// A cleanup to call the given 'operator delete' function upon
1107  /// abnormal exit from a new expression.
1108  class CallDeleteDuringNew : public EHScopeStack::Cleanup {
1109  size_t NumPlacementArgs;
1110  const FunctionDecl *OperatorDelete;
1111  llvm::Value *Ptr;
1112  llvm::Value *AllocSize;
1113 
1114  RValue *getPlacementArgs() { return reinterpret_cast<RValue*>(this+1); }
1115 
1116  public:
1117  static size_t getExtraSize(size_t NumPlacementArgs) {
1118  return NumPlacementArgs * sizeof(RValue);
1119  }
1120 
1121  CallDeleteDuringNew(size_t NumPlacementArgs,
1122  const FunctionDecl *OperatorDelete,
1123  llvm::Value *Ptr,
1124  llvm::Value *AllocSize)
1125  : NumPlacementArgs(NumPlacementArgs), OperatorDelete(OperatorDelete),
1126  Ptr(Ptr), AllocSize(AllocSize) {}
1127 
1128  void setPlacementArg(unsigned I, RValue Arg) {
1129  assert(I < NumPlacementArgs && "index out of range");
1130  getPlacementArgs()[I] = Arg;
1131  }
1132 
1133  void Emit(CodeGenFunction &CGF, Flags flags) override {
1134  const FunctionProtoType *FPT
1135  = OperatorDelete->getType()->getAs<FunctionProtoType>();
1136  assert(FPT->getNumParams() == NumPlacementArgs + 1 ||
1137  (FPT->getNumParams() == 2 && NumPlacementArgs == 0));
1138 
1139  CallArgList DeleteArgs;
1140 
1141  // The first argument is always a void*.
1143  DeleteArgs.add(RValue::get(Ptr), *AI++);
1144 
1145  // A member 'operator delete' can take an extra 'size_t' argument.
1146  if (FPT->getNumParams() == NumPlacementArgs + 2)
1147  DeleteArgs.add(RValue::get(AllocSize), *AI++);
1148 
1149  // Pass the rest of the arguments, which must match exactly.
1150  for (unsigned I = 0; I != NumPlacementArgs; ++I)
1151  DeleteArgs.add(getPlacementArgs()[I], *AI++);
1152 
1153  // Call 'operator delete'.
1154  EmitNewDeleteCall(CGF, OperatorDelete, FPT, DeleteArgs);
1155  }
1156  };
1157 
1158  /// A cleanup to call the given 'operator delete' function upon
1159  /// abnormal exit from a new expression when the new expression is
1160  /// conditional.
1161  class CallDeleteDuringConditionalNew : public EHScopeStack::Cleanup {
1162  size_t NumPlacementArgs;
1163  const FunctionDecl *OperatorDelete;
1166 
1167  DominatingValue<RValue>::saved_type *getPlacementArgs() {
1168  return reinterpret_cast<DominatingValue<RValue>::saved_type*>(this+1);
1169  }
1170 
1171  public:
1172  static size_t getExtraSize(size_t NumPlacementArgs) {
1173  return NumPlacementArgs * sizeof(DominatingValue<RValue>::saved_type);
1174  }
1175 
1176  CallDeleteDuringConditionalNew(size_t NumPlacementArgs,
1177  const FunctionDecl *OperatorDelete,
1180  : NumPlacementArgs(NumPlacementArgs), OperatorDelete(OperatorDelete),
1181  Ptr(Ptr), AllocSize(AllocSize) {}
1182 
1183  void setPlacementArg(unsigned I, DominatingValue<RValue>::saved_type Arg) {
1184  assert(I < NumPlacementArgs && "index out of range");
1185  getPlacementArgs()[I] = Arg;
1186  }
1187 
1188  void Emit(CodeGenFunction &CGF, Flags flags) override {
1189  const FunctionProtoType *FPT
1190  = OperatorDelete->getType()->getAs<FunctionProtoType>();
1191  assert(FPT->getNumParams() == NumPlacementArgs + 1 ||
1192  (FPT->getNumParams() == 2 && NumPlacementArgs == 0));
1193 
1194  CallArgList DeleteArgs;
1195 
1196  // The first argument is always a void*.
1198  DeleteArgs.add(Ptr.restore(CGF), *AI++);
1199 
1200  // A member 'operator delete' can take an extra 'size_t' argument.
1201  if (FPT->getNumParams() == NumPlacementArgs + 2) {
1202  RValue RV = AllocSize.restore(CGF);
1203  DeleteArgs.add(RV, *AI++);
1204  }
1205 
1206  // Pass the rest of the arguments, which must match exactly.
1207  for (unsigned I = 0; I != NumPlacementArgs; ++I) {
1208  RValue RV = getPlacementArgs()[I].restore(CGF);
1209  DeleteArgs.add(RV, *AI++);
1210  }
1211 
1212  // Call 'operator delete'.
1213  EmitNewDeleteCall(CGF, OperatorDelete, FPT, DeleteArgs);
1214  }
1215  };
1216 }
1217 
1218 /// Enter a cleanup to call 'operator delete' if the initializer in a
1219 /// new-expression throws.
1221  const CXXNewExpr *E,
1222  llvm::Value *NewPtr,
1223  llvm::Value *AllocSize,
1224  const CallArgList &NewArgs) {
1225  // If we're not inside a conditional branch, then the cleanup will
1226  // dominate and we can do the easier (and more efficient) thing.
1227  if (!CGF.isInConditionalBranch()) {
1228  CallDeleteDuringNew *Cleanup = CGF.EHStack
1229  .pushCleanupWithExtra<CallDeleteDuringNew>(EHCleanup,
1230  E->getNumPlacementArgs(),
1231  E->getOperatorDelete(),
1232  NewPtr, AllocSize);
1233  for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I)
1234  Cleanup->setPlacementArg(I, NewArgs[I+1].RV);
1235 
1236  return;
1237  }
1238 
1239  // Otherwise, we need to save all this stuff.
1242  DominatingValue<RValue>::saved_type SavedAllocSize =
1243  DominatingValue<RValue>::save(CGF, RValue::get(AllocSize));
1244 
1245  CallDeleteDuringConditionalNew *Cleanup = CGF.EHStack
1246  .pushCleanupWithExtra<CallDeleteDuringConditionalNew>(EHCleanup,
1247  E->getNumPlacementArgs(),
1248  E->getOperatorDelete(),
1249  SavedNewPtr,
1250  SavedAllocSize);
1251  for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I)
1252  Cleanup->setPlacementArg(I,
1253  DominatingValue<RValue>::save(CGF, NewArgs[I+1].RV));
1254 
1255  CGF.initFullExprCleanup();
1256 }
1257 
1259  // The element type being allocated.
1261 
1262  // 1. Build a call to the allocation function.
1263  FunctionDecl *allocator = E->getOperatorNew();
1264  const FunctionProtoType *allocatorType =
1265  allocator->getType()->castAs<FunctionProtoType>();
1266 
1267  CallArgList allocatorArgs;
1268 
1269  // The allocation size is the first argument.
1270  QualType sizeType = getContext().getSizeType();
1271 
1272  // If there is a brace-initializer, cannot allocate fewer elements than inits.
1273  unsigned minElements = 0;
1274  if (E->isArray() && E->hasInitializer()) {
1275  if (const InitListExpr *ILE = dyn_cast<InitListExpr>(E->getInitializer()))
1276  minElements = ILE->getNumInits();
1277  }
1278 
1279  llvm::Value *numElements = nullptr;
1280  llvm::Value *allocSizeWithoutCookie = nullptr;
1281  llvm::Value *allocSize =
1282  EmitCXXNewAllocSize(*this, E, minElements, numElements,
1283  allocSizeWithoutCookie);
1284 
1285  allocatorArgs.add(RValue::get(allocSize), sizeType);
1286 
1287  // We start at 1 here because the first argument (the allocation size)
1288  // has already been emitted.
1289  EmitCallArgs(allocatorArgs, allocatorType, E->placement_arg_begin(),
1290  E->placement_arg_end(), /* CalleeDecl */ nullptr,
1291  /*ParamsToSkip*/ 1);
1292 
1293  // Emit the allocation call. If the allocator is a global placement
1294  // operator, just "inline" it directly.
1295  RValue RV;
1296  if (allocator->isReservedGlobalPlacementOperator()) {
1297  assert(allocatorArgs.size() == 2);
1298  RV = allocatorArgs[1].RV;
1299  // TODO: kill any unnecessary computations done for the size
1300  // argument.
1301  } else {
1302  RV = EmitNewDeleteCall(*this, allocator, allocatorType, allocatorArgs);
1303  }
1304 
1305  // Emit a null check on the allocation result if the allocation
1306  // function is allowed to return null (because it has a non-throwing
1307  // exception spec or is the reserved placement new) and we have an
1308  // interesting initializer.
1309  bool nullCheck = E->shouldNullCheckAllocation(getContext()) &&
1310  (!allocType.isPODType(getContext()) || E->hasInitializer());
1311 
1312  llvm::BasicBlock *nullCheckBB = nullptr;
1313  llvm::BasicBlock *contBB = nullptr;
1314 
1315  llvm::Value *allocation = RV.getScalarVal();
1316  unsigned AS = allocation->getType()->getPointerAddressSpace();
1317 
1318  // The null-check means that the initializer is conditionally
1319  // evaluated.
1320  ConditionalEvaluation conditional(*this);
1321 
1322  if (nullCheck) {
1323  conditional.begin(*this);
1324 
1325  nullCheckBB = Builder.GetInsertBlock();
1326  llvm::BasicBlock *notNullBB = createBasicBlock("new.notnull");
1327  contBB = createBasicBlock("new.cont");
1328 
1329  llvm::Value *isNull = Builder.CreateIsNull(allocation, "new.isnull");
1330  Builder.CreateCondBr(isNull, contBB, notNullBB);
1331  EmitBlock(notNullBB);
1332  }
1333 
1334  // If there's an operator delete, enter a cleanup to call it if an
1335  // exception is thrown.
1336  EHScopeStack::stable_iterator operatorDeleteCleanup;
1337  llvm::Instruction *cleanupDominator = nullptr;
1338  if (E->getOperatorDelete() &&
1340  EnterNewDeleteCleanup(*this, E, allocation, allocSize, allocatorArgs);
1341  operatorDeleteCleanup = EHStack.stable_begin();
1342  cleanupDominator = Builder.CreateUnreachable();
1343  }
1344 
1345  assert((allocSize == allocSizeWithoutCookie) ==
1346  CalculateCookiePadding(*this, E).isZero());
1347  if (allocSize != allocSizeWithoutCookie) {
1348  assert(E->isArray());
1349  allocation = CGM.getCXXABI().InitializeArrayCookie(*this, allocation,
1350  numElements,
1351  E, allocType);
1352  }
1353 
1354  llvm::Type *elementTy = ConvertTypeForMem(allocType);
1355  llvm::Type *elementPtrTy = elementTy->getPointerTo(AS);
1356  llvm::Value *result = Builder.CreateBitCast(allocation, elementPtrTy);
1357 
1358  EmitNewInitializer(*this, E, allocType, elementTy, result, numElements,
1359  allocSizeWithoutCookie);
1360  if (E->isArray()) {
1361  // NewPtr is a pointer to the base element type. If we're
1362  // allocating an array of arrays, we'll need to cast back to the
1363  // array pointer type.
1364  llvm::Type *resultType = ConvertTypeForMem(E->getType());
1365  if (result->getType() != resultType)
1366  result = Builder.CreateBitCast(result, resultType);
1367  }
1368 
1369  // Deactivate the 'operator delete' cleanup if we finished
1370  // initialization.
1371  if (operatorDeleteCleanup.isValid()) {
1372  DeactivateCleanupBlock(operatorDeleteCleanup, cleanupDominator);
1373  cleanupDominator->eraseFromParent();
1374  }
1375 
1376  if (nullCheck) {
1377  conditional.end(*this);
1378 
1379  llvm::BasicBlock *notNullBB = Builder.GetInsertBlock();
1380  EmitBlock(contBB);
1381 
1382  llvm::PHINode *PHI = Builder.CreatePHI(result->getType(), 2);
1383  PHI->addIncoming(result, notNullBB);
1384  PHI->addIncoming(llvm::Constant::getNullValue(result->getType()),
1385  nullCheckBB);
1386 
1387  result = PHI;
1388  }
1389 
1390  return result;
1391 }
1392 
1394  llvm::Value *Ptr,
1395  QualType DeleteTy) {
1396  assert(DeleteFD->getOverloadedOperator() == OO_Delete);
1397 
1398  const FunctionProtoType *DeleteFTy =
1399  DeleteFD->getType()->getAs<FunctionProtoType>();
1400 
1401  CallArgList DeleteArgs;
1402 
1403  // Check if we need to pass the size to the delete operator.
1404  llvm::Value *Size = nullptr;
1405  QualType SizeTy;
1406  if (DeleteFTy->getNumParams() == 2) {
1407  SizeTy = DeleteFTy->getParamType(1);
1408  CharUnits DeleteTypeSize = getContext().getTypeSizeInChars(DeleteTy);
1409  Size = llvm::ConstantInt::get(ConvertType(SizeTy),
1410  DeleteTypeSize.getQuantity());
1411  }
1412 
1413  QualType ArgTy = DeleteFTy->getParamType(0);
1414  llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy));
1415  DeleteArgs.add(RValue::get(DeletePtr), ArgTy);
1416 
1417  if (Size)
1418  DeleteArgs.add(RValue::get(Size), SizeTy);
1419 
1420  // Emit the call to delete.
1421  EmitNewDeleteCall(*this, DeleteFD, DeleteFTy, DeleteArgs);
1422 }
1423 
1424 namespace {
1425  /// Calls the given 'operator delete' on a single object.
1426  struct CallObjectDelete : EHScopeStack::Cleanup {
1427  llvm::Value *Ptr;
1428  const FunctionDecl *OperatorDelete;
1429  QualType ElementType;
1430 
1431  CallObjectDelete(llvm::Value *Ptr,
1432  const FunctionDecl *OperatorDelete,
1433  QualType ElementType)
1434  : Ptr(Ptr), OperatorDelete(OperatorDelete), ElementType(ElementType) {}
1435 
1436  void Emit(CodeGenFunction &CGF, Flags flags) override {
1437  CGF.EmitDeleteCall(OperatorDelete, Ptr, ElementType);
1438  }
1439  };
1440 }
1441 
1442 void
1444  llvm::Value *CompletePtr,
1445  QualType ElementType) {
1446  EHStack.pushCleanup<CallObjectDelete>(NormalAndEHCleanup, CompletePtr,
1447  OperatorDelete, ElementType);
1448 }
1449 
1450 /// Emit the code for deleting a single object.
1452  const CXXDeleteExpr *DE,
1453  llvm::Value *Ptr,
1454  QualType ElementType) {
1455  // Find the destructor for the type, if applicable. If the
1456  // destructor is virtual, we'll just emit the vcall and return.
1457  const CXXDestructorDecl *Dtor = nullptr;
1458  if (const RecordType *RT = ElementType->getAs<RecordType>()) {
1459  CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1460  if (RD->hasDefinition() && !RD->hasTrivialDestructor()) {
1461  Dtor = RD->getDestructor();
1462 
1463  if (Dtor->isVirtual()) {
1464  CGF.CGM.getCXXABI().emitVirtualObjectDelete(CGF, DE, Ptr, ElementType,
1465  Dtor);
1466  return;
1467  }
1468  }
1469  }
1470 
1471  // Make sure that we call delete even if the dtor throws.
1472  // This doesn't have to a conditional cleanup because we're going
1473  // to pop it off in a second.
1474  const FunctionDecl *OperatorDelete = DE->getOperatorDelete();
1475  CGF.EHStack.pushCleanup<CallObjectDelete>(NormalAndEHCleanup,
1476  Ptr, OperatorDelete, ElementType);
1477 
1478  if (Dtor)
1480  /*ForVirtualBase=*/false,
1481  /*Delegating=*/false,
1482  Ptr);
1483  else if (CGF.getLangOpts().ObjCAutoRefCount &&
1484  ElementType->isObjCLifetimeType()) {
1485  switch (ElementType.getObjCLifetime()) {
1486  case Qualifiers::OCL_None:
1489  break;
1490 
1491  case Qualifiers::OCL_Strong: {
1492  // Load the pointer value.
1493  llvm::Value *PtrValue = CGF.Builder.CreateLoad(Ptr,
1494  ElementType.isVolatileQualified());
1495 
1496  CGF.EmitARCRelease(PtrValue, ARCPreciseLifetime);
1497  break;
1498  }
1499 
1500  case Qualifiers::OCL_Weak:
1501  CGF.EmitARCDestroyWeak(Ptr);
1502  break;
1503  }
1504  }
1505 
1506  CGF.PopCleanupBlock();
1507 }
1508 
1509 namespace {
1510  /// Calls the given 'operator delete' on an array of objects.
1511  struct CallArrayDelete : EHScopeStack::Cleanup {
1512  llvm::Value *Ptr;
1513  const FunctionDecl *OperatorDelete;
1514  llvm::Value *NumElements;
1515  QualType ElementType;
1516  CharUnits CookieSize;
1517 
1518  CallArrayDelete(llvm::Value *Ptr,
1519  const FunctionDecl *OperatorDelete,
1520  llvm::Value *NumElements,
1521  QualType ElementType,
1522  CharUnits CookieSize)
1523  : Ptr(Ptr), OperatorDelete(OperatorDelete), NumElements(NumElements),
1524  ElementType(ElementType), CookieSize(CookieSize) {}
1525 
1526  void Emit(CodeGenFunction &CGF, Flags flags) override {
1527  const FunctionProtoType *DeleteFTy =
1528  OperatorDelete->getType()->getAs<FunctionProtoType>();
1529  assert(DeleteFTy->getNumParams() == 1 || DeleteFTy->getNumParams() == 2);
1530 
1531  CallArgList Args;
1532 
1533  // Pass the pointer as the first argument.
1534  QualType VoidPtrTy = DeleteFTy->getParamType(0);
1535  llvm::Value *DeletePtr
1536  = CGF.Builder.CreateBitCast(Ptr, CGF.ConvertType(VoidPtrTy));
1537  Args.add(RValue::get(DeletePtr), VoidPtrTy);
1538 
1539  // Pass the original requested size as the second argument.
1540  if (DeleteFTy->getNumParams() == 2) {
1541  QualType size_t = DeleteFTy->getParamType(1);
1542  llvm::IntegerType *SizeTy
1543  = cast<llvm::IntegerType>(CGF.ConvertType(size_t));
1544 
1545  CharUnits ElementTypeSize =
1546  CGF.CGM.getContext().getTypeSizeInChars(ElementType);
1547 
1548  // The size of an element, multiplied by the number of elements.
1549  llvm::Value *Size
1550  = llvm::ConstantInt::get(SizeTy, ElementTypeSize.getQuantity());
1551  if (NumElements)
1552  Size = CGF.Builder.CreateMul(Size, NumElements);
1553 
1554  // Plus the size of the cookie if applicable.
1555  if (!CookieSize.isZero()) {
1556  llvm::Value *CookieSizeV
1557  = llvm::ConstantInt::get(SizeTy, CookieSize.getQuantity());
1558  Size = CGF.Builder.CreateAdd(Size, CookieSizeV);
1559  }
1560 
1561  Args.add(RValue::get(Size), size_t);
1562  }
1563 
1564  // Emit the call to delete.
1565  EmitNewDeleteCall(CGF, OperatorDelete, DeleteFTy, Args);
1566  }
1567  };
1568 }
1569 
1570 /// Emit the code for deleting an array of objects.
1572  const CXXDeleteExpr *E,
1573  llvm::Value *deletedPtr,
1574  QualType elementType) {
1575  llvm::Value *numElements = nullptr;
1576  llvm::Value *allocatedPtr = nullptr;
1577  CharUnits cookieSize;
1578  CGF.CGM.getCXXABI().ReadArrayCookie(CGF, deletedPtr, E, elementType,
1579  numElements, allocatedPtr, cookieSize);
1580 
1581  assert(allocatedPtr && "ReadArrayCookie didn't set allocated pointer");
1582 
1583  // Make sure that we call delete even if one of the dtors throws.
1584  const FunctionDecl *operatorDelete = E->getOperatorDelete();
1585  CGF.EHStack.pushCleanup<CallArrayDelete>(NormalAndEHCleanup,
1586  allocatedPtr, operatorDelete,
1587  numElements, elementType,
1588  cookieSize);
1589 
1590  // Destroy the elements.
1591  if (QualType::DestructionKind dtorKind = elementType.isDestructedType()) {
1592  assert(numElements && "no element count for a type with a destructor!");
1593 
1594  llvm::Value *arrayEnd =
1595  CGF.Builder.CreateInBoundsGEP(deletedPtr, numElements, "delete.end");
1596 
1597  // Note that it is legal to allocate a zero-length array, and we
1598  // can never fold the check away because the length should always
1599  // come from a cookie.
1600  CGF.emitArrayDestroy(deletedPtr, arrayEnd, elementType,
1601  CGF.getDestroyer(dtorKind),
1602  /*checkZeroLength*/ true,
1603  CGF.needsEHCleanup(dtorKind));
1604  }
1605 
1606  // Pop the cleanup block.
1607  CGF.PopCleanupBlock();
1608 }
1609 
1611  const Expr *Arg = E->getArgument();
1612  llvm::Value *Ptr = EmitScalarExpr(Arg);
1613 
1614  // Null check the pointer.
1615  llvm::BasicBlock *DeleteNotNull = createBasicBlock("delete.notnull");
1616  llvm::BasicBlock *DeleteEnd = createBasicBlock("delete.end");
1617 
1618  llvm::Value *IsNull = Builder.CreateIsNull(Ptr, "isnull");
1619 
1620  Builder.CreateCondBr(IsNull, DeleteEnd, DeleteNotNull);
1621  EmitBlock(DeleteNotNull);
1622 
1623  // We might be deleting a pointer to array. If so, GEP down to the
1624  // first non-array element.
1625  // (this assumes that A(*)[3][7] is converted to [3 x [7 x %A]]*)
1626  QualType DeleteTy = Arg->getType()->getAs<PointerType>()->getPointeeType();
1627  if (DeleteTy->isConstantArrayType()) {
1628  llvm::Value *Zero = Builder.getInt32(0);
1630 
1631  GEP.push_back(Zero); // point at the outermost array
1632 
1633  // For each layer of array type we're pointing at:
1634  while (const ConstantArrayType *Arr
1635  = getContext().getAsConstantArrayType(DeleteTy)) {
1636  // 1. Unpeel the array type.
1637  DeleteTy = Arr->getElementType();
1638 
1639  // 2. GEP to the first element of the array.
1640  GEP.push_back(Zero);
1641  }
1642 
1643  Ptr = Builder.CreateInBoundsGEP(Ptr, GEP, "del.first");
1644  }
1645 
1646  assert(ConvertTypeForMem(DeleteTy) ==
1647  cast<llvm::PointerType>(Ptr->getType())->getElementType());
1648 
1649  if (E->isArrayForm()) {
1650  EmitArrayDelete(*this, E, Ptr, DeleteTy);
1651  } else {
1652  EmitObjectDelete(*this, E, Ptr, DeleteTy);
1653  }
1654 
1655  EmitBlock(DeleteEnd);
1656 }
1657 
1658 static bool isGLValueFromPointerDeref(const Expr *E) {
1659  E = E->IgnoreParens();
1660 
1661  if (const auto *CE = dyn_cast<CastExpr>(E)) {
1662  if (!CE->getSubExpr()->isGLValue())
1663  return false;
1664  return isGLValueFromPointerDeref(CE->getSubExpr());
1665  }
1666 
1667  if (const auto *OVE = dyn_cast<OpaqueValueExpr>(E))
1668  return isGLValueFromPointerDeref(OVE->getSourceExpr());
1669 
1670  if (const auto *BO = dyn_cast<BinaryOperator>(E))
1671  if (BO->getOpcode() == BO_Comma)
1672  return isGLValueFromPointerDeref(BO->getRHS());
1673 
1674  if (const auto *ACO = dyn_cast<AbstractConditionalOperator>(E))
1675  return isGLValueFromPointerDeref(ACO->getTrueExpr()) ||
1676  isGLValueFromPointerDeref(ACO->getFalseExpr());
1677 
1678  // C++11 [expr.sub]p1:
1679  // The expression E1[E2] is identical (by definition) to *((E1)+(E2))
1680  if (isa<ArraySubscriptExpr>(E))
1681  return true;
1682 
1683  if (const auto *UO = dyn_cast<UnaryOperator>(E))
1684  if (UO->getOpcode() == UO_Deref)
1685  return true;
1686 
1687  return false;
1688 }
1689 
1691  llvm::Type *StdTypeInfoPtrTy) {
1692  // Get the vtable pointer.
1693  llvm::Value *ThisPtr = CGF.EmitLValue(E).getAddress();
1694 
1695  // C++ [expr.typeid]p2:
1696  // If the glvalue expression is obtained by applying the unary * operator to
1697  // a pointer and the pointer is a null pointer value, the typeid expression
1698  // throws the std::bad_typeid exception.
1699  //
1700  // However, this paragraph's intent is not clear. We choose a very generous
1701  // interpretation which implores us to consider comma operators, conditional
1702  // operators, parentheses and other such constructs.
1703  QualType SrcRecordTy = E->getType();
1705  isGLValueFromPointerDeref(E), SrcRecordTy)) {
1706  llvm::BasicBlock *BadTypeidBlock =
1707  CGF.createBasicBlock("typeid.bad_typeid");
1708  llvm::BasicBlock *EndBlock = CGF.createBasicBlock("typeid.end");
1709 
1710  llvm::Value *IsNull = CGF.Builder.CreateIsNull(ThisPtr);
1711  CGF.Builder.CreateCondBr(IsNull, BadTypeidBlock, EndBlock);
1712 
1713  CGF.EmitBlock(BadTypeidBlock);
1714  CGF.CGM.getCXXABI().EmitBadTypeidCall(CGF);
1715  CGF.EmitBlock(EndBlock);
1716  }
1717 
1718  return CGF.CGM.getCXXABI().EmitTypeid(CGF, SrcRecordTy, ThisPtr,
1719  StdTypeInfoPtrTy);
1720 }
1721 
1723  llvm::Type *StdTypeInfoPtrTy =
1724  ConvertType(E->getType())->getPointerTo();
1725 
1726  if (E->isTypeOperand()) {
1727  llvm::Constant *TypeInfo =
1729  return Builder.CreateBitCast(TypeInfo, StdTypeInfoPtrTy);
1730  }
1731 
1732  // C++ [expr.typeid]p2:
1733  // When typeid is applied to a glvalue expression whose type is a
1734  // polymorphic class type, the result refers to a std::type_info object
1735  // representing the type of the most derived object (that is, the dynamic
1736  // type) to which the glvalue refers.
1737  if (E->isPotentiallyEvaluated())
1738  return EmitTypeidFromVTable(*this, E->getExprOperand(),
1739  StdTypeInfoPtrTy);
1740 
1741  QualType OperandTy = E->getExprOperand()->getType();
1742  return Builder.CreateBitCast(CGM.GetAddrOfRTTIDescriptor(OperandTy),
1743  StdTypeInfoPtrTy);
1744 }
1745 
1747  QualType DestTy) {
1748  llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1749  if (DestTy->isPointerType())
1750  return llvm::Constant::getNullValue(DestLTy);
1751 
1752  /// C++ [expr.dynamic.cast]p9:
1753  /// A failed cast to reference type throws std::bad_cast
1754  if (!CGF.CGM.getCXXABI().EmitBadCastCall(CGF))
1755  return nullptr;
1756 
1757  CGF.EmitBlock(CGF.createBasicBlock("dynamic_cast.end"));
1758  return llvm::UndefValue::get(DestLTy);
1759 }
1760 
1762  const CXXDynamicCastExpr *DCE) {
1763  QualType DestTy = DCE->getTypeAsWritten();
1764 
1765  if (DCE->isAlwaysNull())
1766  if (llvm::Value *T = EmitDynamicCastToNull(*this, DestTy))
1767  return T;
1768 
1769  QualType SrcTy = DCE->getSubExpr()->getType();
1770 
1771  // C++ [expr.dynamic.cast]p7:
1772  // If T is "pointer to cv void," then the result is a pointer to the most
1773  // derived object pointed to by v.
1774  const PointerType *DestPTy = DestTy->getAs<PointerType>();
1775 
1776  bool isDynamicCastToVoid;
1777  QualType SrcRecordTy;
1778  QualType DestRecordTy;
1779  if (DestPTy) {
1780  isDynamicCastToVoid = DestPTy->getPointeeType()->isVoidType();
1781  SrcRecordTy = SrcTy->castAs<PointerType>()->getPointeeType();
1782  DestRecordTy = DestPTy->getPointeeType();
1783  } else {
1784  isDynamicCastToVoid = false;
1785  SrcRecordTy = SrcTy;
1786  DestRecordTy = DestTy->castAs<ReferenceType>()->getPointeeType();
1787  }
1788 
1789  assert(SrcRecordTy->isRecordType() && "source type must be a record type!");
1790 
1791  // C++ [expr.dynamic.cast]p4:
1792  // If the value of v is a null pointer value in the pointer case, the result
1793  // is the null pointer value of type T.
1794  bool ShouldNullCheckSrcValue =
1796  SrcRecordTy);
1797 
1798  llvm::BasicBlock *CastNull = nullptr;
1799  llvm::BasicBlock *CastNotNull = nullptr;
1800  llvm::BasicBlock *CastEnd = createBasicBlock("dynamic_cast.end");
1801 
1802  if (ShouldNullCheckSrcValue) {
1803  CastNull = createBasicBlock("dynamic_cast.null");
1804  CastNotNull = createBasicBlock("dynamic_cast.notnull");
1805 
1806  llvm::Value *IsNull = Builder.CreateIsNull(Value);
1807  Builder.CreateCondBr(IsNull, CastNull, CastNotNull);
1808  EmitBlock(CastNotNull);
1809  }
1810 
1811  if (isDynamicCastToVoid) {
1812  Value = CGM.getCXXABI().EmitDynamicCastToVoid(*this, Value, SrcRecordTy,
1813  DestTy);
1814  } else {
1815  assert(DestRecordTy->isRecordType() &&
1816  "destination type must be a record type!");
1817  Value = CGM.getCXXABI().EmitDynamicCastCall(*this, Value, SrcRecordTy,
1818  DestTy, DestRecordTy, CastEnd);
1819  }
1820 
1821  if (ShouldNullCheckSrcValue) {
1822  EmitBranch(CastEnd);
1823 
1824  EmitBlock(CastNull);
1825  EmitBranch(CastEnd);
1826  }
1827 
1828  EmitBlock(CastEnd);
1829 
1830  if (ShouldNullCheckSrcValue) {
1831  llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2);
1832  PHI->addIncoming(Value, CastNotNull);
1833  PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()), CastNull);
1834 
1835  Value = PHI;
1836  }
1837 
1838  return Value;
1839 }
1840 
1842  RunCleanupsScope Scope(*this);
1843  LValue SlotLV =
1844  MakeAddrLValue(Slot.getAddr(), E->getType(), Slot.getAlignment());
1845 
1848  e = E->capture_init_end();
1849  i != e; ++i, ++CurField) {
1850  // Emit initialization
1851  LValue LV = EmitLValueForFieldInitialization(SlotLV, *CurField);
1852  if (CurField->hasCapturedVLAType()) {
1853  auto VAT = CurField->getCapturedVLAType();
1854  EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV);
1855  } else {
1856  ArrayRef<VarDecl *> ArrayIndexes;
1857  if (CurField->getType()->isArrayType())
1858  ArrayIndexes = E->getCaptureInitIndexVars(i);
1859  EmitInitializerForField(*CurField, LV, *i, ArrayIndexes);
1860  }
1861  }
1862 }
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:54
void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init, ArrayRef< VarDecl * > ArrayIndexes)
Definition: CGClass.cpp:629
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2411
virtual void EmitBadTypeidCall(CodeGenFunction &CGF)=0
virtual llvm::Value * EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy, llvm::Value *ThisPtr, llvm::Type *StdTypeInfoPtrTy)=0
Complete object ctor.
Definition: ABI.h:26
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
Definition: CGDecl.cpp:1356
bool isConstantArrayType() const
Definition: Type.h:5274
void EmitVTablePtrCheckForCall(const CXXMethodDecl *MD, llvm::Value *VTable, CFITypeCheckKind TCK, SourceLocation Loc)
Definition: CGClass.cpp:2165
llvm::Type * ConvertTypeForMem(QualType T)
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2216
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1263
DestructionKind isDestructedType() const
Definition: Type.h:999
CXXCtorType getCtorType() const
Definition: GlobalDecl.h:62
bool isElidable() const
Whether this construction is elidable.
Definition: ExprCXX.h:1144
llvm::Module & getModule() const
bool isOne() const
isOne - Test whether the quantity equals one.
Definition: CharUnits.h:119
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
virtual bool shouldTypeidBeNullChecked(bool IsDeref, QualType SrcRecordTy)=0
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp")
Definition: CGExpr.cpp:57
Checking the 'this' pointer for a constructor call.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:163
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name...
Definition: Expr.h:2430
bool isRecordType() const
Definition: Type.h:5289
virtual bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr, QualType SrcRecordTy)=0
bool hasDefinition() const
Definition: DeclCXX.h:680
QualType getPointeeType() const
Definition: Type.h:2364
void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)
Definition: CGExpr.cpp:1469
void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit)
QualType getRecordType(const RecordDecl *Decl) const
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1075
RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E, ReturnValueSlot ReturnValue)
Definition: CGExprCXX.cpp:106
const LangOptions & getLangOpts() const
LValue EmitLValueForFieldInitialization(LValue Base, const FieldDecl *Field)
Definition: CGExpr.cpp:2794
static RValue EmitNewDeleteCall(CodeGenFunction &CGF, const FunctionDecl *Callee, const FunctionProtoType *CalleeType, const CallArgList &Args)
Definition: CGExprCXX.cpp:1054
void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating, llvm::Value *This)
Definition: CGClass.cpp:1950
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2147
Expr * ignoreParenBaseCasts() LLVM_READONLY
Ignore parentheses and derived-to-base casts.
Definition: Expr.cpp:2509
llvm::Value * getAddress() const
Definition: CGValue.h:265
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
Definition: DeclCXX.cpp:1526
static llvm::Value * EmitCXXNewAllocSize(CodeGenFunction &CGF, const CXXNewExpr *e, unsigned minElements, llvm::Value *&numElements, llvm::Value *&sizeWithoutCookie)
Definition: CGExprCXX.cpp:502
CharUnits getAlignment() const
Definition: CGValue.h:483
void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin, llvm::Value *arrayEndPointer, QualType elementType, Destroyer *destroyer)
Definition: CGDecl.cpp:1598
static saved_type save(CodeGenFunction &CGF, type value)
Definition: EHScopeStack.h:60
virtual void emitVirtualObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE, llvm::Value *Ptr, QualType ElementType, const CXXDestructorDecl *Dtor)=0
const Expr * getCallee() const
Definition: Expr.h:2188
T * pushCleanupWithExtra(CleanupKind Kind, size_t N, As...A)
Definition: EHScopeStack.h:289
field_iterator field_begin() const
Definition: Decl.cpp:3629
QualType getThisType(ASTContext &C) const
Returns the type of the this pointer.
Definition: DeclCXX.cpp:1592
const CGFunctionInfo & arrangeCXXStructorDeclaration(const CXXMethodDecl *MD, StructorType Type)
Definition: CGCall.cpp:193
IsZeroed_t isZeroed() const
Definition: CGValue.h:497
RValue EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E, ReturnValueSlot ReturnValue)
Definition: CGExprCXX.cpp:345
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Definition: DeclCXX.cpp:1547
bool isVoidType() const
Definition: Type.h:5426
unsigned getNumParams() const
Definition: Type.h:3133
An object to manage conditionally-evaluated expressions.
llvm::Value * EmitCXXNewExpr(const CXXNewExpr *E)
Definition: CGExprCXX.cpp:1258
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Definition: DeclCXX.h:1144
void EmitCallArgs(CallArgList &Args, const T *CallArgTypeInfo, CallExpr::const_arg_iterator ArgBeg, CallExpr::const_arg_iterator ArgEnd, const FunctionDecl *CalleeDecl=nullptr, unsigned ParamsToSkip=0)
EmitCallArgs - Emit call arguments for a function.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:89
QualType getReturnType() const
Definition: Decl.h:1997
static llvm::Value * EmitTypeidFromVTable(CodeGenFunction &CGF, const Expr *E, llvm::Type *StdTypeInfoPtrTy)
Definition: CGExprCXX.cpp:1690
void EmitNewArrayInitializer(const CXXNewExpr *E, QualType elementType, llvm::Type *ElementTy, llvm::Value *NewPtr, llvm::Value *NumElements, llvm::Value *AllocSizeWithoutCookie)
Definition: CGExprCXX.cpp:788
bool isPotentiallyEvaluated() const
Definition: ExprCXX.cpp:28
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
Expr * getSubExpr()
Definition: Expr.h:2713
void EmitAggregateAssign(llvm::Value *DestPtr, llvm::Value *SrcPtr, QualType EltTy)
Expr * getLHS() const
Definition: Expr.h:2964
static void EmitArrayDelete(CodeGenFunction &CGF, const CXXDeleteExpr *E, llvm::Value *deletedPtr, QualType elementType)
Emit the code for deleting an array of objects.
Definition: CGExprCXX.cpp:1571
virtual RValue EmitCUDAKernelCallExpr(CodeGenFunction &CGF, const CUDAKernelCallExpr *E, ReturnValueSlot ReturnValue)
LValue MakeAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment=CharUnits())
void EmitSynthesizedCXXCopyCtor(llvm::Value *Dest, llvm::Value *Src, const Expr *Exp)
Definition: CGExprCXX.cpp:466
Describes an C or C++ initializer list.
Definition: Expr.h:3759
CGCUDARuntime & getCUDARuntime()
Return a reference to the configured CUDA runtime.
Expr * getArraySize()
Definition: ExprCXX.h:1714
bool isAlwaysNull() const
Definition: ExprCXX.cpp:639
RValue EmitCall(const CGFunctionInfo &FnInfo, llvm::Value *Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, const Decl *TargetDecl=nullptr, llvm::Instruction **callOrInvoke=nullptr)
Definition: CGCall.cpp:3106
llvm::Value * GetVTablePtr(llvm::Value *This, llvm::Type *Ty)
Definition: CGClass.cpp:2122
Base object ctor.
Definition: ABI.h:27
virtual llvm::Value * getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This, llvm::Type *Ty, SourceLocation Loc)=0
Build a virtual function pointer in the ABI-specific way.
ArrayRef< VarDecl * > getCaptureInitIndexVars(capture_init_iterator Iter) const
Retrieve the set of index variables used in the capture initializer of an array captured by copy...
Definition: ExprCXX.cpp:1074
void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin, llvm::Value *arrayEnd, QualType elementType, Destroyer *destroyer)
Definition: CGDecl.cpp:1613
const CXXRecordDecl * getParent() const
Definition: DeclCXX.h:1817
capture_init_iterator capture_init_end() const
Retrieve the iterator pointing one past the last initialization argument for this lambda expression...
Definition: ExprCXX.h:1518
bool isDefaulted() const
Definition: Decl.h:1805
Expr * getInitializer()
The initializer of this new-expression.
Definition: ExprCXX.h:1751
Expr * getExprOperand() const
Definition: ExprCXX.h:589
bool isObjCLifetimeType() const
Definition: Type.cpp:3561
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2918
bool needsEHCleanup(QualType::DestructionKind kind)
RecordDecl * getDecl() const
Definition: Type.h:3527
llvm::Value * EmitDynamicCast(llvm::Value *V, const CXXDynamicCastExpr *DCE)
Definition: CGExprCXX.cpp:1761
QualType getTypeAsWritten() const
Definition: Expr.h:2849
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
static RequiredArgs commonEmitCXXMemberOrOperatorCall(CodeGenFunction &CGF, const CXXMethodDecl *MD, llvm::Value *Callee, ReturnValueSlot ReturnValue, llvm::Value *This, llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *CE, CallArgList &Args)
Definition: CGExprCXX.cpp:27
void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr, QualType DeleteTy)
Definition: CGExprCXX.cpp:1393
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1343
const CGFunctionInfo & arrangeCXXMethodDeclaration(const CXXMethodDecl *MD)
Definition: CGCall.cpp:177
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.
QualType getType() const
Definition: Decl.h:538
CXXMethodDecl * getCorrespondingMethodInClass(const CXXRecordDecl *RD, bool MayBeBase=false)
Find the method in RD that corresponds to this one.
Definition: DeclCXX.cpp:1426
arg_iterator placement_arg_end()
Definition: ExprCXX.h:1776
arg_iterator arg_end()
Definition: Expr.h:2247
const ArrayType * getAsArrayTypeUnsafe() const
Definition: Type.h:5572
llvm::GlobalValue * getAddrOfCXXStructor(const CXXMethodDecl *MD, StructorType Type, const CGFunctionInfo *FnInfo=nullptr, llvm::FunctionType *FnType=nullptr, bool DontDefer=false)
Return the address of the constructor/destructor of the given type.
Definition: CGCXX.cpp:229
bool isUnion() const
Definition: Decl.h:2906
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:1864
void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest)
Definition: CGExprCXX.cpp:394
QualType getParamType(unsigned i) const
Definition: Type.h:3134
virtual CharUnits GetArrayCookieSize(const CXXNewExpr *expr)
Definition: CGCXXABI.cpp:178
Qualifiers::ObjCLifetime getObjCLifetime() const
getObjCLifetime - Returns lifetime attribute of this type.
Definition: Type.h:976
capture_init_iterator capture_init_begin() const
Retrieve the first initialization argument for this lambda expression (which initializes the first ca...
Definition: ExprCXX.h:1512
param_type_iterator param_type_begin() const
Definition: Type.h:3254
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:1710
QualType getPointeeType() const
Definition: Type.cpp:414
bool requiresZeroInitialization() const
Whether this construction first requires zero-initialization before the initializer is called...
Definition: ExprCXX.h:1165
bool isSignedIntegerOrEnumerationType() const
Definition: Type.cpp:1699
static TypeEvaluationKind getEvaluationKind(QualType T)
virtual void ReadArrayCookie(CodeGenFunction &CGF, llvm::Value *Ptr, const CXXDeleteExpr *expr, QualType ElementType, llvm::Value *&NumElements, llvm::Value *&AllocPtr, CharUnits &CookieSize)
Definition: CGCXXABI.cpp:218
virtual llvm::Value * EmitDynamicCastCall(CodeGenFunction &CGF, llvm::Value *Value, QualType SrcRecordTy, QualType DestTy, QualType DestRecordTy, llvm::BasicBlock *CastEnd)=0
bool isInstance() const
Definition: DeclCXX.h:1744
bool CanDevirtualizeMemberFunctionCall(const Expr *Base, const CXXMethodDecl *MD)
Definition: CGClass.cpp:2300
CGCXXABI & getCXXABI() const
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
RValue EmitCXXMemberOrOperatorCall(const CXXMethodDecl *MD, llvm::Value *Callee, ReturnValueSlot ReturnValue, llvm::Value *This, llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *E)
Definition: CGExprCXX.cpp:72
void pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete, llvm::Value *CompletePtr, QualType ElementType)
Definition: CGExprCXX.cpp:1443
bool isVirtual() const
Definition: DeclCXX.h:1761
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2358
static void EnterNewDeleteCleanup(CodeGenFunction &CGF, const CXXNewExpr *E, llvm::Value *NewPtr, llvm::Value *AllocSize, const CallArgList &NewArgs)
Definition: CGExprCXX.cpp:1220
CharUnits getNonVirtualAlignment() const
Definition: RecordLayout.h:202
virtual bool EmitBadCastCall(CodeGenFunction &CGF)=0
ASTContext & getContext() const
ConstructionKind getConstructionKind() const
Determine whether this constructor is actually constructing a base class (rather than a complete obje...
Definition: ExprCXX.h:1172
void add(RValue rvalue, QualType type, bool needscopy=false)
Definition: CGCall.h:81
stable_iterator stable_begin() const
Definition: EHScopeStack.h:364
virtual llvm::Value * EmitVirtualDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType, llvm::Value *This, const CXXMemberCallExpr *CE)=0
Emit the ABI-specific virtual destructor call.
bool shouldNullCheckAllocation(const ASTContext &Ctx) const
True if the allocation result needs to be null-checked.
Definition: ExprCXX.cpp:210
QualType getAllocatedType() const
Definition: ExprCXX.h:1682
void EmitLambdaExpr(const LambdaExpr *E, AggValueSlot Dest)
Definition: CGExprCXX.cpp:1841
RValue EmitCXXMemberOrOperatorMemberCallExpr(const CallExpr *CE, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue, bool HasQualifier, NestedNameSpecifier *Qualifier, bool IsArrow, const Expr *Base)
Definition: CGExprCXX.cpp:132
static void EmitObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE, llvm::Value *Ptr, QualType ElementType)
Emit the code for deleting a single object.
Definition: CGExprCXX.cpp:1451
llvm::Value * EmitCastToVoidPtr(llvm::Value *value)
Emit a cast to void* in the appropriate address space.
Definition: CGExpr.cpp:43
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys=None)
Expr * getArgument()
Definition: ExprCXX.h:1866
bool isArray() const
Definition: ExprCXX.h:1713
bool isArrayForm() const
Definition: ExprCXX.h:1853
There is no lifetime qualification on this type.
Definition: Type.h:130
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition: ExprCXX.h:269
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type, bool ForVirtualBase, bool Delegating, llvm::Value *This, const CXXConstructExpr *E)
Definition: CGClass.cpp:1774
bool mayInsertExtraPadding(bool EmitRemark=false) const
Whether we are allowed to insert extra padding between fields. These padding are added to help Addres...
Definition: Decl.cpp:3686
llvm::Value * EmitCXXTypeidExpr(const CXXTypeidExpr *E)
Definition: CGExprCXX.cpp:1722
ASTContext & getContext() const
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
Definition: CGObjC.cpp:2021
void EmitAggregateCopy(llvm::Value *DestPtr, llvm::Value *SrcPtr, QualType EltTy, bool isVolatile=false, CharUnits Alignment=CharUnits::Zero(), bool isAssignment=false)
Definition: CGExprAgg.cpp:1425
static CXXRecordDecl * getCXXRecord(const Expr *E)
Definition: CGExprCXX.cpp:96
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
Definition: ExprCXX.h:1623
void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)
Deactive a cleanup that was created in an active state.
Definition: CGCleanup.cpp:1135
An aggregate value slot.
Definition: CGValue.h:363
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1717
const CXXRecordDecl * getBestDynamicClassType() const
For an expression of class type or pointer to class type, return the most derived class decl the expr...
Definition: Expr.cpp:39
virtual llvm::Value * EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, const Expr *E, llvm::Value *&This, llvm::Value *MemPtr, const MemberPointerType *MPT)
Definition: CGCXXABI.cpp:75
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
void EmitNullInitialization(llvm::Value *DestPtr, QualType Ty)
llvm::Constant * EmitNullConstantForBase(const CXXRecordDecl *Record)
SanitizerSet SanOpts
Sanitizers enabled for this function.
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2003
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
bool hasInitializer() const
Whether this new-expression has any initializer at all.
Definition: ExprCXX.h:1741
const T * castAs() const
Definition: Type.h:5586
lookup_result lookup(DeclarationName Name) const
Definition: DeclBase.cpp:1339
Complete object dtor.
Definition: ABI.h:36
RValue EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E, ReturnValueSlot ReturnValue)
Definition: CGExprCXX.cpp:285
Assigning into this object requires a lifetime extension.
Definition: Type.h:147
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5086
RValue EmitBuiltinNewDeleteCall(const FunctionProtoType *Type, const Expr *Arg, bool IsDelete)
Definition: CGExprCXX.cpp:1087
const CGFunctionInfo & arrangeCXXMethodCall(const CallArgList &args, const FunctionProtoType *type, RequiredArgs required)
Arrange a call to a C++ method, passing the given arguments.
Definition: CGCall.cpp:446
bool isDynamicClass() const
Definition: DeclCXX.h:693
CXXCtorType
C++ constructor types.
Definition: ABI.h:25
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.cpp:193
static void StoreAnyExprIntoOneUnit(CodeGenFunction &CGF, const Expr *Init, QualType AllocType, llvm::Value *NewPtr)
Definition: CGExprCXX.cpp:761
QualType getPointeeType() const
Definition: Type.h:2139
void EmitARCDestroyWeak(llvm::Value *addr)
Definition: CGObjC.cpp:2232
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
bool isArrow() const
Definition: Expr.h:2548
QualType getType() const
Definition: Expr.h:125
static CharUnits CalculateCookiePadding(CodeGenFunction &CGF, const CXXNewExpr *E)
Definition: CGExprCXX.cpp:489
static const Type * getElementType(const Expr *BaseExpr)
QualType getTypeOperand(ASTContext &Context) const
Retrieves the type operand of this typeid() expression after various required adjustments (removing r...
Definition: ExprCXX.cpp:43
llvm::Constant * GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty=0, bool ForVTable=false, bool DontDefer=false)
Represents a delete expression for memory deallocation and destructor calls, e.g. "delete[] pArray"...
Definition: ExprCXX.h:1819
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return 0.
Definition: Expr.cpp:1184
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:1302
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1639
bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const
Determine whether the result of this expression is a temporary object of the given class type...
Definition: Expr.cpp:2633
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
void emitArrayDestroy(llvm::Value *begin, llvm::Value *end, QualType type, Destroyer *destroyer, bool checkZeroLength, bool useEHCleanup)
Definition: CGDecl.cpp:1467
unsigned getNumPlacementArgs() const
Definition: ExprCXX.h:1721
unsigned getNumArgs() const
Definition: Expr.h:2205
void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, llvm::Value *V, QualType Type, CharUnits Alignment=CharUnits::Zero(), bool SkipNullCheck=false)
Emit a check that V is the address of storage of the appropriate size and alignment for an object of ...
Definition: CGExpr.cpp:489
void EmitAggExpr(const Expr *E, AggValueSlot AS)
Definition: CGExprAgg.cpp:1403
void EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D, llvm::Value *This, llvm::Value *Src, const CXXConstructExpr *E)
Definition: CGClass.cpp:1826
static llvm::Value * EmitDynamicCastToNull(CodeGenFunction &CGF, QualType DestTy)
Definition: CGExprCXX.cpp:1746
static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype, unsigned additional)
FunctionDecl * getOperatorNew() const
Definition: ExprCXX.h:1708
const T * getAs() const
Definition: Type.h:5555
QualType getCanonicalType() const
Definition: Type.h:5055
arg_iterator arg_begin()
Definition: Expr.h:2246
static void EmitNullBaseClassInitialization(CodeGenFunction &CGF, llvm::Value *DestPtr, const CXXRecordDecl *Base)
Definition: CGExprCXX.cpp:350
Represents a call to a CUDA kernel function.
Definition: ExprCXX.h:155
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1266
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
Definition: Sanitizers.h:52
void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
Definition: CGDecl.cpp:604
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1201
CXXConstructorDecl * getConstructor() const
Definition: ExprCXX.h:1137
bool isTrivial() const
Definition: Decl.h:1800
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
Definition: CGStmt.cpp:348
CharUnits getNonVirtualSize() const
Definition: RecordLayout.h:194
static void EmitNewInitializer(CodeGenFunction &CGF, const CXXNewExpr *E, QualType ElementType, llvm::Type *ElementTy, llvm::Value *NewPtr, llvm::Value *NumElements, llvm::Value *AllocSizeWithoutCookie)
Definition: CGExprCXX.cpp:1040
arg_iterator placement_arg_begin()
Definition: ExprCXX.h:1773
RValue EmitCXXStructorCall(const CXXMethodDecl *MD, llvm::Value *Callee, ReturnValueSlot ReturnValue, llvm::Value *This, llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *E, StructorType Type)
Definition: CGExprCXX.cpp:85
static bool isGLValueFromPointerDeref(const Expr *E)
Definition: CGExprCXX.cpp:1658
llvm::ConstantInt * getSize(CharUnits numChars)
Emit the given number of characters as a value of type size_t.
Expr * getBase() const
Definition: Expr.h:2405
const Type * getClass() const
Definition: Type.h:2378
llvm::Value * getAddr() const
Definition: CGValue.h:475
Reading or writing from this object requires a barrier call.
Definition: Type.h:144
bool isPODType(ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:1922
void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D, const ConstantArrayType *ArrayTy, llvm::Value *ArrayPtr, const CXXConstructExpr *E, bool ZeroInitialization=false)
Definition: CGClass.cpp:1656
llvm::Value * BuildAppleKextVirtualCall(const CXXMethodDecl *MD, NestedNameSpecifier *Qual, llvm::Type *Ty)
Definition: CGCXX.cpp:280
Represents a C++ struct/union/class.
Definition: DeclCXX.h:285
void EmitBranch(llvm::BasicBlock *Block)
Definition: CGStmt.cpp:368
Opcode getOpcode() const
Definition: Expr.h:2961
llvm::Type * ConvertType(QualType T)
bool hasQualifier() const
Determines whether this member expression actually had a C++ nested-name-specifier prior to the name ...
Definition: Expr.h:2425
void EmitCXXDeleteExpr(const CXXDeleteExpr *E)
Definition: CGExprCXX.cpp:1610
LValue EmitLValue(const Expr *E)
Definition: CGExpr.cpp:831
bool isReservedGlobalPlacementOperator() const
Determines whether this operator new or delete is one of the reserved global placement operators: voi...
Definition: Decl.cpp:2469
virtual llvm::Value * adjustThisArgumentForVirtualFunctionCall(CodeGenFunction &CGF, GlobalDecl GD, llvm::Value *This, bool VirtualCall)
Definition: CGCXXABI.h:298
Expr * getRHS() const
Definition: Expr.h:2966
static RValue get(llvm::Value *V)
Definition: CGValue.h:71
uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const
Return number of constant array elements.
const CGFunctionInfo & arrangeFreeFunctionCall(const CallArgList &Args, const FunctionType *Ty, bool ChainCall)
Definition: CGCall.cpp:414
static AggValueSlot forAddr(llvm::Value *addr, CharUnits align, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, IsZeroed_t isZeroed=IsNotZeroed)
Definition: CGValue.h:424
virtual llvm::Value * EmitDynamicCastToVoid(CodeGenFunction &CGF, llvm::Value *Value, QualType SrcRecordTy, QualType DestTy)=0
virtual llvm::Value * InitializeArrayCookie(CodeGenFunction &CGF, llvm::Value *NewPtr, llvm::Value *NumElements, const CXXNewExpr *expr, QualType ElementType)
Definition: CGCXXABI.cpp:189
bool isTypeOperand() const
Definition: ExprCXX.h:572
RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue)
Definition: CGExprCXX.cpp:335
TranslationUnitDecl * getTranslationUnitDecl()
Definition: DeclBase.cpp:269
void PopCleanupBlock(bool FallThroughIsBranchThrough=false)
Definition: CGCleanup.cpp:583
bool isIgnored() const
Definition: CGValue.h:479
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
bool isZeroInitializable(QualType T)
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:4352
CXXRecordDecl * getLambdaClass() const
Retrieve the class that corresponds to the lambda.
Definition: ExprCXX.cpp:1086
Expr * IgnoreParens() LLVM_READONLY
Definition: Expr.cpp:2408
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5043
bool isPointerType() const
Definition: Type.h:5232
OverloadedOperatorKind getOverloadedOperator() const
Definition: Decl.cpp:2916
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition: CGCall.cpp:1253