clang  14.0.0git
CGExprCXX.cpp
Go to the documentation of this file.
1 //===--- CGExprCXX.cpp - Emit LLVM Code for C++ expressions ---------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This contains code dealing with code generation of C++ expressions
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "CGCUDARuntime.h"
14 #include "CGCXXABI.h"
15 #include "CGDebugInfo.h"
16 #include "CGObjCRuntime.h"
17 #include "CodeGenFunction.h"
18 #include "ConstantEmitter.h"
19 #include "TargetInfo.h"
22 #include "llvm/IR/Intrinsics.h"
23 
24 using namespace clang;
25 using namespace CodeGen;
26 
27 namespace {
28 struct MemberCallInfo {
29  RequiredArgs ReqArgs;
30  // Number of prefix arguments for the call. Ignores the `this` pointer.
31  unsigned PrefixSize;
32 };
33 }
34 
35 static MemberCallInfo
37  llvm::Value *This, llvm::Value *ImplicitParam,
38  QualType ImplicitParamTy, const CallExpr *CE,
39  CallArgList &Args, CallArgList *RtlArgs) {
40  assert(CE == nullptr || isa<CXXMemberCallExpr>(CE) ||
41  isa<CXXOperatorCallExpr>(CE));
42  assert(MD->isInstance() &&
43  "Trying to emit a member or operator call expr on a static method!");
44 
45  // Push the this ptr.
46  const CXXRecordDecl *RD =
48  Args.add(RValue::get(This), CGF.getTypes().DeriveThisType(RD, MD));
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  unsigned PrefixSize = Args.size() - 1;
58 
59  // And the rest of the call args.
60  if (RtlArgs) {
61  // Special case: if the caller emitted the arguments right-to-left already
62  // (prior to emitting the *this argument), we're done. This happens for
63  // assignment operators.
64  Args.addFrom(*RtlArgs);
65  } else if (CE) {
66  // Special case: skip first argument of CXXOperatorCall (it is "this").
67  unsigned ArgsToSkip = isa<CXXOperatorCallExpr>(CE) ? 1 : 0;
68  CGF.EmitCallArgs(Args, FPT, drop_begin(CE->arguments(), ArgsToSkip),
69  CE->getDirectCallee());
70  } else {
71  assert(
72  FPT->getNumParams() == 0 &&
73  "No CallExpr specified for function with non-zero number of arguments");
74  }
75  return {required, PrefixSize};
76 }
77 
79  const CXXMethodDecl *MD, const CGCallee &Callee,
80  ReturnValueSlot ReturnValue,
81  llvm::Value *This, llvm::Value *ImplicitParam, QualType ImplicitParamTy,
82  const CallExpr *CE, CallArgList *RtlArgs) {
83  const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
84  CallArgList Args;
85  MemberCallInfo CallInfo = commonEmitCXXMemberOrOperatorCall(
86  *this, MD, This, ImplicitParam, ImplicitParamTy, CE, Args, RtlArgs);
87  auto &FnInfo = CGM.getTypes().arrangeCXXMethodCall(
88  Args, FPT, CallInfo.ReqArgs, CallInfo.PrefixSize);
89  return EmitCall(FnInfo, Callee, ReturnValue, Args, nullptr,
90  CE && CE == MustTailCall,
91  CE ? CE->getExprLoc() : SourceLocation());
92 }
93 
95  GlobalDecl Dtor, const CGCallee &Callee, llvm::Value *This, QualType ThisTy,
96  llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *CE) {
97  const CXXMethodDecl *DtorDecl = cast<CXXMethodDecl>(Dtor.getDecl());
98 
99  assert(!ThisTy.isNull());
100  assert(ThisTy->getAsCXXRecordDecl() == DtorDecl->getParent() &&
101  "Pointer/Object mixup");
102 
103  LangAS SrcAS = ThisTy.getAddressSpace();
104  LangAS DstAS = DtorDecl->getMethodQualifiers().getAddressSpace();
105  if (SrcAS != DstAS) {
106  QualType DstTy = DtorDecl->getThisType();
107  llvm::Type *NewType = CGM.getTypes().ConvertType(DstTy);
108  This = getTargetHooks().performAddrSpaceCast(*this, This, SrcAS, DstAS,
109  NewType);
110  }
111 
112  CallArgList Args;
113  commonEmitCXXMemberOrOperatorCall(*this, DtorDecl, This, ImplicitParam,
114  ImplicitParamTy, CE, Args, nullptr);
115  return EmitCall(CGM.getTypes().arrangeCXXStructorDeclaration(Dtor), Callee,
116  ReturnValueSlot(), Args, nullptr, CE && CE == MustTailCall,
117  CE ? CE->getExprLoc() : SourceLocation{});
118 }
119 
121  const CXXPseudoDestructorExpr *E) {
122  QualType DestroyedType = E->getDestroyedType();
123  if (DestroyedType.hasStrongOrWeakObjCLifetime()) {
124  // Automatic Reference Counting:
125  // If the pseudo-expression names a retainable object with weak or
126  // strong lifetime, the object shall be released.
127  Expr *BaseExpr = E->getBase();
128  Address BaseValue = Address::invalid();
129  Qualifiers BaseQuals;
130 
131  // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar.
132  if (E->isArrow()) {
133  BaseValue = EmitPointerWithAlignment(BaseExpr);
134  const auto *PTy = BaseExpr->getType()->castAs<PointerType>();
135  BaseQuals = PTy->getPointeeType().getQualifiers();
136  } else {
137  LValue BaseLV = EmitLValue(BaseExpr);
138  BaseValue = BaseLV.getAddress(*this);
139  QualType BaseTy = BaseExpr->getType();
140  BaseQuals = BaseTy.getQualifiers();
141  }
142 
143  switch (DestroyedType.getObjCLifetime()) {
147  break;
148 
151  DestroyedType.isVolatileQualified()),
153  break;
154 
156  EmitARCDestroyWeak(BaseValue);
157  break;
158  }
159  } else {
160  // C++ [expr.pseudo]p1:
161  // The result shall only be used as the operand for the function call
162  // operator (), and the result of such a call has type void. The only
163  // effect is the evaluation of the postfix-expression before the dot or
164  // arrow.
165  EmitIgnoredExpr(E->getBase());
166  }
167 
168  return RValue::get(nullptr);
169 }
170 
171 static CXXRecordDecl *getCXXRecord(const Expr *E) {
172  QualType T = E->getType();
173  if (const PointerType *PTy = T->getAs<PointerType>())
174  T = PTy->getPointeeType();
175  const RecordType *Ty = T->castAs<RecordType>();
176  return cast<CXXRecordDecl>(Ty->getDecl());
177 }
178 
179 // Note: This function also emit constructor calls to support a MSVC
180 // extensions allowing explicit constructor function call.
182  ReturnValueSlot ReturnValue) {
183  const Expr *callee = CE->getCallee()->IgnoreParens();
184 
185  if (isa<BinaryOperator>(callee))
187 
188  const MemberExpr *ME = cast<MemberExpr>(callee);
189  const CXXMethodDecl *MD = cast<CXXMethodDecl>(ME->getMemberDecl());
190 
191  if (MD->isStatic()) {
192  // The method is static, emit it as we would a regular call.
193  CGCallee callee =
195  return EmitCall(getContext().getPointerType(MD->getType()), callee, CE,
196  ReturnValue);
197  }
198 
199  bool HasQualifier = ME->hasQualifier();
200  NestedNameSpecifier *Qualifier = HasQualifier ? ME->getQualifier() : nullptr;
201  bool IsArrow = ME->isArrow();
202  const Expr *Base = ME->getBase();
203 
205  CE, MD, ReturnValue, HasQualifier, Qualifier, IsArrow, Base);
206 }
207 
209  const CallExpr *CE, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue,
210  bool HasQualifier, NestedNameSpecifier *Qualifier, bool IsArrow,
211  const Expr *Base) {
212  assert(isa<CXXMemberCallExpr>(CE) || isa<CXXOperatorCallExpr>(CE));
213 
214  // Compute the object pointer.
215  bool CanUseVirtualCall = MD->isVirtual() && !HasQualifier;
216 
217  const CXXMethodDecl *DevirtualizedMethod = nullptr;
218  if (CanUseVirtualCall &&
219  MD->getDevirtualizedMethod(Base, getLangOpts().AppleKext)) {
220  const CXXRecordDecl *BestDynamicDecl = Base->getBestDynamicClassType();
221  DevirtualizedMethod = MD->getCorrespondingMethodInClass(BestDynamicDecl);
222  assert(DevirtualizedMethod);
223  const CXXRecordDecl *DevirtualizedClass = DevirtualizedMethod->getParent();
224  const Expr *Inner = Base->IgnoreParenBaseCasts();
225  if (DevirtualizedMethod->getReturnType().getCanonicalType() !=
227  // If the return types are not the same, this might be a case where more
228  // code needs to run to compensate for it. For example, the derived
229  // method might return a type that inherits form from the return
230  // type of MD and has a prefix.
231  // For now we just avoid devirtualizing these covariant cases.
232  DevirtualizedMethod = nullptr;
233  else if (getCXXRecord(Inner) == DevirtualizedClass)
234  // If the class of the Inner expression is where the dynamic method
235  // is defined, build the this pointer from it.
236  Base = Inner;
237  else if (getCXXRecord(Base) != DevirtualizedClass) {
238  // If the method is defined in a class that is not the best dynamic
239  // one or the one of the full expression, we would have to build
240  // a derived-to-base cast to compute the correct this pointer, but
241  // we don't have support for that yet, so do a virtual call.
242  DevirtualizedMethod = nullptr;
243  }
244  }
245 
246  bool TrivialForCodegen =
247  MD->isTrivial() || (MD->isDefaulted() && MD->getParent()->isUnion());
248  bool TrivialAssignment =
249  TrivialForCodegen &&
252 
253  // C++17 demands that we evaluate the RHS of a (possibly-compound) assignment
254  // operator before the LHS.
255  CallArgList RtlArgStorage;
256  CallArgList *RtlArgs = nullptr;
257  LValue TrivialAssignmentRHS;
258  if (auto *OCE = dyn_cast<CXXOperatorCallExpr>(CE)) {
259  if (OCE->isAssignmentOp()) {
260  if (TrivialAssignment) {
261  TrivialAssignmentRHS = EmitLValue(CE->getArg(1));
262  } else {
263  RtlArgs = &RtlArgStorage;
264  EmitCallArgs(*RtlArgs, MD->getType()->castAs<FunctionProtoType>(),
265  drop_begin(CE->arguments(), 1), CE->getDirectCallee(),
266  /*ParamsToSkip*/0, EvaluationOrder::ForceRightToLeft);
267  }
268  }
269  }
270 
271  LValue This;
272  if (IsArrow) {
273  LValueBaseInfo BaseInfo;
274  TBAAAccessInfo TBAAInfo;
275  Address ThisValue = EmitPointerWithAlignment(Base, &BaseInfo, &TBAAInfo);
276  This = MakeAddrLValue(ThisValue, Base->getType(), BaseInfo, TBAAInfo);
277  } else {
278  This = EmitLValue(Base);
279  }
280 
281  if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
282  // This is the MSVC p->Ctor::Ctor(...) extension. We assume that's
283  // constructing a new complete object of type Ctor.
284  assert(!RtlArgs);
285  assert(ReturnValue.isNull() && "Constructor shouldn't have return value");
286  CallArgList Args;
288  *this, Ctor, This.getPointer(*this), /*ImplicitParam=*/nullptr,
289  /*ImplicitParamTy=*/QualType(), CE, Args, nullptr);
290 
291  EmitCXXConstructorCall(Ctor, Ctor_Complete, /*ForVirtualBase=*/false,
292  /*Delegating=*/false, This.getAddress(*this), Args,
294  /*NewPointerIsChecked=*/false);
295  return RValue::get(nullptr);
296  }
297 
298  if (TrivialForCodegen) {
299  if (isa<CXXDestructorDecl>(MD))
300  return RValue::get(nullptr);
301 
302  if (TrivialAssignment) {
303  // We don't like to generate the trivial copy/move assignment operator
304  // when it isn't necessary; just produce the proper effect here.
305  // It's important that we use the result of EmitLValue here rather than
306  // emitting call arguments, in order to preserve TBAA information from
307  // the RHS.
308  LValue RHS = isa<CXXOperatorCallExpr>(CE)
309  ? TrivialAssignmentRHS
310  : EmitLValue(*CE->arg_begin());
311  EmitAggregateAssign(This, RHS, CE->getType());
312  return RValue::get(This.getPointer(*this));
313  }
314 
315  assert(MD->getParent()->mayInsertExtraPadding() &&
316  "unknown trivial member function");
317  }
318 
319  // Compute the function type we're calling.
320  const CXXMethodDecl *CalleeDecl =
321  DevirtualizedMethod ? DevirtualizedMethod : MD;
322  const CGFunctionInfo *FInfo = nullptr;
323  if (const auto *Dtor = dyn_cast<CXXDestructorDecl>(CalleeDecl))
325  GlobalDecl(Dtor, Dtor_Complete));
326  else
327  FInfo = &CGM.getTypes().arrangeCXXMethodDeclaration(CalleeDecl);
328 
329  llvm::FunctionType *Ty = CGM.getTypes().GetFunctionType(*FInfo);
330 
331  // C++11 [class.mfct.non-static]p2:
332  // If a non-static member function of a class X is called for an object that
333  // is not of type X, or of a type derived from X, the behavior is undefined.
334  SourceLocation CallLoc;
335  ASTContext &C = getContext();
336  if (CE)
337  CallLoc = CE->getExprLoc();
338 
339  SanitizerSet SkippedChecks;
340  if (const auto *CMCE = dyn_cast<CXXMemberCallExpr>(CE)) {
341  auto *IOA = CMCE->getImplicitObjectArgument();
342  bool IsImplicitObjectCXXThis = IsWrappedCXXThis(IOA);
343  if (IsImplicitObjectCXXThis)
344  SkippedChecks.set(SanitizerKind::Alignment, true);
345  if (IsImplicitObjectCXXThis || isa<DeclRefExpr>(IOA))
346  SkippedChecks.set(SanitizerKind::Null, true);
347  }
349  This.getPointer(*this),
350  C.getRecordType(CalleeDecl->getParent()),
351  /*Alignment=*/CharUnits::Zero(), SkippedChecks);
352 
353  // C++ [class.virtual]p12:
354  // Explicit qualification with the scope operator (5.1) suppresses the
355  // virtual call mechanism.
356  //
357  // We also don't emit a virtual call if the base expression has a record type
358  // because then we know what the type is.
359  bool UseVirtualCall = CanUseVirtualCall && !DevirtualizedMethod;
360 
361  if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(CalleeDecl)) {
362  assert(CE->arg_begin() == CE->arg_end() &&
363  "Destructor shouldn't have explicit parameters");
364  assert(ReturnValue.isNull() && "Destructor shouldn't have return value");
365  if (UseVirtualCall) {
367  This.getAddress(*this),
368  cast<CXXMemberCallExpr>(CE));
369  } else {
370  GlobalDecl GD(Dtor, Dtor_Complete);
371  CGCallee Callee;
372  if (getLangOpts().AppleKext && Dtor->isVirtual() && HasQualifier)
373  Callee = BuildAppleKextVirtualCall(Dtor, Qualifier, Ty);
374  else if (!DevirtualizedMethod)
375  Callee =
376  CGCallee::forDirect(CGM.getAddrOfCXXStructor(GD, FInfo, Ty), GD);
377  else {
378  Callee = CGCallee::forDirect(CGM.GetAddrOfFunction(GD, Ty), GD);
379  }
380 
381  QualType ThisTy =
382  IsArrow ? Base->getType()->getPointeeType() : Base->getType();
383  EmitCXXDestructorCall(GD, Callee, This.getPointer(*this), ThisTy,
384  /*ImplicitParam=*/nullptr,
385  /*ImplicitParamTy=*/QualType(), CE);
386  }
387  return RValue::get(nullptr);
388  }
389 
390  // FIXME: Uses of 'MD' past this point need to be audited. We may need to use
391  // 'CalleeDecl' instead.
392 
393  CGCallee Callee;
394  if (UseVirtualCall) {
395  Callee = CGCallee::forVirtual(CE, MD, This.getAddress(*this), Ty);
396  } else {
397  if (SanOpts.has(SanitizerKind::CFINVCall) &&
398  MD->getParent()->isDynamicClass()) {
399  llvm::Value *VTable;
400  const CXXRecordDecl *RD;
401  std::tie(VTable, RD) = CGM.getCXXABI().LoadVTablePtr(
402  *this, This.getAddress(*this), CalleeDecl->getParent());
404  }
405 
406  if (getLangOpts().AppleKext && MD->isVirtual() && HasQualifier)
407  Callee = BuildAppleKextVirtualCall(MD, Qualifier, Ty);
408  else if (!DevirtualizedMethod)
409  Callee =
411  else {
412  Callee =
413  CGCallee::forDirect(CGM.GetAddrOfFunction(DevirtualizedMethod, Ty),
414  GlobalDecl(DevirtualizedMethod));
415  }
416  }
417 
418  if (MD->isVirtual()) {
419  Address NewThisAddr =
421  *this, CalleeDecl, This.getAddress(*this), UseVirtualCall);
422  This.setAddress(NewThisAddr);
423  }
424 
426  CalleeDecl, Callee, ReturnValue, This.getPointer(*this),
427  /*ImplicitParam=*/nullptr, QualType(), CE, RtlArgs);
428 }
429 
430 RValue
432  ReturnValueSlot ReturnValue) {
433  const BinaryOperator *BO =
434  cast<BinaryOperator>(E->getCallee()->IgnoreParens());
435  const Expr *BaseExpr = BO->getLHS();
436  const Expr *MemFnExpr = BO->getRHS();
437 
438  const auto *MPT = MemFnExpr->getType()->castAs<MemberPointerType>();
439  const auto *FPT = MPT->getPointeeType()->castAs<FunctionProtoType>();
440  const auto *RD =
441  cast<CXXRecordDecl>(MPT->getClass()->castAs<RecordType>()->getDecl());
442 
443  // Emit the 'this' pointer.
445  if (BO->getOpcode() == BO_PtrMemI)
446  This = EmitPointerWithAlignment(BaseExpr);
447  else
448  This = EmitLValue(BaseExpr).getAddress(*this);
449 
450  EmitTypeCheck(TCK_MemberCall, E->getExprLoc(), This.getPointer(),
451  QualType(MPT->getClass(), 0));
452 
453  // Get the member function pointer.
454  llvm::Value *MemFnPtr = EmitScalarExpr(MemFnExpr);
455 
456  // Ask the ABI to load the callee. Note that This is modified.
457  llvm::Value *ThisPtrForCall = nullptr;
458  CGCallee Callee =
460  ThisPtrForCall, MemFnPtr, MPT);
461 
462  CallArgList Args;
463 
464  QualType ThisType =
465  getContext().getPointerType(getContext().getTagDeclType(RD));
466 
467  // Push the this ptr.
468  Args.add(RValue::get(ThisPtrForCall), ThisType);
469 
470  RequiredArgs required = RequiredArgs::forPrototypePlus(FPT, 1);
471 
472  // And the rest of the call args
473  EmitCallArgs(Args, FPT, E->arguments());
474  return EmitCall(CGM.getTypes().arrangeCXXMethodCall(Args, FPT, required,
475  /*PrefixSize=*/0),
476  Callee, ReturnValue, Args, nullptr, E == MustTailCall,
477  E->getExprLoc());
478 }
479 
480 RValue
482  const CXXMethodDecl *MD,
483  ReturnValueSlot ReturnValue) {
484  assert(MD->isInstance() &&
485  "Trying to emit a member call expr on a static method!");
487  E, MD, ReturnValue, /*HasQualifier=*/false, /*Qualifier=*/nullptr,
488  /*IsArrow=*/false, E->getArg(0));
489 }
490 
492  ReturnValueSlot ReturnValue) {
494 }
495 
497  Address DestPtr,
498  const CXXRecordDecl *Base) {
499  if (Base->isEmpty())
500  return;
501 
502  DestPtr = CGF.Builder.CreateElementBitCast(DestPtr, CGF.Int8Ty);
503 
504  const ASTRecordLayout &Layout = CGF.getContext().getASTRecordLayout(Base);
505  CharUnits NVSize = Layout.getNonVirtualSize();
506 
507  // We cannot simply zero-initialize the entire base sub-object if vbptrs are
508  // present, they are initialized by the most derived class before calling the
509  // constructor.
511  Stores.emplace_back(CharUnits::Zero(), NVSize);
512 
513  // Each store is split by the existence of a vbptr.
514  CharUnits VBPtrWidth = CGF.getPointerSize();
515  std::vector<CharUnits> VBPtrOffsets =
517  for (CharUnits VBPtrOffset : VBPtrOffsets) {
518  // Stop before we hit any virtual base pointers located in virtual bases.
519  if (VBPtrOffset >= NVSize)
520  break;
521  std::pair<CharUnits, CharUnits> LastStore = Stores.pop_back_val();
522  CharUnits LastStoreOffset = LastStore.first;
523  CharUnits LastStoreSize = LastStore.second;
524 
525  CharUnits SplitBeforeOffset = LastStoreOffset;
526  CharUnits SplitBeforeSize = VBPtrOffset - SplitBeforeOffset;
527  assert(!SplitBeforeSize.isNegative() && "negative store size!");
528  if (!SplitBeforeSize.isZero())
529  Stores.emplace_back(SplitBeforeOffset, SplitBeforeSize);
530 
531  CharUnits SplitAfterOffset = VBPtrOffset + VBPtrWidth;
532  CharUnits SplitAfterSize = LastStoreSize - SplitAfterOffset;
533  assert(!SplitAfterSize.isNegative() && "negative store size!");
534  if (!SplitAfterSize.isZero())
535  Stores.emplace_back(SplitAfterOffset, SplitAfterSize);
536  }
537 
538  // If the type contains a pointer to data member we can't memset it to zero.
539  // Instead, create a null constant and copy it to the destination.
540  // TODO: there are other patterns besides zero that we can usefully memset,
541  // like -1, which happens to be the pattern used by member-pointers.
542  // TODO: isZeroInitializable can be over-conservative in the case where a
543  // virtual base contains a member pointer.
544  llvm::Constant *NullConstantForBase = CGF.CGM.EmitNullConstantForBase(Base);
545  if (!NullConstantForBase->isNullValue()) {
546  llvm::GlobalVariable *NullVariable = new llvm::GlobalVariable(
547  CGF.CGM.getModule(), NullConstantForBase->getType(),
548  /*isConstant=*/true, llvm::GlobalVariable::PrivateLinkage,
549  NullConstantForBase, Twine());
550 
551  CharUnits Align = std::max(Layout.getNonVirtualAlignment(),
552  DestPtr.getAlignment());
553  NullVariable->setAlignment(Align.getAsAlign());
554 
555  Address SrcPtr = Address(CGF.EmitCastToVoidPtr(NullVariable), Align);
556 
557  // Get and call the appropriate llvm.memcpy overload.
558  for (std::pair<CharUnits, CharUnits> Store : Stores) {
559  CharUnits StoreOffset = Store.first;
560  CharUnits StoreSize = Store.second;
561  llvm::Value *StoreSizeVal = CGF.CGM.getSize(StoreSize);
562  CGF.Builder.CreateMemCpy(
563  CGF.Builder.CreateConstInBoundsByteGEP(DestPtr, StoreOffset),
564  CGF.Builder.CreateConstInBoundsByteGEP(SrcPtr, StoreOffset),
565  StoreSizeVal);
566  }
567 
568  // Otherwise, just memset the whole thing to zero. This is legal
569  // because in LLVM, all default initializers (other than the ones we just
570  // handled above) are guaranteed to have a bit pattern of all zeros.
571  } else {
572  for (std::pair<CharUnits, CharUnits> Store : Stores) {
573  CharUnits StoreOffset = Store.first;
574  CharUnits StoreSize = Store.second;
575  llvm::Value *StoreSizeVal = CGF.CGM.getSize(StoreSize);
576  CGF.Builder.CreateMemSet(
577  CGF.Builder.CreateConstInBoundsByteGEP(DestPtr, StoreOffset),
578  CGF.Builder.getInt8(0), StoreSizeVal);
579  }
580  }
581 }
582 
583 void
585  AggValueSlot Dest) {
586  assert(!Dest.isIgnored() && "Must have a destination!");
587  const CXXConstructorDecl *CD = E->getConstructor();
588 
589  // If we require zero initialization before (or instead of) calling the
590  // constructor, as can be the case with a non-user-provided default
591  // constructor, emit the zero initialization now, unless destination is
592  // already zeroed.
593  if (E->requiresZeroInitialization() && !Dest.isZeroed()) {
594  switch (E->getConstructionKind()) {
598  break;
602  CD->getParent());
603  break;
604  }
605  }
606 
607  // If this is a call to a trivial default constructor, do nothing.
608  if (CD->isTrivial() && CD->isDefaultConstructor())
609  return;
610 
611  // Elide the constructor if we're constructing from a temporary.
612  if (getLangOpts().ElideConstructors && E->isElidable()) {
613  // FIXME: This only handles the simplest case, where the source object
614  // is passed directly as the first argument to the constructor.
615  // This should also handle stepping though implicit casts and
616  // conversion sequences which involve two steps, with a
617  // conversion operator followed by a converting constructor.
618  const Expr *SrcObj = E->getArg(0);
619  assert(SrcObj->isTemporaryObject(getContext(), CD->getParent()));
620  assert(
621  getContext().hasSameUnqualifiedType(E->getType(), SrcObj->getType()));
622  EmitAggExpr(SrcObj, Dest);
623  return;
624  }
625 
626  if (const ArrayType *arrayType
627  = getContext().getAsArrayType(E->getType())) {
629  Dest.isSanitizerChecked());
630  } else {
632  bool ForVirtualBase = false;
633  bool Delegating = false;
634 
635  switch (E->getConstructionKind()) {
637  // We should be emitting a constructor; GlobalDecl will assert this
638  Type = CurGD.getCtorType();
639  Delegating = true;
640  break;
641 
644  break;
645 
647  ForVirtualBase = true;
648  LLVM_FALLTHROUGH;
649 
651  Type = Ctor_Base;
652  }
653 
654  // Call the constructor.
655  EmitCXXConstructorCall(CD, Type, ForVirtualBase, Delegating, Dest, E);
656  }
657 }
658 
660  const Expr *Exp) {
661  if (const ExprWithCleanups *E = dyn_cast<ExprWithCleanups>(Exp))
662  Exp = E->getSubExpr();
663  assert(isa<CXXConstructExpr>(Exp) &&
664  "EmitSynthesizedCXXCopyCtor - unknown copy ctor expr");
665  const CXXConstructExpr* E = cast<CXXConstructExpr>(Exp);
666  const CXXConstructorDecl *CD = E->getConstructor();
667  RunCleanupsScope Scope(*this);
668 
669  // If we require zero initialization before (or instead of) calling the
670  // constructor, as can be the case with a non-user-provided default
671  // constructor, emit the zero initialization now.
672  // FIXME. Do I still need this for a copy ctor synthesis?
674  EmitNullInitialization(Dest, E->getType());
675 
676  assert(!getContext().getAsConstantArrayType(E->getType())
677  && "EmitSynthesizedCXXCopyCtor - Copied-in Array");
678  EmitSynthesizedCXXCopyCtorCall(CD, Dest, Src, E);
679 }
680 
682  const CXXNewExpr *E) {
683  if (!E->isArray())
684  return CharUnits::Zero();
685 
686  // No cookie is required if the operator new[] being used is the
687  // reserved placement operator new[].
689  return CharUnits::Zero();
690 
691  return CGF.CGM.getCXXABI().GetArrayCookieSize(E);
692 }
693 
695  const CXXNewExpr *e,
696  unsigned minElements,
697  llvm::Value *&numElements,
698  llvm::Value *&sizeWithoutCookie) {
700 
701  if (!e->isArray()) {
702  CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type);
703  sizeWithoutCookie
704  = llvm::ConstantInt::get(CGF.SizeTy, typeSize.getQuantity());
705  return sizeWithoutCookie;
706  }
707 
708  // The width of size_t.
709  unsigned sizeWidth = CGF.SizeTy->getBitWidth();
710 
711  // Figure out the cookie size.
712  llvm::APInt cookieSize(sizeWidth,
713  CalculateCookiePadding(CGF, e).getQuantity());
714 
715  // Emit the array size expression.
716  // We multiply the size of all dimensions for NumElements.
717  // e.g for 'int[2][3]', ElemType is 'int' and NumElements is 6.
718  numElements =
720  if (!numElements)
721  numElements = CGF.EmitScalarExpr(*e->getArraySize());
722  assert(isa<llvm::IntegerType>(numElements->getType()));
723 
724  // The number of elements can be have an arbitrary integer type;
725  // essentially, we need to multiply it by a constant factor, add a
726  // cookie size, and verify that the result is representable as a
727  // size_t. That's just a gloss, though, and it's wrong in one
728  // important way: if the count is negative, it's an error even if
729  // the cookie size would bring the total size >= 0.
730  bool isSigned
731  = (*e->getArraySize())->getType()->isSignedIntegerOrEnumerationType();
732  llvm::IntegerType *numElementsType
733  = cast<llvm::IntegerType>(numElements->getType());
734  unsigned numElementsWidth = numElementsType->getBitWidth();
735 
736  // Compute the constant factor.
737  llvm::APInt arraySizeMultiplier(sizeWidth, 1);
738  while (const ConstantArrayType *CAT
740  type = CAT->getElementType();
741  arraySizeMultiplier *= CAT->getSize();
742  }
743 
744  CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type);
745  llvm::APInt typeSizeMultiplier(sizeWidth, typeSize.getQuantity());
746  typeSizeMultiplier *= arraySizeMultiplier;
747 
748  // This will be a size_t.
749  llvm::Value *size;
750 
751  // If someone is doing 'new int[42]' there is no need to do a dynamic check.
752  // Don't bloat the -O0 code.
753  if (llvm::ConstantInt *numElementsC =
754  dyn_cast<llvm::ConstantInt>(numElements)) {
755  const llvm::APInt &count = numElementsC->getValue();
756 
757  bool hasAnyOverflow = false;
758 
759  // If 'count' was a negative number, it's an overflow.
760  if (isSigned && count.isNegative())
761  hasAnyOverflow = true;
762 
763  // We want to do all this arithmetic in size_t. If numElements is
764  // wider than that, check whether it's already too big, and if so,
765  // overflow.
766  else if (numElementsWidth > sizeWidth &&
767  numElementsWidth - sizeWidth > count.countLeadingZeros())
768  hasAnyOverflow = true;
769 
770  // Okay, compute a count at the right width.
771  llvm::APInt adjustedCount = count.zextOrTrunc(sizeWidth);
772 
773  // If there is a brace-initializer, we cannot allocate fewer elements than
774  // there are initializers. If we do, that's treated like an overflow.
775  if (adjustedCount.ult(minElements))
776  hasAnyOverflow = true;
777 
778  // Scale numElements by that. This might overflow, but we don't
779  // care because it only overflows if allocationSize does, too, and
780  // if that overflows then we shouldn't use this.
781  numElements = llvm::ConstantInt::get(CGF.SizeTy,
782  adjustedCount * arraySizeMultiplier);
783 
784  // Compute the size before cookie, and track whether it overflowed.
785  bool overflow;
786  llvm::APInt allocationSize
787  = adjustedCount.umul_ov(typeSizeMultiplier, overflow);
788  hasAnyOverflow |= overflow;
789 
790  // Add in the cookie, and check whether it's overflowed.
791  if (cookieSize != 0) {
792  // Save the current size without a cookie. This shouldn't be
793  // used if there was overflow.
794  sizeWithoutCookie = llvm::ConstantInt::get(CGF.SizeTy, allocationSize);
795 
796  allocationSize = allocationSize.uadd_ov(cookieSize, overflow);
797  hasAnyOverflow |= overflow;
798  }
799 
800  // On overflow, produce a -1 so operator new will fail.
801  if (hasAnyOverflow) {
802  size = llvm::Constant::getAllOnesValue(CGF.SizeTy);
803  } else {
804  size = llvm::ConstantInt::get(CGF.SizeTy, allocationSize);
805  }
806 
807  // Otherwise, we might need to use the overflow intrinsics.
808  } else {
809  // There are up to five conditions we need to test for:
810  // 1) if isSigned, we need to check whether numElements is negative;
811  // 2) if numElementsWidth > sizeWidth, we need to check whether
812  // numElements is larger than something representable in size_t;
813  // 3) if minElements > 0, we need to check whether numElements is smaller
814  // than that.
815  // 4) we need to compute
816  // sizeWithoutCookie := numElements * typeSizeMultiplier
817  // and check whether it overflows; and
818  // 5) if we need a cookie, we need to compute
819  // size := sizeWithoutCookie + cookieSize
820  // and check whether it overflows.
821 
822  llvm::Value *hasOverflow = nullptr;
823 
824  // If numElementsWidth > sizeWidth, then one way or another, we're
825  // going to have to do a comparison for (2), and this happens to
826  // take care of (1), too.
827  if (numElementsWidth > sizeWidth) {
828  llvm::APInt threshold(numElementsWidth, 1);
829  threshold <<= sizeWidth;
830 
831  llvm::Value *thresholdV
832  = llvm::ConstantInt::get(numElementsType, threshold);
833 
834  hasOverflow = CGF.Builder.CreateICmpUGE(numElements, thresholdV);
835  numElements = CGF.Builder.CreateTrunc(numElements, CGF.SizeTy);
836 
837  // Otherwise, if we're signed, we want to sext up to size_t.
838  } else if (isSigned) {
839  if (numElementsWidth < sizeWidth)
840  numElements = CGF.Builder.CreateSExt(numElements, CGF.SizeTy);
841 
842  // If there's a non-1 type size multiplier, then we can do the
843  // signedness check at the same time as we do the multiply
844  // because a negative number times anything will cause an
845  // unsigned overflow. Otherwise, we have to do it here. But at least
846  // in this case, we can subsume the >= minElements check.
847  if (typeSizeMultiplier == 1)
848  hasOverflow = CGF.Builder.CreateICmpSLT(numElements,
849  llvm::ConstantInt::get(CGF.SizeTy, minElements));
850 
851  // Otherwise, zext up to size_t if necessary.
852  } else if (numElementsWidth < sizeWidth) {
853  numElements = CGF.Builder.CreateZExt(numElements, CGF.SizeTy);
854  }
855 
856  assert(numElements->getType() == CGF.SizeTy);
857 
858  if (minElements) {
859  // Don't allow allocation of fewer elements than we have initializers.
860  if (!hasOverflow) {
861  hasOverflow = CGF.Builder.CreateICmpULT(numElements,
862  llvm::ConstantInt::get(CGF.SizeTy, minElements));
863  } else if (numElementsWidth > sizeWidth) {
864  // The other existing overflow subsumes this check.
865  // We do an unsigned comparison, since any signed value < -1 is
866  // taken care of either above or below.
867  hasOverflow = CGF.Builder.CreateOr(hasOverflow,
868  CGF.Builder.CreateICmpULT(numElements,
869  llvm::ConstantInt::get(CGF.SizeTy, minElements)));
870  }
871  }
872 
873  size = numElements;
874 
875  // Multiply by the type size if necessary. This multiplier
876  // includes all the factors for nested arrays.
877  //
878  // This step also causes numElements to be scaled up by the
879  // nested-array factor if necessary. Overflow on this computation
880  // can be ignored because the result shouldn't be used if
881  // allocation fails.
882  if (typeSizeMultiplier != 1) {
883  llvm::Function *umul_with_overflow
884  = CGF.CGM.getIntrinsic(llvm::Intrinsic::umul_with_overflow, CGF.SizeTy);
885 
886  llvm::Value *tsmV =
887  llvm::ConstantInt::get(CGF.SizeTy, typeSizeMultiplier);
888  llvm::Value *result =
889  CGF.Builder.CreateCall(umul_with_overflow, {size, tsmV});
890 
891  llvm::Value *overflowed = CGF.Builder.CreateExtractValue(result, 1);
892  if (hasOverflow)
893  hasOverflow = CGF.Builder.CreateOr(hasOverflow, overflowed);
894  else
895  hasOverflow = overflowed;
896 
897  size = CGF.Builder.CreateExtractValue(result, 0);
898 
899  // Also scale up numElements by the array size multiplier.
900  if (arraySizeMultiplier != 1) {
901  // If the base element type size is 1, then we can re-use the
902  // multiply we just did.
903  if (typeSize.isOne()) {
904  assert(arraySizeMultiplier == typeSizeMultiplier);
905  numElements = size;
906 
907  // Otherwise we need a separate multiply.
908  } else {
909  llvm::Value *asmV =
910  llvm::ConstantInt::get(CGF.SizeTy, arraySizeMultiplier);
911  numElements = CGF.Builder.CreateMul(numElements, asmV);
912  }
913  }
914  } else {
915  // numElements doesn't need to be scaled.
916  assert(arraySizeMultiplier == 1);
917  }
918 
919  // Add in the cookie size if necessary.
920  if (cookieSize != 0) {
921  sizeWithoutCookie = size;
922 
923  llvm::Function *uadd_with_overflow
924  = CGF.CGM.getIntrinsic(llvm::Intrinsic::uadd_with_overflow, CGF.SizeTy);
925 
926  llvm::Value *cookieSizeV = llvm::ConstantInt::get(CGF.SizeTy, cookieSize);
927  llvm::Value *result =
928  CGF.Builder.CreateCall(uadd_with_overflow, {size, cookieSizeV});
929 
930  llvm::Value *overflowed = CGF.Builder.CreateExtractValue(result, 1);
931  if (hasOverflow)
932  hasOverflow = CGF.Builder.CreateOr(hasOverflow, overflowed);
933  else
934  hasOverflow = overflowed;
935 
936  size = CGF.Builder.CreateExtractValue(result, 0);
937  }
938 
939  // If we had any possibility of dynamic overflow, make a select to
940  // overwrite 'size' with an all-ones value, which should cause
941  // operator new to throw.
942  if (hasOverflow)
943  size = CGF.Builder.CreateSelect(hasOverflow,
944  llvm::Constant::getAllOnesValue(CGF.SizeTy),
945  size);
946  }
947 
948  if (cookieSize == 0)
949  sizeWithoutCookie = size;
950  else
951  assert(sizeWithoutCookie && "didn't set sizeWithoutCookie?");
952 
953  return size;
954 }
955 
956 static void StoreAnyExprIntoOneUnit(CodeGenFunction &CGF, const Expr *Init,
957  QualType AllocType, Address NewPtr,
958  AggValueSlot::Overlap_t MayOverlap) {
959  // FIXME: Refactor with EmitExprAsInit.
960  switch (CGF.getEvaluationKind(AllocType)) {
961  case TEK_Scalar:
962  CGF.EmitScalarInit(Init, nullptr,
963  CGF.MakeAddrLValue(NewPtr, AllocType), false);
964  return;
965  case TEK_Complex:
966  CGF.EmitComplexExprIntoLValue(Init, CGF.MakeAddrLValue(NewPtr, AllocType),
967  /*isInit*/ true);
968  return;
969  case TEK_Aggregate: {
970  AggValueSlot Slot
971  = AggValueSlot::forAddr(NewPtr, AllocType.getQualifiers(),
975  MayOverlap, AggValueSlot::IsNotZeroed,
977  CGF.EmitAggExpr(Init, Slot);
978  return;
979  }
980  }
981  llvm_unreachable("bad evaluation kind");
982 }
983 
985  const CXXNewExpr *E, QualType ElementType, llvm::Type *ElementTy,
986  Address BeginPtr, llvm::Value *NumElements,
987  llvm::Value *AllocSizeWithoutCookie) {
988  // If we have a type with trivial initialization and no initializer,
989  // there's nothing to do.
990  if (!E->hasInitializer())
991  return;
992 
993  Address CurPtr = BeginPtr;
994 
995  unsigned InitListElements = 0;
996 
997  const Expr *Init = E->getInitializer();
998  Address EndOfInit = Address::invalid();
999  QualType::DestructionKind DtorKind = ElementType.isDestructedType();
1001  llvm::Instruction *CleanupDominator = nullptr;
1002 
1003  CharUnits ElementSize = getContext().getTypeSizeInChars(ElementType);
1004  CharUnits ElementAlign =
1005  BeginPtr.getAlignment().alignmentOfArrayElement(ElementSize);
1006 
1007  // Attempt to perform zero-initialization using memset.
1008  auto TryMemsetInitialization = [&]() -> bool {
1009  // FIXME: If the type is a pointer-to-data-member under the Itanium ABI,
1010  // we can initialize with a memset to -1.
1011  if (!CGM.getTypes().isZeroInitializable(ElementType))
1012  return false;
1013 
1014  // Optimization: since zero initialization will just set the memory
1015  // to all zeroes, generate a single memset to do it in one shot.
1016 
1017  // Subtract out the size of any elements we've already initialized.
1018  auto *RemainingSize = AllocSizeWithoutCookie;
1019  if (InitListElements) {
1020  // We know this can't overflow; we check this when doing the allocation.
1021  auto *InitializedSize = llvm::ConstantInt::get(
1022  RemainingSize->getType(),
1023  getContext().getTypeSizeInChars(ElementType).getQuantity() *
1024  InitListElements);
1025  RemainingSize = Builder.CreateSub(RemainingSize, InitializedSize);
1026  }
1027 
1028  // Create the memset.
1029  Builder.CreateMemSet(CurPtr, Builder.getInt8(0), RemainingSize, false);
1030  return true;
1031  };
1032 
1033  // If the initializer is an initializer list, first do the explicit elements.
1034  if (const InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
1035  // Initializing from a (braced) string literal is a special case; the init
1036  // list element does not initialize a (single) array element.
1037  if (ILE->isStringLiteralInit()) {
1038  // Initialize the initial portion of length equal to that of the string
1039  // literal. The allocation must be for at least this much; we emitted a
1040  // check for that earlier.
1041  AggValueSlot Slot =
1042  AggValueSlot::forAddr(CurPtr, ElementType.getQualifiers(),
1049  EmitAggExpr(ILE->getInit(0), Slot);
1050 
1051  // Move past these elements.
1052  InitListElements =
1053  cast<ConstantArrayType>(ILE->getType()->getAsArrayTypeUnsafe())
1054  ->getSize().getZExtValue();
1055  CurPtr =
1056  Address(Builder.CreateInBoundsGEP(CurPtr.getElementType(),
1057  CurPtr.getPointer(),
1058  Builder.getSize(InitListElements),
1059  "string.init.end"),
1060  CurPtr.getAlignment().alignmentAtOffset(InitListElements *
1061  ElementSize));
1062 
1063  // Zero out the rest, if any remain.
1064  llvm::ConstantInt *ConstNum = dyn_cast<llvm::ConstantInt>(NumElements);
1065  if (!ConstNum || !ConstNum->equalsInt(InitListElements)) {
1066  bool OK = TryMemsetInitialization();
1067  (void)OK;
1068  assert(OK && "couldn't memset character type?");
1069  }
1070  return;
1071  }
1072 
1073  InitListElements = ILE->getNumInits();
1074 
1075  // If this is a multi-dimensional array new, we will initialize multiple
1076  // elements with each init list element.
1077  QualType AllocType = E->getAllocatedType();
1078  if (const ConstantArrayType *CAT = dyn_cast_or_null<ConstantArrayType>(
1079  AllocType->getAsArrayTypeUnsafe())) {
1080  ElementTy = ConvertTypeForMem(AllocType);
1081  CurPtr = Builder.CreateElementBitCast(CurPtr, ElementTy);
1082  InitListElements *= getContext().getConstantArrayElementCount(CAT);
1083  }
1084 
1085  // Enter a partial-destruction Cleanup if necessary.
1086  if (needsEHCleanup(DtorKind)) {
1087  // In principle we could tell the Cleanup where we are more
1088  // directly, but the control flow can get so varied here that it
1089  // would actually be quite complex. Therefore we go through an
1090  // alloca.
1091  EndOfInit = CreateTempAlloca(BeginPtr.getType(), getPointerAlign(),
1092  "array.init.end");
1093  CleanupDominator = Builder.CreateStore(BeginPtr.getPointer(), EndOfInit);
1094  pushIrregularPartialArrayCleanup(BeginPtr.getPointer(), EndOfInit,
1095  ElementType, ElementAlign,
1096  getDestroyer(DtorKind));
1097  Cleanup = EHStack.stable_begin();
1098  }
1099 
1100  CharUnits StartAlign = CurPtr.getAlignment();
1101  for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i) {
1102  // Tell the cleanup that it needs to destroy up to this
1103  // element. TODO: some of these stores can be trivially
1104  // observed to be unnecessary.
1105  if (EndOfInit.isValid()) {
1106  auto FinishedPtr =
1107  Builder.CreateBitCast(CurPtr.getPointer(), BeginPtr.getType());
1108  Builder.CreateStore(FinishedPtr, EndOfInit);
1109  }
1110  // FIXME: If the last initializer is an incomplete initializer list for
1111  // an array, and we have an array filler, we can fold together the two
1112  // initialization loops.
1113  StoreAnyExprIntoOneUnit(*this, ILE->getInit(i),
1114  ILE->getInit(i)->getType(), CurPtr,
1116  CurPtr = Address(Builder.CreateInBoundsGEP(CurPtr.getElementType(),
1117  CurPtr.getPointer(),
1118  Builder.getSize(1),
1119  "array.exp.next"),
1120  StartAlign.alignmentAtOffset((i + 1) * ElementSize));
1121  }
1122 
1123  // The remaining elements are filled with the array filler expression.
1124  Init = ILE->getArrayFiller();
1125 
1126  // Extract the initializer for the individual array elements by pulling
1127  // out the array filler from all the nested initializer lists. This avoids
1128  // generating a nested loop for the initialization.
1129  while (Init && Init->getType()->isConstantArrayType()) {
1130  auto *SubILE = dyn_cast<InitListExpr>(Init);
1131  if (!SubILE)
1132  break;
1133  assert(SubILE->getNumInits() == 0 && "explicit inits in array filler?");
1134  Init = SubILE->getArrayFiller();
1135  }
1136 
1137  // Switch back to initializing one base element at a time.
1138  CurPtr = Builder.CreateBitCast(CurPtr, BeginPtr.getType());
1139  }
1140 
1141  // If all elements have already been initialized, skip any further
1142  // initialization.
1143  llvm::ConstantInt *ConstNum = dyn_cast<llvm::ConstantInt>(NumElements);
1144  if (ConstNum && ConstNum->getZExtValue() <= InitListElements) {
1145  // If there was a Cleanup, deactivate it.
1146  if (CleanupDominator)
1147  DeactivateCleanupBlock(Cleanup, CleanupDominator);
1148  return;
1149  }
1150 
1151  assert(Init && "have trailing elements to initialize but no initializer");
1152 
1153  // If this is a constructor call, try to optimize it out, and failing that
1154  // emit a single loop to initialize all remaining elements.
1155  if (const CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init)) {
1156  CXXConstructorDecl *Ctor = CCE->getConstructor();
1157  if (Ctor->isTrivial()) {
1158  // If new expression did not specify value-initialization, then there
1159  // is no initialization.
1160  if (!CCE->requiresZeroInitialization() || Ctor->getParent()->isEmpty())
1161  return;
1162 
1163  if (TryMemsetInitialization())
1164  return;
1165  }
1166 
1167  // Store the new Cleanup position for irregular Cleanups.
1168  //
1169  // FIXME: Share this cleanup with the constructor call emission rather than
1170  // having it create a cleanup of its own.
1171  if (EndOfInit.isValid())
1172  Builder.CreateStore(CurPtr.getPointer(), EndOfInit);
1173 
1174  // Emit a constructor call loop to initialize the remaining elements.
1175  if (InitListElements)
1176  NumElements = Builder.CreateSub(
1177  NumElements,
1178  llvm::ConstantInt::get(NumElements->getType(), InitListElements));
1179  EmitCXXAggrConstructorCall(Ctor, NumElements, CurPtr, CCE,
1180  /*NewPointerIsChecked*/true,
1181  CCE->requiresZeroInitialization());
1182  return;
1183  }
1184 
1185  // If this is value-initialization, we can usually use memset.
1186  ImplicitValueInitExpr IVIE(ElementType);
1187  if (isa<ImplicitValueInitExpr>(Init)) {
1188  if (TryMemsetInitialization())
1189  return;
1190 
1191  // Switch to an ImplicitValueInitExpr for the element type. This handles
1192  // only one case: multidimensional array new of pointers to members. In
1193  // all other cases, we already have an initializer for the array element.
1194  Init = &IVIE;
1195  }
1196 
1197  // At this point we should have found an initializer for the individual
1198  // elements of the array.
1199  assert(getContext().hasSameUnqualifiedType(ElementType, Init->getType()) &&
1200  "got wrong type of element to initialize");
1201 
1202  // If we have an empty initializer list, we can usually use memset.
1203  if (auto *ILE = dyn_cast<InitListExpr>(Init))
1204  if (ILE->getNumInits() == 0 && TryMemsetInitialization())
1205  return;
1206 
1207  // If we have a struct whose every field is value-initialized, we can
1208  // usually use memset.
1209  if (auto *ILE = dyn_cast<InitListExpr>(Init)) {
1210  if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
1211  if (RType->getDecl()->isStruct()) {
1212  unsigned NumElements = 0;
1213  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RType->getDecl()))
1214  NumElements = CXXRD->getNumBases();
1215  for (auto *Field : RType->getDecl()->fields())
1216  if (!Field->isUnnamedBitfield())
1217  ++NumElements;
1218  // FIXME: Recurse into nested InitListExprs.
1219  if (ILE->getNumInits() == NumElements)
1220  for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i)
1221  if (!isa<ImplicitValueInitExpr>(ILE->getInit(i)))
1222  --NumElements;
1223  if (ILE->getNumInits() == NumElements && TryMemsetInitialization())
1224  return;
1225  }
1226  }
1227  }
1228 
1229  // Create the loop blocks.
1230  llvm::BasicBlock *EntryBB = Builder.GetInsertBlock();
1231  llvm::BasicBlock *LoopBB = createBasicBlock("new.loop");
1232  llvm::BasicBlock *ContBB = createBasicBlock("new.loop.end");
1233 
1234  // Find the end of the array, hoisted out of the loop.
1235  llvm::Value *EndPtr =
1236  Builder.CreateInBoundsGEP(BeginPtr.getElementType(), BeginPtr.getPointer(),
1237  NumElements, "array.end");
1238 
1239  // If the number of elements isn't constant, we have to now check if there is
1240  // anything left to initialize.
1241  if (!ConstNum) {
1242  llvm::Value *IsEmpty =
1243  Builder.CreateICmpEQ(CurPtr.getPointer(), EndPtr, "array.isempty");
1244  Builder.CreateCondBr(IsEmpty, ContBB, LoopBB);
1245  }
1246 
1247  // Enter the loop.
1248  EmitBlock(LoopBB);
1249 
1250  // Set up the current-element phi.
1251  llvm::PHINode *CurPtrPhi =
1252  Builder.CreatePHI(CurPtr.getType(), 2, "array.cur");
1253  CurPtrPhi->addIncoming(CurPtr.getPointer(), EntryBB);
1254 
1255  CurPtr = Address(CurPtrPhi, ElementAlign);
1256 
1257  // Store the new Cleanup position for irregular Cleanups.
1258  if (EndOfInit.isValid())
1259  Builder.CreateStore(CurPtr.getPointer(), EndOfInit);
1260 
1261  // Enter a partial-destruction Cleanup if necessary.
1262  if (!CleanupDominator && needsEHCleanup(DtorKind)) {
1264  ElementType, ElementAlign,
1265  getDestroyer(DtorKind));
1266  Cleanup = EHStack.stable_begin();
1267  CleanupDominator = Builder.CreateUnreachable();
1268  }
1269 
1270  // Emit the initializer into this element.
1271  StoreAnyExprIntoOneUnit(*this, Init, Init->getType(), CurPtr,
1273 
1274  // Leave the Cleanup if we entered one.
1275  if (CleanupDominator) {
1276  DeactivateCleanupBlock(Cleanup, CleanupDominator);
1277  CleanupDominator->eraseFromParent();
1278  }
1279 
1280  // Advance to the next element by adjusting the pointer type as necessary.
1281  llvm::Value *NextPtr =
1282  Builder.CreateConstInBoundsGEP1_32(ElementTy, CurPtr.getPointer(), 1,
1283  "array.next");
1284 
1285  // Check whether we've gotten to the end of the array and, if so,
1286  // exit the loop.
1287  llvm::Value *IsEnd = Builder.CreateICmpEQ(NextPtr, EndPtr, "array.atend");
1288  Builder.CreateCondBr(IsEnd, ContBB, LoopBB);
1289  CurPtrPhi->addIncoming(NextPtr, Builder.GetInsertBlock());
1290 
1291  EmitBlock(ContBB);
1292 }
1293 
1294 static void EmitNewInitializer(CodeGenFunction &CGF, const CXXNewExpr *E,
1295  QualType ElementType, llvm::Type *ElementTy,
1296  Address NewPtr, llvm::Value *NumElements,
1297  llvm::Value *AllocSizeWithoutCookie) {
1298  ApplyDebugLocation DL(CGF, E);
1299  if (E->isArray())
1300  CGF.EmitNewArrayInitializer(E, ElementType, ElementTy, NewPtr, NumElements,
1301  AllocSizeWithoutCookie);
1302  else if (const Expr *Init = E->getInitializer())
1303  StoreAnyExprIntoOneUnit(CGF, Init, E->getAllocatedType(), NewPtr,
1305 }
1306 
1307 /// Emit a call to an operator new or operator delete function, as implicitly
1308 /// created by new-expressions and delete-expressions.
1310  const FunctionDecl *CalleeDecl,
1311  const FunctionProtoType *CalleeType,
1312  const CallArgList &Args) {
1313  llvm::CallBase *CallOrInvoke;
1314  llvm::Constant *CalleePtr = CGF.CGM.GetAddrOfFunction(CalleeDecl);
1315  CGCallee Callee = CGCallee::forDirect(CalleePtr, GlobalDecl(CalleeDecl));
1316  RValue RV =
1318  Args, CalleeType, /*ChainCall=*/false),
1319  Callee, ReturnValueSlot(), Args, &CallOrInvoke);
1320 
1321  /// C++1y [expr.new]p10:
1322  /// [In a new-expression,] an implementation is allowed to omit a call
1323  /// to a replaceable global allocation function.
1324  ///
1325  /// We model such elidable calls with the 'builtin' attribute.
1326  llvm::Function *Fn = dyn_cast<llvm::Function>(CalleePtr);
1327  if (CalleeDecl->isReplaceableGlobalAllocationFunction() &&
1328  Fn && Fn->hasFnAttribute(llvm::Attribute::NoBuiltin)) {
1329  CallOrInvoke->addFnAttr(llvm::Attribute::Builtin);
1330  }
1331 
1332  return RV;
1333 }
1334 
1336  const CallExpr *TheCall,
1337  bool IsDelete) {
1338  CallArgList Args;
1339  EmitCallArgs(Args, Type, TheCall->arguments());
1340  // Find the allocation or deallocation function that we're calling.
1341  ASTContext &Ctx = getContext();
1343  .getCXXOperatorName(IsDelete ? OO_Delete : OO_New);
1344 
1345  for (auto *Decl : Ctx.getTranslationUnitDecl()->lookup(Name))
1346  if (auto *FD = dyn_cast<FunctionDecl>(Decl))
1347  if (Ctx.hasSameType(FD->getType(), QualType(Type, 0)))
1348  return EmitNewDeleteCall(*this, FD, Type, Args);
1349  llvm_unreachable("predeclared global operator new/delete is missing");
1350 }
1351 
1352 namespace {
1353 /// The parameters to pass to a usual operator delete.
1354 struct UsualDeleteParams {
1355  bool DestroyingDelete = false;
1356  bool Size = false;
1357  bool Alignment = false;
1358 };
1359 }
1360 
1361 static UsualDeleteParams getUsualDeleteParams(const FunctionDecl *FD) {
1362  UsualDeleteParams Params;
1363 
1364  const FunctionProtoType *FPT = FD->getType()->castAs<FunctionProtoType>();
1365  auto AI = FPT->param_type_begin(), AE = FPT->param_type_end();
1366 
1367  // The first argument is always a void*.
1368  ++AI;
1369 
1370  // The next parameter may be a std::destroying_delete_t.
1371  if (FD->isDestroyingOperatorDelete()) {
1372  Params.DestroyingDelete = true;
1373  assert(AI != AE);
1374  ++AI;
1375  }
1376 
1377  // Figure out what other parameters we should be implicitly passing.
1378  if (AI != AE && (*AI)->isIntegerType()) {
1379  Params.Size = true;
1380  ++AI;
1381  }
1382 
1383  if (AI != AE && (*AI)->isAlignValT()) {
1384  Params.Alignment = true;
1385  ++AI;
1386  }
1387 
1388  assert(AI == AE && "unexpected usual deallocation function parameter");
1389  return Params;
1390 }
1391 
1392 namespace {
1393  /// A cleanup to call the given 'operator delete' function upon abnormal
1394  /// exit from a new expression. Templated on a traits type that deals with
1395  /// ensuring that the arguments dominate the cleanup if necessary.
1396  template<typename Traits>
1397  class CallDeleteDuringNew final : public EHScopeStack::Cleanup {
1398  /// Type used to hold llvm::Value*s.
1399  typedef typename Traits::ValueTy ValueTy;
1400  /// Type used to hold RValues.
1401  typedef typename Traits::RValueTy RValueTy;
1402  struct PlacementArg {
1403  RValueTy ArgValue;
1404  QualType ArgType;
1405  };
1406 
1407  unsigned NumPlacementArgs : 31;
1408  unsigned PassAlignmentToPlacementDelete : 1;
1409  const FunctionDecl *OperatorDelete;
1410  ValueTy Ptr;
1411  ValueTy AllocSize;
1412  CharUnits AllocAlign;
1413 
1414  PlacementArg *getPlacementArgs() {
1415  return reinterpret_cast<PlacementArg *>(this + 1);
1416  }
1417 
1418  public:
1419  static size_t getExtraSize(size_t NumPlacementArgs) {
1420  return NumPlacementArgs * sizeof(PlacementArg);
1421  }
1422 
1423  CallDeleteDuringNew(size_t NumPlacementArgs,
1424  const FunctionDecl *OperatorDelete, ValueTy Ptr,
1425  ValueTy AllocSize, bool PassAlignmentToPlacementDelete,
1426  CharUnits AllocAlign)
1427  : NumPlacementArgs(NumPlacementArgs),
1428  PassAlignmentToPlacementDelete(PassAlignmentToPlacementDelete),
1429  OperatorDelete(OperatorDelete), Ptr(Ptr), AllocSize(AllocSize),
1430  AllocAlign(AllocAlign) {}
1431 
1432  void setPlacementArg(unsigned I, RValueTy Arg, QualType Type) {
1433  assert(I < NumPlacementArgs && "index out of range");
1434  getPlacementArgs()[I] = {Arg, Type};
1435  }
1436 
1437  void Emit(CodeGenFunction &CGF, Flags flags) override {
1438  const auto *FPT = OperatorDelete->getType()->castAs<FunctionProtoType>();
1439  CallArgList DeleteArgs;
1440 
1441  // The first argument is always a void* (or C* for a destroying operator
1442  // delete for class type C).
1443  DeleteArgs.add(Traits::get(CGF, Ptr), FPT->getParamType(0));
1444 
1445  // Figure out what other parameters we should be implicitly passing.
1446  UsualDeleteParams Params;
1447  if (NumPlacementArgs) {
1448  // A placement deallocation function is implicitly passed an alignment
1449  // if the placement allocation function was, but is never passed a size.
1450  Params.Alignment = PassAlignmentToPlacementDelete;
1451  } else {
1452  // For a non-placement new-expression, 'operator delete' can take a
1453  // size and/or an alignment if it has the right parameters.
1454  Params = getUsualDeleteParams(OperatorDelete);
1455  }
1456 
1457  assert(!Params.DestroyingDelete &&
1458  "should not call destroying delete in a new-expression");
1459 
1460  // The second argument can be a std::size_t (for non-placement delete).
1461  if (Params.Size)
1462  DeleteArgs.add(Traits::get(CGF, AllocSize),
1463  CGF.getContext().getSizeType());
1464 
1465  // The next (second or third) argument can be a std::align_val_t, which
1466  // is an enum whose underlying type is std::size_t.
1467  // FIXME: Use the right type as the parameter type. Note that in a call
1468  // to operator delete(size_t, ...), we may not have it available.
1469  if (Params.Alignment)
1470  DeleteArgs.add(RValue::get(llvm::ConstantInt::get(
1471  CGF.SizeTy, AllocAlign.getQuantity())),
1472  CGF.getContext().getSizeType());
1473 
1474  // Pass the rest of the arguments, which must match exactly.
1475  for (unsigned I = 0; I != NumPlacementArgs; ++I) {
1476  auto Arg = getPlacementArgs()[I];
1477  DeleteArgs.add(Traits::get(CGF, Arg.ArgValue), Arg.ArgType);
1478  }
1479 
1480  // Call 'operator delete'.
1481  EmitNewDeleteCall(CGF, OperatorDelete, FPT, DeleteArgs);
1482  }
1483  };
1484 }
1485 
1486 /// Enter a cleanup to call 'operator delete' if the initializer in a
1487 /// new-expression throws.
1489  const CXXNewExpr *E,
1490  Address NewPtr,
1491  llvm::Value *AllocSize,
1492  CharUnits AllocAlign,
1493  const CallArgList &NewArgs) {
1494  unsigned NumNonPlacementArgs = E->passAlignment() ? 2 : 1;
1495 
1496  // If we're not inside a conditional branch, then the cleanup will
1497  // dominate and we can do the easier (and more efficient) thing.
1498  if (!CGF.isInConditionalBranch()) {
1499  struct DirectCleanupTraits {
1500  typedef llvm::Value *ValueTy;
1501  typedef RValue RValueTy;
1502  static RValue get(CodeGenFunction &, ValueTy V) { return RValue::get(V); }
1503  static RValue get(CodeGenFunction &, RValueTy V) { return V; }
1504  };
1505 
1506  typedef CallDeleteDuringNew<DirectCleanupTraits> DirectCleanup;
1507 
1508  DirectCleanup *Cleanup = CGF.EHStack
1509  .pushCleanupWithExtra<DirectCleanup>(EHCleanup,
1510  E->getNumPlacementArgs(),
1511  E->getOperatorDelete(),
1512  NewPtr.getPointer(),
1513  AllocSize,
1514  E->passAlignment(),
1515  AllocAlign);
1516  for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) {
1517  auto &Arg = NewArgs[I + NumNonPlacementArgs];
1518  Cleanup->setPlacementArg(I, Arg.getRValue(CGF), Arg.Ty);
1519  }
1520 
1521  return;
1522  }
1523 
1524  // Otherwise, we need to save all this stuff.
1527  DominatingValue<RValue>::saved_type SavedAllocSize =
1528  DominatingValue<RValue>::save(CGF, RValue::get(AllocSize));
1529 
1530  struct ConditionalCleanupTraits {
1531  typedef DominatingValue<RValue>::saved_type ValueTy;
1532  typedef DominatingValue<RValue>::saved_type RValueTy;
1533  static RValue get(CodeGenFunction &CGF, ValueTy V) {
1534  return V.restore(CGF);
1535  }
1536  };
1537  typedef CallDeleteDuringNew<ConditionalCleanupTraits> ConditionalCleanup;
1538 
1539  ConditionalCleanup *Cleanup = CGF.EHStack
1540  .pushCleanupWithExtra<ConditionalCleanup>(EHCleanup,
1541  E->getNumPlacementArgs(),
1542  E->getOperatorDelete(),
1543  SavedNewPtr,
1544  SavedAllocSize,
1545  E->passAlignment(),
1546  AllocAlign);
1547  for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) {
1548  auto &Arg = NewArgs[I + NumNonPlacementArgs];
1549  Cleanup->setPlacementArg(
1550  I, DominatingValue<RValue>::save(CGF, Arg.getRValue(CGF)), Arg.Ty);
1551  }
1552 
1553  CGF.initFullExprCleanup();
1554 }
1555 
1557  // The element type being allocated.
1559 
1560  // 1. Build a call to the allocation function.
1561  FunctionDecl *allocator = E->getOperatorNew();
1562 
1563  // If there is a brace-initializer, cannot allocate fewer elements than inits.
1564  unsigned minElements = 0;
1565  if (E->isArray() && E->hasInitializer()) {
1566  const InitListExpr *ILE = dyn_cast<InitListExpr>(E->getInitializer());
1567  if (ILE && ILE->isStringLiteralInit())
1568  minElements =
1569  cast<ConstantArrayType>(ILE->getType()->getAsArrayTypeUnsafe())
1570  ->getSize().getZExtValue();
1571  else if (ILE)
1572  minElements = ILE->getNumInits();
1573  }
1574 
1575  llvm::Value *numElements = nullptr;
1576  llvm::Value *allocSizeWithoutCookie = nullptr;
1577  llvm::Value *allocSize =
1578  EmitCXXNewAllocSize(*this, E, minElements, numElements,
1579  allocSizeWithoutCookie);
1580  CharUnits allocAlign = getContext().getPreferredTypeAlignInChars(allocType);
1581 
1582  // Emit the allocation call. If the allocator is a global placement
1583  // operator, just "inline" it directly.
1584  Address allocation = Address::invalid();
1585  CallArgList allocatorArgs;
1586  if (allocator->isReservedGlobalPlacementOperator()) {
1587  assert(E->getNumPlacementArgs() == 1);
1588  const Expr *arg = *E->placement_arguments().begin();
1589 
1590  LValueBaseInfo BaseInfo;
1591  allocation = EmitPointerWithAlignment(arg, &BaseInfo);
1592 
1593  // The pointer expression will, in many cases, be an opaque void*.
1594  // In these cases, discard the computed alignment and use the
1595  // formal alignment of the allocated type.
1596  if (BaseInfo.getAlignmentSource() != AlignmentSource::Decl)
1597  allocation = Address(allocation.getPointer(), allocAlign);
1598 
1599  // Set up allocatorArgs for the call to operator delete if it's not
1600  // the reserved global operator.
1601  if (E->getOperatorDelete() &&
1603  allocatorArgs.add(RValue::get(allocSize), getContext().getSizeType());
1604  allocatorArgs.add(RValue::get(allocation.getPointer()), arg->getType());
1605  }
1606 
1607  } else {
1608  const FunctionProtoType *allocatorType =
1609  allocator->getType()->castAs<FunctionProtoType>();
1610  unsigned ParamsToSkip = 0;
1611 
1612  // The allocation size is the first argument.
1613  QualType sizeType = getContext().getSizeType();
1614  allocatorArgs.add(RValue::get(allocSize), sizeType);
1615  ++ParamsToSkip;
1616 
1617  if (allocSize != allocSizeWithoutCookie) {
1618  CharUnits cookieAlign = getSizeAlign(); // FIXME: Ask the ABI.
1619  allocAlign = std::max(allocAlign, cookieAlign);
1620  }
1621 
1622  // The allocation alignment may be passed as the second argument.
1623  if (E->passAlignment()) {
1624  QualType AlignValT = sizeType;
1625  if (allocatorType->getNumParams() > 1) {
1626  AlignValT = allocatorType->getParamType(1);
1627  assert(getContext().hasSameUnqualifiedType(
1628  AlignValT->castAs<EnumType>()->getDecl()->getIntegerType(),
1629  sizeType) &&
1630  "wrong type for alignment parameter");
1631  ++ParamsToSkip;
1632  } else {
1633  // Corner case, passing alignment to 'operator new(size_t, ...)'.
1634  assert(allocator->isVariadic() && "can't pass alignment to allocator");
1635  }
1636  allocatorArgs.add(
1637  RValue::get(llvm::ConstantInt::get(SizeTy, allocAlign.getQuantity())),
1638  AlignValT);
1639  }
1640 
1641  // FIXME: Why do we not pass a CalleeDecl here?
1642  EmitCallArgs(allocatorArgs, allocatorType, E->placement_arguments(),
1643  /*AC*/AbstractCallee(), /*ParamsToSkip*/ParamsToSkip);
1644 
1645  RValue RV =
1646  EmitNewDeleteCall(*this, allocator, allocatorType, allocatorArgs);
1647 
1648  // Set !heapallocsite metadata on the call to operator new.
1649  if (getDebugInfo())
1650  if (auto *newCall = dyn_cast<llvm::CallBase>(RV.getScalarVal()))
1651  getDebugInfo()->addHeapAllocSiteMetadata(newCall, allocType,
1652  E->getExprLoc());
1653 
1654  // If this was a call to a global replaceable allocation function that does
1655  // not take an alignment argument, the allocator is known to produce
1656  // storage that's suitably aligned for any object that fits, up to a known
1657  // threshold. Otherwise assume it's suitably aligned for the allocated type.
1658  CharUnits allocationAlign = allocAlign;
1659  if (!E->passAlignment() &&
1661  unsigned AllocatorAlign = llvm::PowerOf2Floor(std::min<uint64_t>(
1662  Target.getNewAlign(), getContext().getTypeSize(allocType)));
1663  allocationAlign = std::max(
1664  allocationAlign, getContext().toCharUnitsFromBits(AllocatorAlign));
1665  }
1666 
1667  allocation = Address(RV.getScalarVal(), allocationAlign);
1668  }
1669 
1670  // Emit a null check on the allocation result if the allocation
1671  // function is allowed to return null (because it has a non-throwing
1672  // exception spec or is the reserved placement new) and we have an
1673  // interesting initializer will be running sanitizers on the initialization.
1674  bool nullCheck = E->shouldNullCheckAllocation() &&
1675  (!allocType.isPODType(getContext()) || E->hasInitializer() ||
1677 
1678  llvm::BasicBlock *nullCheckBB = nullptr;
1679  llvm::BasicBlock *contBB = nullptr;
1680 
1681  // The null-check means that the initializer is conditionally
1682  // evaluated.
1683  ConditionalEvaluation conditional(*this);
1684 
1685  if (nullCheck) {
1686  conditional.begin(*this);
1687 
1688  nullCheckBB = Builder.GetInsertBlock();
1689  llvm::BasicBlock *notNullBB = createBasicBlock("new.notnull");
1690  contBB = createBasicBlock("new.cont");
1691 
1692  llvm::Value *isNull =
1693  Builder.CreateIsNull(allocation.getPointer(), "new.isnull");
1694  Builder.CreateCondBr(isNull, contBB, notNullBB);
1695  EmitBlock(notNullBB);
1696  }
1697 
1698  // If there's an operator delete, enter a cleanup to call it if an
1699  // exception is thrown.
1700  EHScopeStack::stable_iterator operatorDeleteCleanup;
1701  llvm::Instruction *cleanupDominator = nullptr;
1702  if (E->getOperatorDelete() &&
1704  EnterNewDeleteCleanup(*this, E, allocation, allocSize, allocAlign,
1705  allocatorArgs);
1706  operatorDeleteCleanup = EHStack.stable_begin();
1707  cleanupDominator = Builder.CreateUnreachable();
1708  }
1709 
1710  assert((allocSize == allocSizeWithoutCookie) ==
1711  CalculateCookiePadding(*this, E).isZero());
1712  if (allocSize != allocSizeWithoutCookie) {
1713  assert(E->isArray());
1714  allocation = CGM.getCXXABI().InitializeArrayCookie(*this, allocation,
1715  numElements,
1716  E, allocType);
1717  }
1718 
1719  llvm::Type *elementTy = ConvertTypeForMem(allocType);
1720  Address result = Builder.CreateElementBitCast(allocation, elementTy);
1721 
1722  // Passing pointer through launder.invariant.group to avoid propagation of
1723  // vptrs information which may be included in previous type.
1724  // To not break LTO with different optimizations levels, we do it regardless
1725  // of optimization level.
1726  if (CGM.getCodeGenOpts().StrictVTablePointers &&
1727  allocator->isReservedGlobalPlacementOperator())
1728  result = Address(Builder.CreateLaunderInvariantGroup(result.getPointer()),
1729  result.getAlignment());
1730 
1731  // Emit sanitizer checks for pointer value now, so that in the case of an
1732  // array it was checked only once and not at each constructor call. We may
1733  // have already checked that the pointer is non-null.
1734  // FIXME: If we have an array cookie and a potentially-throwing allocator,
1735  // we'll null check the wrong pointer here.
1736  SanitizerSet SkippedChecks;
1737  SkippedChecks.set(SanitizerKind::Null, nullCheck);
1740  result.getPointer(), allocType, result.getAlignment(),
1741  SkippedChecks, numElements);
1742 
1743  EmitNewInitializer(*this, E, allocType, elementTy, result, numElements,
1744  allocSizeWithoutCookie);
1745  if (E->isArray()) {
1746  // NewPtr is a pointer to the base element type. If we're
1747  // allocating an array of arrays, we'll need to cast back to the
1748  // array pointer type.
1749  llvm::Type *resultType = ConvertTypeForMem(E->getType());
1750  if (result.getType() != resultType)
1751  result = Builder.CreateBitCast(result, resultType);
1752  }
1753 
1754  // Deactivate the 'operator delete' cleanup if we finished
1755  // initialization.
1756  if (operatorDeleteCleanup.isValid()) {
1757  DeactivateCleanupBlock(operatorDeleteCleanup, cleanupDominator);
1758  cleanupDominator->eraseFromParent();
1759  }
1760 
1761  llvm::Value *resultPtr = result.getPointer();
1762  if (nullCheck) {
1763  conditional.end(*this);
1764 
1765  llvm::BasicBlock *notNullBB = Builder.GetInsertBlock();
1766  EmitBlock(contBB);
1767 
1768  llvm::PHINode *PHI = Builder.CreatePHI(resultPtr->getType(), 2);
1769  PHI->addIncoming(resultPtr, notNullBB);
1770  PHI->addIncoming(llvm::Constant::getNullValue(resultPtr->getType()),
1771  nullCheckBB);
1772 
1773  resultPtr = PHI;
1774  }
1775 
1776  return resultPtr;
1777 }
1778 
1780  llvm::Value *Ptr, QualType DeleteTy,
1781  llvm::Value *NumElements,
1782  CharUnits CookieSize) {
1783  assert((!NumElements && CookieSize.isZero()) ||
1784  DeleteFD->getOverloadedOperator() == OO_Array_Delete);
1785 
1786  const auto *DeleteFTy = DeleteFD->getType()->castAs<FunctionProtoType>();
1787  CallArgList DeleteArgs;
1788 
1789  auto Params = getUsualDeleteParams(DeleteFD);
1790  auto ParamTypeIt = DeleteFTy->param_type_begin();
1791 
1792  // Pass the pointer itself.
1793  QualType ArgTy = *ParamTypeIt++;
1794  llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy));
1795  DeleteArgs.add(RValue::get(DeletePtr), ArgTy);
1796 
1797  // Pass the std::destroying_delete tag if present.
1798  llvm::AllocaInst *DestroyingDeleteTag = nullptr;
1799  if (Params.DestroyingDelete) {
1800  QualType DDTag = *ParamTypeIt++;
1801  llvm::Type *Ty = getTypes().ConvertType(DDTag);
1802  CharUnits Align = CGM.getNaturalTypeAlignment(DDTag);
1803  DestroyingDeleteTag = CreateTempAlloca(Ty, "destroying.delete.tag");
1804  DestroyingDeleteTag->setAlignment(Align.getAsAlign());
1805  DeleteArgs.add(RValue::getAggregate(Address(DestroyingDeleteTag, Align)), DDTag);
1806  }
1807 
1808  // Pass the size if the delete function has a size_t parameter.
1809  if (Params.Size) {
1810  QualType SizeType = *ParamTypeIt++;
1811  CharUnits DeleteTypeSize = getContext().getTypeSizeInChars(DeleteTy);
1812  llvm::Value *Size = llvm::ConstantInt::get(ConvertType(SizeType),
1813  DeleteTypeSize.getQuantity());
1814 
1815  // For array new, multiply by the number of elements.
1816  if (NumElements)
1817  Size = Builder.CreateMul(Size, NumElements);
1818 
1819  // If there is a cookie, add the cookie size.
1820  if (!CookieSize.isZero())
1821  Size = Builder.CreateAdd(
1822  Size, llvm::ConstantInt::get(SizeTy, CookieSize.getQuantity()));
1823 
1824  DeleteArgs.add(RValue::get(Size), SizeType);
1825  }
1826 
1827  // Pass the alignment if the delete function has an align_val_t parameter.
1828  if (Params.Alignment) {
1829  QualType AlignValType = *ParamTypeIt++;
1830  CharUnits DeleteTypeAlign =
1831  getContext().toCharUnitsFromBits(getContext().getTypeAlignIfKnown(
1832  DeleteTy, true /* NeedsPreferredAlignment */));
1833  llvm::Value *Align = llvm::ConstantInt::get(ConvertType(AlignValType),
1834  DeleteTypeAlign.getQuantity());
1835  DeleteArgs.add(RValue::get(Align), AlignValType);
1836  }
1837 
1838  assert(ParamTypeIt == DeleteFTy->param_type_end() &&
1839  "unknown parameter to usual delete function");
1840 
1841  // Emit the call to delete.
1842  EmitNewDeleteCall(*this, DeleteFD, DeleteFTy, DeleteArgs);
1843 
1844  // If call argument lowering didn't use the destroying_delete_t alloca,
1845  // remove it again.
1846  if (DestroyingDeleteTag && DestroyingDeleteTag->use_empty())
1847  DestroyingDeleteTag->eraseFromParent();
1848 }
1849 
1850 namespace {
1851  /// Calls the given 'operator delete' on a single object.
1852  struct CallObjectDelete final : EHScopeStack::Cleanup {
1853  llvm::Value *Ptr;
1854  const FunctionDecl *OperatorDelete;
1855  QualType ElementType;
1856 
1857  CallObjectDelete(llvm::Value *Ptr,
1858  const FunctionDecl *OperatorDelete,
1859  QualType ElementType)
1860  : Ptr(Ptr), OperatorDelete(OperatorDelete), ElementType(ElementType) {}
1861 
1862  void Emit(CodeGenFunction &CGF, Flags flags) override {
1863  CGF.EmitDeleteCall(OperatorDelete, Ptr, ElementType);
1864  }
1865  };
1866 }
1867 
1868 void
1870  llvm::Value *CompletePtr,
1871  QualType ElementType) {
1872  EHStack.pushCleanup<CallObjectDelete>(NormalAndEHCleanup, CompletePtr,
1873  OperatorDelete, ElementType);
1874 }
1875 
1876 /// Emit the code for deleting a single object with a destroying operator
1877 /// delete. If the element type has a non-virtual destructor, Ptr has already
1878 /// been converted to the type of the parameter of 'operator delete'. Otherwise
1879 /// Ptr points to an object of the static type.
1881  const CXXDeleteExpr *DE, Address Ptr,
1882  QualType ElementType) {
1883  auto *Dtor = ElementType->getAsCXXRecordDecl()->getDestructor();
1884  if (Dtor && Dtor->isVirtual())
1885  CGF.CGM.getCXXABI().emitVirtualObjectDelete(CGF, DE, Ptr, ElementType,
1886  Dtor);
1887  else
1888  CGF.EmitDeleteCall(DE->getOperatorDelete(), Ptr.getPointer(), ElementType);
1889 }
1890 
1891 /// Emit the code for deleting a single object.
1892 /// \return \c true if we started emitting UnconditionalDeleteBlock, \c false
1893 /// if not.
1895  const CXXDeleteExpr *DE,
1896  Address Ptr,
1897  QualType ElementType,
1898  llvm::BasicBlock *UnconditionalDeleteBlock) {
1899  // C++11 [expr.delete]p3:
1900  // If the static type of the object to be deleted is different from its
1901  // dynamic type, the static type shall be a base class of the dynamic type
1902  // of the object to be deleted and the static type shall have a virtual
1903  // destructor or the behavior is undefined.
1905  DE->getExprLoc(), Ptr.getPointer(),
1906  ElementType);
1907 
1908  const FunctionDecl *OperatorDelete = DE->getOperatorDelete();
1909  assert(!OperatorDelete->isDestroyingOperatorDelete());
1910 
1911  // Find the destructor for the type, if applicable. If the
1912  // destructor is virtual, we'll just emit the vcall and return.
1913  const CXXDestructorDecl *Dtor = nullptr;
1914  if (const RecordType *RT = ElementType->getAs<RecordType>()) {
1915  CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1916  if (RD->hasDefinition() && !RD->hasTrivialDestructor()) {
1917  Dtor = RD->getDestructor();
1918 
1919  if (Dtor->isVirtual()) {
1920  bool UseVirtualCall = true;
1921  const Expr *Base = DE->getArgument();
1922  if (auto *DevirtualizedDtor =
1923  dyn_cast_or_null<const CXXDestructorDecl>(
1924  Dtor->getDevirtualizedMethod(
1925  Base, CGF.CGM.getLangOpts().AppleKext))) {
1926  UseVirtualCall = false;
1927  const CXXRecordDecl *DevirtualizedClass =
1928  DevirtualizedDtor->getParent();
1929  if (declaresSameEntity(getCXXRecord(Base), DevirtualizedClass)) {
1930  // Devirtualized to the class of the base type (the type of the
1931  // whole expression).
1932  Dtor = DevirtualizedDtor;
1933  } else {
1934  // Devirtualized to some other type. Would need to cast the this
1935  // pointer to that type but we don't have support for that yet, so
1936  // do a virtual call. FIXME: handle the case where it is
1937  // devirtualized to the derived type (the type of the inner
1938  // expression) as in EmitCXXMemberOrOperatorMemberCallExpr.
1939  UseVirtualCall = true;
1940  }
1941  }
1942  if (UseVirtualCall) {
1943  CGF.CGM.getCXXABI().emitVirtualObjectDelete(CGF, DE, Ptr, ElementType,
1944  Dtor);
1945  return false;
1946  }
1947  }
1948  }
1949  }
1950 
1951  // Make sure that we call delete even if the dtor throws.
1952  // This doesn't have to a conditional cleanup because we're going
1953  // to pop it off in a second.
1954  CGF.EHStack.pushCleanup<CallObjectDelete>(NormalAndEHCleanup,
1955  Ptr.getPointer(),
1956  OperatorDelete, ElementType);
1957 
1958  if (Dtor)
1960  /*ForVirtualBase=*/false,
1961  /*Delegating=*/false,
1962  Ptr, ElementType);
1963  else if (auto Lifetime = ElementType.getObjCLifetime()) {
1964  switch (Lifetime) {
1965  case Qualifiers::OCL_None:
1968  break;
1969 
1972  break;
1973 
1974  case Qualifiers::OCL_Weak:
1975  CGF.EmitARCDestroyWeak(Ptr);
1976  break;
1977  }
1978  }
1979 
1980  // When optimizing for size, call 'operator delete' unconditionally.
1981  if (CGF.CGM.getCodeGenOpts().OptimizeSize > 1) {
1982  CGF.EmitBlock(UnconditionalDeleteBlock);
1983  CGF.PopCleanupBlock();
1984  return true;
1985  }
1986 
1987  CGF.PopCleanupBlock();
1988  return false;
1989 }
1990 
1991 namespace {
1992  /// Calls the given 'operator delete' on an array of objects.
1993  struct CallArrayDelete final : EHScopeStack::Cleanup {
1994  llvm::Value *Ptr;
1995  const FunctionDecl *OperatorDelete;
1996  llvm::Value *NumElements;
1997  QualType ElementType;
1998  CharUnits CookieSize;
1999 
2000  CallArrayDelete(llvm::Value *Ptr,
2001  const FunctionDecl *OperatorDelete,
2002  llvm::Value *NumElements,
2003  QualType ElementType,
2004  CharUnits CookieSize)
2005  : Ptr(Ptr), OperatorDelete(OperatorDelete), NumElements(NumElements),
2006  ElementType(ElementType), CookieSize(CookieSize) {}
2007 
2008  void Emit(CodeGenFunction &CGF, Flags flags) override {
2009  CGF.EmitDeleteCall(OperatorDelete, Ptr, ElementType, NumElements,
2010  CookieSize);
2011  }
2012  };
2013 }
2014 
2015 /// Emit the code for deleting an array of objects.
2017  const CXXDeleteExpr *E,
2018  Address deletedPtr,
2019  QualType elementType) {
2020  llvm::Value *numElements = nullptr;
2021  llvm::Value *allocatedPtr = nullptr;
2022  CharUnits cookieSize;
2023  CGF.CGM.getCXXABI().ReadArrayCookie(CGF, deletedPtr, E, elementType,
2024  numElements, allocatedPtr, cookieSize);
2025 
2026  assert(allocatedPtr && "ReadArrayCookie didn't set allocated pointer");
2027 
2028  // Make sure that we call delete even if one of the dtors throws.
2029  const FunctionDecl *operatorDelete = E->getOperatorDelete();
2030  CGF.EHStack.pushCleanup<CallArrayDelete>(NormalAndEHCleanup,
2031  allocatedPtr, operatorDelete,
2032  numElements, elementType,
2033  cookieSize);
2034 
2035  // Destroy the elements.
2036  if (QualType::DestructionKind dtorKind = elementType.isDestructedType()) {
2037  assert(numElements && "no element count for a type with a destructor!");
2038 
2039  CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType);
2040  CharUnits elementAlign =
2041  deletedPtr.getAlignment().alignmentOfArrayElement(elementSize);
2042 
2043  llvm::Value *arrayBegin = deletedPtr.getPointer();
2044  llvm::Value *arrayEnd = CGF.Builder.CreateInBoundsGEP(
2045  deletedPtr.getElementType(), arrayBegin, numElements, "delete.end");
2046 
2047  // Note that it is legal to allocate a zero-length array, and we
2048  // can never fold the check away because the length should always
2049  // come from a cookie.
2050  CGF.emitArrayDestroy(arrayBegin, arrayEnd, elementType, elementAlign,
2051  CGF.getDestroyer(dtorKind),
2052  /*checkZeroLength*/ true,
2053  CGF.needsEHCleanup(dtorKind));
2054  }
2055 
2056  // Pop the cleanup block.
2057  CGF.PopCleanupBlock();
2058 }
2059 
2061  const Expr *Arg = E->getArgument();
2062  Address Ptr = EmitPointerWithAlignment(Arg);
2063 
2064  // Null check the pointer.
2065  //
2066  // We could avoid this null check if we can determine that the object
2067  // destruction is trivial and doesn't require an array cookie; we can
2068  // unconditionally perform the operator delete call in that case. For now, we
2069  // assume that deleted pointers are null rarely enough that it's better to
2070  // keep the branch. This might be worth revisiting for a -O0 code size win.
2071  llvm::BasicBlock *DeleteNotNull = createBasicBlock("delete.notnull");
2072  llvm::BasicBlock *DeleteEnd = createBasicBlock("delete.end");
2073 
2074  llvm::Value *IsNull = Builder.CreateIsNull(Ptr.getPointer(), "isnull");
2075 
2076  Builder.CreateCondBr(IsNull, DeleteEnd, DeleteNotNull);
2077  EmitBlock(DeleteNotNull);
2078 
2079  QualType DeleteTy = E->getDestroyedType();
2080 
2081  // A destroying operator delete overrides the entire operation of the
2082  // delete expression.
2084  EmitDestroyingObjectDelete(*this, E, Ptr, DeleteTy);
2085  EmitBlock(DeleteEnd);
2086  return;
2087  }
2088 
2089  // We might be deleting a pointer to array. If so, GEP down to the
2090  // first non-array element.
2091  // (this assumes that A(*)[3][7] is converted to [3 x [7 x %A]]*)
2092  if (DeleteTy->isConstantArrayType()) {
2093  llvm::Value *Zero = Builder.getInt32(0);
2095 
2096  GEP.push_back(Zero); // point at the outermost array
2097 
2098  // For each layer of array type we're pointing at:
2099  while (const ConstantArrayType *Arr
2100  = getContext().getAsConstantArrayType(DeleteTy)) {
2101  // 1. Unpeel the array type.
2102  DeleteTy = Arr->getElementType();
2103 
2104  // 2. GEP to the first element of the array.
2105  GEP.push_back(Zero);
2106  }
2107 
2108  Ptr = Address(Builder.CreateInBoundsGEP(Ptr.getElementType(),
2109  Ptr.getPointer(), GEP, "del.first"),
2110  Ptr.getAlignment());
2111  }
2112 
2113  assert(ConvertTypeForMem(DeleteTy) == Ptr.getElementType());
2114 
2115  if (E->isArrayForm()) {
2116  EmitArrayDelete(*this, E, Ptr, DeleteTy);
2117  EmitBlock(DeleteEnd);
2118  } else {
2119  if (!EmitObjectDelete(*this, E, Ptr, DeleteTy, DeleteEnd))
2120  EmitBlock(DeleteEnd);
2121  }
2122 }
2123 
2124 static bool isGLValueFromPointerDeref(const Expr *E) {
2125  E = E->IgnoreParens();
2126 
2127  if (const auto *CE = dyn_cast<CastExpr>(E)) {
2128  if (!CE->getSubExpr()->isGLValue())
2129  return false;
2130  return isGLValueFromPointerDeref(CE->getSubExpr());
2131  }
2132 
2133  if (const auto *OVE = dyn_cast<OpaqueValueExpr>(E))
2134  return isGLValueFromPointerDeref(OVE->getSourceExpr());
2135 
2136  if (const auto *BO = dyn_cast<BinaryOperator>(E))
2137  if (BO->getOpcode() == BO_Comma)
2138  return isGLValueFromPointerDeref(BO->getRHS());
2139 
2140  if (const auto *ACO = dyn_cast<AbstractConditionalOperator>(E))
2141  return isGLValueFromPointerDeref(ACO->getTrueExpr()) ||
2142  isGLValueFromPointerDeref(ACO->getFalseExpr());
2143 
2144  // C++11 [expr.sub]p1:
2145  // The expression E1[E2] is identical (by definition) to *((E1)+(E2))
2146  if (isa<ArraySubscriptExpr>(E))
2147  return true;
2148 
2149  if (const auto *UO = dyn_cast<UnaryOperator>(E))
2150  if (UO->getOpcode() == UO_Deref)
2151  return true;
2152 
2153  return false;
2154 }
2155 
2157  llvm::Type *StdTypeInfoPtrTy) {
2158  // Get the vtable pointer.
2159  Address ThisPtr = CGF.EmitLValue(E).getAddress(CGF);
2160 
2161  QualType SrcRecordTy = E->getType();
2162 
2163  // C++ [class.cdtor]p4:
2164  // If the operand of typeid refers to the object under construction or
2165  // destruction and the static type of the operand is neither the constructor
2166  // or destructor’s class nor one of its bases, the behavior is undefined.
2168  ThisPtr.getPointer(), SrcRecordTy);
2169 
2170  // C++ [expr.typeid]p2:
2171  // If the glvalue expression is obtained by applying the unary * operator to
2172  // a pointer and the pointer is a null pointer value, the typeid expression
2173  // throws the std::bad_typeid exception.
2174  //
2175  // However, this paragraph's intent is not clear. We choose a very generous
2176  // interpretation which implores us to consider comma operators, conditional
2177  // operators, parentheses and other such constructs.
2179  isGLValueFromPointerDeref(E), SrcRecordTy)) {
2180  llvm::BasicBlock *BadTypeidBlock =
2181  CGF.createBasicBlock("typeid.bad_typeid");
2182  llvm::BasicBlock *EndBlock = CGF.createBasicBlock("typeid.end");
2183 
2184  llvm::Value *IsNull = CGF.Builder.CreateIsNull(ThisPtr.getPointer());
2185  CGF.Builder.CreateCondBr(IsNull, BadTypeidBlock, EndBlock);
2186 
2187  CGF.EmitBlock(BadTypeidBlock);
2188  CGF.CGM.getCXXABI().EmitBadTypeidCall(CGF);
2189  CGF.EmitBlock(EndBlock);
2190  }
2191 
2192  return CGF.CGM.getCXXABI().EmitTypeid(CGF, SrcRecordTy, ThisPtr,
2193  StdTypeInfoPtrTy);
2194 }
2195 
2197  llvm::Type *StdTypeInfoPtrTy =
2198  ConvertType(E->getType())->getPointerTo();
2199 
2200  if (E->isTypeOperand()) {
2201  llvm::Constant *TypeInfo =
2203  return Builder.CreateBitCast(TypeInfo, StdTypeInfoPtrTy);
2204  }
2205 
2206  // C++ [expr.typeid]p2:
2207  // When typeid is applied to a glvalue expression whose type is a
2208  // polymorphic class type, the result refers to a std::type_info object
2209  // representing the type of the most derived object (that is, the dynamic
2210  // type) to which the glvalue refers.
2211  // If the operand is already most derived object, no need to look up vtable.
2212  if (E->isPotentiallyEvaluated() && !E->isMostDerived(getContext()))
2213  return EmitTypeidFromVTable(*this, E->getExprOperand(),
2214  StdTypeInfoPtrTy);
2215 
2216  QualType OperandTy = E->getExprOperand()->getType();
2218  StdTypeInfoPtrTy);
2219 }
2220 
2222  QualType DestTy) {
2223  llvm::Type *DestLTy = CGF.ConvertType(DestTy);
2224  if (DestTy->isPointerType())
2225  return llvm::Constant::getNullValue(DestLTy);
2226 
2227  /// C++ [expr.dynamic.cast]p9:
2228  /// A failed cast to reference type throws std::bad_cast
2229  if (!CGF.CGM.getCXXABI().EmitBadCastCall(CGF))
2230  return nullptr;
2231 
2232  CGF.EmitBlock(CGF.createBasicBlock("dynamic_cast.end"));
2233  return llvm::UndefValue::get(DestLTy);
2234 }
2235 
2237  const CXXDynamicCastExpr *DCE) {
2238  CGM.EmitExplicitCastExprType(DCE, this);
2239  QualType DestTy = DCE->getTypeAsWritten();
2240 
2241  QualType SrcTy = DCE->getSubExpr()->getType();
2242 
2243  // C++ [expr.dynamic.cast]p7:
2244  // If T is "pointer to cv void," then the result is a pointer to the most
2245  // derived object pointed to by v.
2246  const PointerType *DestPTy = DestTy->getAs<PointerType>();
2247 
2248  bool isDynamicCastToVoid;
2249  QualType SrcRecordTy;
2250  QualType DestRecordTy;
2251  if (DestPTy) {
2252  isDynamicCastToVoid = DestPTy->getPointeeType()->isVoidType();
2253  SrcRecordTy = SrcTy->castAs<PointerType>()->getPointeeType();
2254  DestRecordTy = DestPTy->getPointeeType();
2255  } else {
2256  isDynamicCastToVoid = false;
2257  SrcRecordTy = SrcTy;
2258  DestRecordTy = DestTy->castAs<ReferenceType>()->getPointeeType();
2259  }
2260 
2261  // C++ [class.cdtor]p5:
2262  // If the operand of the dynamic_cast refers to the object under
2263  // construction or destruction and the static type of the operand is not a
2264  // pointer to or object of the constructor or destructor’s own class or one
2265  // of its bases, the dynamic_cast results in undefined behavior.
2267  SrcRecordTy);
2268 
2269  if (DCE->isAlwaysNull())
2270  if (llvm::Value *T = EmitDynamicCastToNull(*this, DestTy))
2271  return T;
2272 
2273  assert(SrcRecordTy->isRecordType() && "source type must be a record type!");
2274 
2275  // C++ [expr.dynamic.cast]p4:
2276  // If the value of v is a null pointer value in the pointer case, the result
2277  // is the null pointer value of type T.
2278  bool ShouldNullCheckSrcValue =
2280  SrcRecordTy);
2281 
2282  llvm::BasicBlock *CastNull = nullptr;
2283  llvm::BasicBlock *CastNotNull = nullptr;
2284  llvm::BasicBlock *CastEnd = createBasicBlock("dynamic_cast.end");
2285 
2286  if (ShouldNullCheckSrcValue) {
2287  CastNull = createBasicBlock("dynamic_cast.null");
2288  CastNotNull = createBasicBlock("dynamic_cast.notnull");
2289 
2290  llvm::Value *IsNull = Builder.CreateIsNull(ThisAddr.getPointer());
2291  Builder.CreateCondBr(IsNull, CastNull, CastNotNull);
2292  EmitBlock(CastNotNull);
2293  }
2294 
2295  llvm::Value *Value;
2296  if (isDynamicCastToVoid) {
2297  Value = CGM.getCXXABI().EmitDynamicCastToVoid(*this, ThisAddr, SrcRecordTy,
2298  DestTy);
2299  } else {
2300  assert(DestRecordTy->isRecordType() &&
2301  "destination type must be a record type!");
2302  Value = CGM.getCXXABI().EmitDynamicCastCall(*this, ThisAddr, SrcRecordTy,
2303  DestTy, DestRecordTy, CastEnd);
2304  CastNotNull = Builder.GetInsertBlock();
2305  }
2306 
2307  if (ShouldNullCheckSrcValue) {
2308  EmitBranch(CastEnd);
2309 
2310  EmitBlock(CastNull);
2311  EmitBranch(CastEnd);
2312  }
2313 
2314  EmitBlock(CastEnd);
2315 
2316  if (ShouldNullCheckSrcValue) {
2317  llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2);
2318  PHI->addIncoming(Value, CastNotNull);
2319  PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()), CastNull);
2320 
2321  Value = PHI;
2322  }
2323 
2324  return Value;
2325 }
clang::CodeGen::CGCXXABI::ReadArrayCookie
virtual void ReadArrayCookie(CodeGenFunction &CGF, Address Ptr, const CXXDeleteExpr *expr, QualType ElementType, llvm::Value *&NumElements, llvm::Value *&AllocPtr, CharUnits &CookieSize)
Reads the array cookie associated with the given pointer, if it has one.
Definition: CGCXXABI.cpp:204
clang::CXXPseudoDestructorExpr::getDestroyedType
QualType getDestroyedType() const
Retrieve the type being destroyed.
Definition: ExprCXX.cpp:334
clang::CXXMethodDecl::getThisType
QualType getThisType() const
Return the type of the this pointer.
Definition: DeclCXX.cpp:2453
clang::CodeGen::CodeGenFunction::ConvertTypeForMem
llvm::Type * ConvertTypeForMem(QualType T)
Definition: CodeGenFunction.cpp:207
clang::CXXNewExpr::passAlignment
bool passAlignment() const
Indicates whether the required alignment should be implicitly passed to the allocation function.
Definition: ExprCXX.h:2332
clang::CodeGen::CodeGenFunction::EmitVTablePtrCheckForCall
void EmitVTablePtrCheckForCall(const CXXRecordDecl *RD, llvm::Value *VTable, CFITypeCheckKind TCK, SourceLocation Loc)
EmitVTablePtrCheckForCall - Virtual method MD is being called via VTable.
Definition: CGClass.cpp:2695
clang::ASTContext::getTypeSizeInChars
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
Definition: ASTContext.cpp:2450
clang::FunctionProtoType::param_type_begin
param_type_iterator param_type_begin() const
Definition: Type.h:4254
clang::CodeGen::CodeGenFunction::EmitComplexExprIntoLValue
void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit)
EmitComplexExprIntoLValue - Emit the given expression of complex type and place its result into the s...
Definition: CGExprComplex.cpp:1129
clang::CharUnits::isOne
bool isOne() const
isOne - Test whether the quantity equals one.
Definition: CharUnits.h:119
clang::CXXConstructExpr::CK_Complete
@ CK_Complete
Definition: ExprCXX.h:1465
clang::CodeGen::CGBuilderTy::CreateMemCpy
llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:286
clang::Type::isRecordType
bool isRecordType() const
Definition: Type.h:6766
clang::CXXMemberCallExpr::getExprLoc
SourceLocation getExprLoc() const LLVM_READONLY
Definition: ExprCXX.h:218
clang::CodeGen::CodeGenTypeCache::SizeTy
llvm::IntegerType * SizeTy
Definition: CodeGenTypeCache.h:50
max
__DEVICE__ int max(int __a, int __b)
Definition: __clang_cuda_math.h:196
clang::CodeGen::CodeGenFunction::getTypeSize
llvm::Value * getTypeSize(QualType Ty)
Returns calculated size of the specified type.
Definition: CGStmtOpenMP.cpp:303
clang::CodeGen::CGDebugInfo::addHeapAllocSiteMetadata
void addHeapAllocSiteMetadata(llvm::CallBase *CallSite, QualType AllocatedTy, SourceLocation Loc)
Add heapallocsite metadata for MSAllocator calls.
Definition: CGDebugInfo.cpp:2422
clang::FunctionDecl::isDefaulted
bool isDefaulted() const
Whether this function is defaulted.
Definition: Decl.h:2216
clang::Type::getAsArrayTypeUnsafe
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
Definition: Type.h:7216
clang::CodeGen::LValueBaseInfo
Definition: CGValue.h:150
clang::QualType::getObjCLifetime
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1120
clang::FunctionProtoType::param_type_end
param_type_iterator param_type_end() const
Definition: Type.h:4258
clang::CXXConstructorDecl
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2401
clang::CXXMethodDecl::isCopyAssignmentOperator
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
Definition: DeclCXX.cpp:2361
clang::CodeGen::CodeGenFunction::EmitNullInitialization
void EmitNullInitialization(Address DestPtr, QualType Ty)
EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...
Definition: CodeGenFunction.cpp:1938
clang::CodeGen::CGCXXABI::EmitBadCastCall
virtual bool EmitBadCastCall(CodeGenFunction &CGF)=0
EmitArrayDelete
static void EmitArrayDelete(CodeGenFunction &CGF, const CXXDeleteExpr *E, Address deletedPtr, QualType elementType)
Emit the code for deleting an array of objects.
Definition: CGExprCXX.cpp:2016
clang::CallExpr::arg_end
arg_iterator arg_end()
Definition: Expr.h:3042
clang::CallExpr::arg_begin
arg_iterator arg_begin()
Definition: Expr.h:3039
clang::CharUnits::getAsAlign
llvm::Align getAsAlign() const
getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...
Definition: CharUnits.h:183
StoreAnyExprIntoOneUnit
static void StoreAnyExprIntoOneUnit(CodeGenFunction &CGF, const Expr *Init, QualType AllocType, Address NewPtr, AggValueSlot::Overlap_t MayOverlap)
Definition: CGExprCXX.cpp:956
clang::interp::APInt
llvm::APInt APInt
Definition: Integral.h:27
clang::CXXPseudoDestructorExpr
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Definition: ExprCXX.h:2517
clang::CharUnits::alignmentOfArrayElement
CharUnits alignmentOfArrayElement(CharUnits elementSize) const
Given that this is the alignment of the first element of an array, return the minimum alignment of an...
Definition: CharUnits.h:201
clang::QualType::hasStrongOrWeakObjCLifetime
bool hasStrongOrWeakObjCLifetime() const
Definition: Type.h:1128
clang::CodeGen::TEK_Aggregate
@ TEK_Aggregate
Definition: CodeGenFunction.h:115
clang::CodeGen::RValue
RValue - This trivial value class is used to represent the result of an expression that is evaluated.
Definition: CGValue.h:39
type
clang::CodeGen::RValue::getAggregate
static RValue getAggregate(Address addr, bool isVolatile=false)
Definition: CGValue.h:107
clang::CodeGen::CodeGenFunction::sanitizePerformTypeCheck
bool sanitizePerformTypeCheck() const
Whether any type-checking sanitizers are enabled.
Definition: CGExpr.cpp:656
clang::CXXMethodDecl::isStatic
bool isStatic() const
Definition: DeclCXX.cpp:2093
clang::CodeGen::CodeGenFunction::EmitARCDestroyWeak
void EmitARCDestroyWeak(Address addr)
void @objc_destroyWeak(i8** addr) Essentially objc_storeWeak(addr, nil).
Definition: CGObjC.cpp:2607
clang::FunctionDecl::getReturnType
QualType getReturnType() const
Definition: Decl.h:2542
clang::CallExpr::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.cpp:1551
clang::RecordDecl::mayInsertExtraPadding
bool mayInsertExtraPadding(bool EmitRemark=false) const
Whether we are allowed to insert extra padding between fields.
Definition: Decl.cpp:4675
CodeGenFunction.h
clang::CodeGen::CodeGenFunction::EmitCall
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **callOrInvoke, bool IsMustTail, SourceLocation Loc)
EmitCall - Generate a call of the given function, expecting the given result type,...
Definition: CGCall.cpp:4610
clang::CodeGen::CodeGenFunction::EmitCXXMemberOrOperatorCall
RValue EmitCXXMemberOrOperatorCall(const CXXMethodDecl *Method, const CGCallee &Callee, ReturnValueSlot ReturnValue, llvm::Value *This, llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *E, CallArgList *RtlArgs)
Definition: CGExprCXX.cpp:78
clang::CodeGen::CGCXXABI::LoadVTablePtr
virtual std::pair< llvm::Value *, const CXXRecordDecl * > LoadVTablePtr(CodeGenFunction &CGF, Address This, const CXXRecordDecl *RD)=0
Load a vtable from This, an object of polymorphic type RD, or from one of its virtual bases if it doe...
clang::CodeGen::EHScopeStack::stable_iterator::isValid
bool isValid() const
Definition: EHScopeStack.h:113
clang::CodeGen::CodeGenFunction::TCK_DynamicOperation
@ TCK_DynamicOperation
Checking the operand of a dynamic_cast or a typeid expression.
Definition: CodeGenFunction.h:2973
clang::ConstantArrayType
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2929
clang::CodeGen::AggValueSlot::DoesNotNeedGCBarriers
@ DoesNotNeedGCBarriers
Definition: CGValue.h:528
clang::CodeGen::Address::getAlignment
CharUnits getAlignment() const
Return the alignment of this pointer.
Definition: Address.h:66
clang::CodeGen::CodeGenTypeCache::getSizeAlign
CharUnits getSizeAlign() const
Definition: CodeGenTypeCache.h:111
clang::CodeGen::CodeGenModule::GetAddrOfFunction
llvm::Constant * GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty=nullptr, bool ForVTable=false, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the given function.
Definition: CodeGenModule.cpp:3850
clang::Qualifiers::OCL_Weak
@ OCL_Weak
Reading or writing from this object requires a barrier call.
Definition: Type.h:176
clang::CodeGen::CGCXXABI::emitVirtualObjectDelete
virtual void emitVirtualObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE, Address Ptr, QualType ElementType, const CXXDestructorDecl *Dtor)=0
clang::CodeGen::CodeGenFunction::EmitSynthesizedCXXCopyCtorCall
void EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D, Address This, Address Src, const CXXConstructExpr *E)
Definition: CGClass.cpp:2329
clang::TargetInfo::getNewAlign
unsigned getNewAlign() const
Return the largest alignment for which a suitably-sized allocation with '::operator new(size_t)' or '...
Definition: TargetInfo.h:640
llvm::SmallVector
Definition: LLVM.h:38
clang::CXXTypeidExpr::isPotentiallyEvaluated
bool isPotentiallyEvaluated() const
Determine whether this typeid has a type operand which is potentially evaluated, per C++11 [expr....
Definition: ExprCXX.cpp:134
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::QualType::getQualifiers
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6455
clang::CodeGen::LValue::getAddress
Address getAddress(CodeGenFunction &CGF) const
Definition: CGValue.h:329
clang::CXXNewExpr::getNumPlacementArgs
unsigned getNumPlacementArgs() const
Definition: ExprCXX.h:2275
clang::CodeGen::CodeGenFunction::PopCleanupBlock
void PopCleanupBlock(bool FallThroughIsBranchThrough=false)
PopCleanupBlock - Will pop the cleanup entry on the stack and process all branch fixups.
Definition: CGCleanup.cpp:647
clang::CastExpr::getSubExpr
Expr * getSubExpr()
Definition: Expr.h:3524
clang::CodeGen::CodeGenModule::getSize
llvm::ConstantInt * getSize(CharUnits numChars)
Emit the given number of characters as a value of type size_t.
Definition: CodeGenModule.cpp:1022
clang::CXXNewExpr::getOperatorNew
FunctionDecl * getOperatorNew() const
Definition: ExprCXX.h:2257
clang::CXXDeleteExpr::isArrayForm
bool isArrayForm() const
Definition: ExprCXX.h:2424
clang::ASTContext::DeclarationNames
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:652
clang::CXXConstructExpr::requiresZeroInitialization
bool requiresZeroInitialization() const
Whether this construction first requires zero-initialization before the initializer is called.
Definition: ExprCXX.h:1571
clang::CodeGen::CGCXXABI::InitializeArrayCookie
virtual Address InitializeArrayCookie(CodeGenFunction &CGF, Address NewPtr, llvm::Value *NumElements, const CXXNewExpr *expr, QualType ElementType)
Initialize the array cookie for the given allocation.
Definition: CGCXXABI.cpp:175
clang::CodeGen::CodeGenTypeCache::getPointerAlign
CharUnits getPointerAlign() const
Definition: CodeGenTypeCache.h:117
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:673
clang::NestedNameSpecifier
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Definition: NestedNameSpecifier.h:50
clang::CXXNewExpr::isArray
bool isArray() const
Definition: ExprCXX.h:2262
clang::SanitizerSet::has
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
Definition: Sanitizers.h:155
clang::CXXTypeidExpr
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:839
clang::QualType::getCanonicalType
QualType getCanonicalType() const
Definition: Type.h:6467
clang::CodeGen::Address::isValid
bool isValid() const
Definition: Address.h:35
clang::CodeGen::CodeGenFunction::EmitARCDestroyStrong
void EmitARCDestroyStrong(Address addr, ARCPreciseLifetime_t precise)
Destroy a __strong variable.
Definition: CGObjC.cpp:2435
clang::ASTContext::getBaseElementType
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
Definition: ASTContext.cpp:6334
clang::Qualifiers
The collection of all-type qualifiers we support.
Definition: Type.h:145
clang::CodeGen::CodeGenFunction::EmitNewArrayInitializer
void EmitNewArrayInitializer(const CXXNewExpr *E, QualType elementType, llvm::Type *ElementTy, Address NewPtr, llvm::Value *NumElements, llvm::Value *AllocSizeWithoutCookie)
Definition: CGExprCXX.cpp:984
clang::ASTRecordLayout::getNonVirtualAlignment
CharUnits getNonVirtualAlignment() const
getNonVirtualAlignment - Get the non-virtual alignment (in chars) of an object, which is the alignmen...
Definition: RecordLayout.h:218
clang::CodeGen::CodeGenFunction::createBasicBlock
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
Definition: CodeGenFunction.h:2422
clang::CXXNewExpr
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
Definition: ExprCXX.h:2139
clang::CodeGen::CodeGenFunction::pushIrregularPartialArrayCleanup
void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin, Address arrayEndPointer, QualType elementType, CharUnits elementAlignment, Destroyer *destroyer)
pushIrregularPartialArrayCleanup - Push an EH cleanup to destroy already-constructed elements of the ...
Definition: CGDecl.cpp:2366
clang::CodeGen::CGBuilderTy::CreateStore
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:95
EmitNewInitializer
static void EmitNewInitializer(CodeGenFunction &CGF, const CXXNewExpr *E, QualType ElementType, llvm::Type *ElementTy, Address NewPtr, llvm::Value *NumElements, llvm::Value *AllocSizeWithoutCookie)
Definition: CGExprCXX.cpp:1294
CGObjCRuntime.h
clang::InitListExpr
Describes an C or C++ initializer list.
Definition: Expr.h:4786
TargetInfo.h
clang::Qualifiers::OCL_ExplicitNone
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
Definition: Type.h:166
clang::Ctor_Base
@ Ctor_Base
Base object ctor.
Definition: ABI.h:26
clang::CodeGen::CodeGenModule::getLangOpts
const LangOptions & getLangOpts() const
Definition: CodeGenModule.h:703
clang::Ctor_Complete
@ Ctor_Complete
Complete object ctor.
Definition: ABI.h:25
clang::Type::isVoidType
bool isVoidType() const
Definition: Type.h:6959
clang::QualType::isVolatileQualified
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:6498
clang::MemberExpr::getQualifier
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name.
Definition: Expr.h:3273
clang::CodeGen::CodeGenFunction::getDestroyer
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
Definition: CGDecl.cpp:2083
clang::CodeGen::EHCleanup
@ EHCleanup
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
Definition: EHScopeStack.h:80
clang::CodeGen::CodeGenFunction::EmitDynamicCast
llvm::Value * EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE)
Definition: CGExprCXX.cpp:2236
clang::CodeGen::CodeGenFunction::CreateTempAlloca
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...
Definition: CGExpr.cpp:110
clang::BinaryOperator::getOpcode
Opcode getOpcode() const
Definition: Expr.h:3847
clang::CharUnits::alignmentAtOffset
CharUnits alignmentAtOffset(CharUnits offset) const
Given that this is a non-zero alignment value, what is the alignment at the given offset?
Definition: CharUnits.h:194
clang::CodeGen::CodeGenFunction::MustTailCall
const CallExpr * MustTailCall
Definition: CodeGenFunction.h:557
clang::CodeGen::CodeGenFunction::EmitCXXMemberCallExpr
RValue EmitCXXMemberCallExpr(const CXXMemberCallExpr *E, ReturnValueSlot ReturnValue)
Definition: CGExprCXX.cpp:181
clang::CXXNewExpr::getAllocatedType
QualType getAllocatedType() const
Definition: ExprCXX.h:2232
clang::ento::Store
const void * Store
Store - This opaque type encapsulates an immutable mapping from locations to values.
Definition: StoreRef.h:27
clang::CodeGen::CodeGenFunction::EmitCUDAKernelCallExpr
RValue EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E, ReturnValueSlot ReturnValue)
Definition: CGExprCXX.cpp:491
clang::CodeGen::CGCXXABI::EmitTypeid
virtual llvm::Value * EmitTypeid(CodeGenFunction &CGF, QualType SrcRecordTy, Address ThisPtr, llvm::Type *StdTypeInfoPtrTy)=0
clang::CXXTypeidExpr::isMostDerived
bool isMostDerived(ASTContext &Context) const
Best-effort check if the expression operand refers to a most derived object.
Definition: ExprCXX.cpp:149
ConstantEmitter.h
clang::CXXTypeidExpr::getExprOperand
Expr * getExprOperand() const
Definition: ExprCXX.h:886
clang::DeclarationName
The name of a declaration.
Definition: DeclarationName.h:145
clang::ASTContext::getTranslationUnitDecl
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1057
clang::CodeGen::CallArgList::add
void add(RValue rvalue, QualType type)
Definition: CGCall.h:288
isGLValueFromPointerDeref
static bool isGLValueFromPointerDeref(const Expr *E)
Definition: CGExprCXX.cpp:2124
clang::MemberExpr::hasQualifier
bool hasQualifier() const
Determines whether this member expression actually had a C++ nested-name-specifier prior to the name ...
Definition: Expr.h:3259
clang::CodeGen::CodeGenFunction::Builder
CGBuilderTy Builder
Definition: CodeGenFunction.h:274
CGDebugInfo.h
clang::CXXMethodDecl::getCorrespondingMethodInClass
CXXMethodDecl * getCorrespondingMethodInClass(const CXXRecordDecl *RD, bool MayBeBase=false)
Find the method in RD that corresponds to this one.
Definition: DeclCXX.cpp:2146
clang::Dtor_Complete
@ Dtor_Complete
Complete object dtor.
Definition: ABI.h:35
clang::CodeGen::CodeGenTypes::ConvertType
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
Definition: CodeGenTypes.cpp:395
clang::CodeGen::CGBuilderTy::CreateBitCast
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:151
clang::CXXMethodDecl::isMoveAssignmentOperator
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Definition: DeclCXX.cpp:2382
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1490
clang::CodeGen::CodeGenFunction::EmitCXXAggrConstructorCall
void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D, const ArrayType *ArrayTy, Address ArrayPtr, const CXXConstructExpr *E, bool NewPointerIsChecked, bool ZeroInitialization=false)
EmitCXXAggrConstructorCall - Emit a loop to call a particular constructor for each of several members...
Definition: CGClass.cpp:1919
clang::CodeGen::CodeGenFunction::EmitCXXDestructorCall
void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating, Address This, QualType ThisTy)
Definition: CGClass.cpp:2442
clang::GlobalDecl
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:56
clang::TypeLoc::getBeginLoc
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:191
clang::CodeGen::AlignmentSource::Decl
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
CodeGenOptions.h
clang::Qualifiers::getAddressSpace
LangAS getAddressSpace() const
Definition: Type.h:361
clang::CodeGen::InvariantValue::save
static saved_type save(CodeGenFunction &CGF, type value)
Definition: EHScopeStack.h:59
clang::CodeGen::ReturnValueSlot
ReturnValueSlot - Contains the address where the return value of a function can be stored,...
Definition: CGCall.h:362
clang::TypeInfo
Definition: ASTContext.h:182
clang::CallExpr::getCallee
Expr * getCallee()
Definition: Expr.h:2945
V
#define V(N, I)
Definition: ASTContext.h:3127
clang::CodeGen::CodeGenFunction::EmitCXXConstructExpr
void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest)
Definition: CGExprCXX.cpp:584
CalculateCookiePadding
static CharUnits CalculateCookiePadding(CodeGenFunction &CGF, const CXXNewExpr *E)
Definition: CGExprCXX.cpp:681
clang::CodeGen::CodeGenFunction::RunCleanupsScope
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited.
Definition: CodeGenFunction.h:866
clang::CodeGen::TBAAAccessInfo
Definition: CodeGenTBAA.h:42
clang::CallExpr::getDirectCallee
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
Definition: Expr.h:2965
clang::RecordType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4613
clang::CXXCtorType
CXXCtorType
C++ constructor types.
Definition: ABI.h:24
clang::SanitizerSet
Definition: Sanitizers.h:153
clang::CodeGen::AggValueSlot::IsSanitizerChecked
@ IsSanitizerChecked
Definition: CGValue.h:529
clang::CodeGen::EHScopeStack::Cleanup
Information for lazily generating a cleanup.
Definition: EHScopeStack.h:141
clang::CXXMethodDecl::isInstance
bool isInstance() const
Definition: DeclCXX.h:1975
clang::ASTContext::getAsConstantArrayType
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2635
clang::CodeGen::ARCPreciseLifetime
@ ARCPreciseLifetime
Definition: CGValue.h:121
clang::FunctionDecl::isTrivial
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2208
clang::QualType::getAddressSpace
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:6549
clang::BinaryOperator
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3803
EmitTypeidFromVTable
static llvm::Value * EmitTypeidFromVTable(CodeGenFunction &CGF, const Expr *E, llvm::Type *StdTypeInfoPtrTy)
Definition: CGExprCXX.cpp:2156
clang::CXXNewExpr::getInitializer
Expr * getInitializer()
The initializer of this new-expression.
Definition: ExprCXX.h:2314
clang::Qualifiers::OCL_Strong
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
Definition: Type.h:173
clang::Scope
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
clang::MemberExpr::isArrow
bool isArrow() const
Definition: Expr.h:3346
clang::CodeGen::CodeGenFunction::EmitCXXNewExpr
llvm::Value * EmitCXXNewExpr(const CXXNewExpr *E)
Definition: CGExprCXX.cpp:1556
clang::CodeGen::CodeGenFunction::EmitCastToVoidPtr
llvm::Value * EmitCastToVoidPtr(llvm::Value *value)
Emit a cast to void* in the appropriate address space.
Definition: CGExpr.cpp:54
clang::CodeGen::CodeGenModule::getCodeGenOpts
const CodeGenOptions & getCodeGenOpts() const
Definition: CodeGenModule.h:708
clang::CodeGen::Address::getType
llvm::PointerType * getType() const
Return the type of the pointer value.
Definition: Address.h:43
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:212
clang::ASTContext::getSizeType
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
Definition: ASTContext.cpp:5746
CGFunctionInfo.h
clang::ArrayType
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2883
clang::DeclarationNameTable::getCXXOperatorName
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
Get the name of the overloadable C++ operator corresponding to Op.
Definition: DeclarationName.h:639
clang::MemberPointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2847
clang::CodeGen::TEK_Complex
@ TEK_Complex
Definition: CodeGenFunction.h:114
clang::CodeGen::CodeGenFunction::EmitTypeCheck
void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, llvm::Value *V, QualType Type, CharUnits Alignment=CharUnits::Zero(), SanitizerSet SkippedChecks=SanitizerSet(), llvm::Value *ArraySize=nullptr)
Emit a check that V is the address of storage of the appropriate size and alignment for an object of ...
Definition: CGExpr.cpp:663
clang::ASTContext::getConstantArrayElementCount
uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const
Return number of constant array elements.
Definition: ASTContext.cpp:6354
clang::Type::getAs
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:7165
clang::CodeGen::CodeGenFunction::getDebugInfo
CGDebugInfo * getDebugInfo()
Definition: CodeGenFunction.h:1976
EmitObjectDelete
static bool EmitObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE, Address Ptr, QualType ElementType, llvm::BasicBlock *UnconditionalDeleteBlock)
Emit the code for deleting a single object.
Definition: CGExprCXX.cpp:1894
clang::CallExpr::getArg
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2986
clang::CodeGen::CGCXXABI::getThisArgumentTypeForMethod
virtual const CXXRecordDecl * getThisArgumentTypeForMethod(const CXXMethodDecl *MD)
Get the type of the implicit "this" parameter used by a method.
Definition: CGCXXABI.h:357
clang::CodeGen::CodeGenFunction::EmitCXXPseudoDestructorExpr
RValue EmitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E)
Definition: CGExprCXX.cpp:120
clang::CodeGen::CodeGenFunction::pushRegularPartialArrayCleanup
void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin, llvm::Value *arrayEnd, QualType elementType, CharUnits elementAlignment, Destroyer *destroyer)
pushRegularPartialArrayCleanup - Push an EH cleanup to destroy already-constructed elements of the gi...
Definition: CGDecl.cpp:2383
clang::FunctionProtoType::getParamType
QualType getParamType(unsigned i) const
Definition: Type.h:4097
clang::ASTRecordLayout::getNonVirtualSize
CharUnits getNonVirtualSize() const
getNonVirtualSize - Get the non-virtual size (in chars) of an object, which is the size of the object...
Definition: RecordLayout.h:210
clang::CodeGen::CGCXXABI::adjustThisArgumentForVirtualFunctionCall
virtual Address adjustThisArgumentForVirtualFunctionCall(CodeGenFunction &CGF, GlobalDecl GD, Address This, bool VirtualCall)
Perform ABI-specific "this" argument adjustment required prior to a call of a virtual function.
Definition: CGCXXABI.h:365
clang::CodeGen::CodeGenModule::getModule
llvm::Module & getModule() const
Definition: CodeGenModule.h:709
clang::CXXDestructorDecl
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2668
clang::CodeGen::DominatingValue
A metaprogramming class for ensuring that a value will dominate an arbitrary position in a function.
Definition: EHScopeStack.h:65
clang::ImplicitValueInitExpr
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:5505
clang::CodeGen::CodeGenFunction::needsEHCleanup
bool needsEHCleanup(QualType::DestructionKind kind)
Determines whether an EH cleanup is required to destroy a type with the given destruction kind.
Definition: CodeGenFunction.h:2068
clang::CodeGen::CodeGenFunction::ConditionalEvaluation::begin
void begin(CodeGenFunction &CGF)
Definition: CodeGenFunction.h:1181
clang::CodeGen::CGCXXABI::EmitBadTypeidCall
virtual void EmitBadTypeidCall(CodeGenFunction &CGF)=0
clang::interp::Zero
bool Zero(InterpState &S, CodePtr OpPC)
Definition: Interp.h:814
clang::CodeGen::CGCXXABI::EmitLoadOfMemberFunctionPointer
virtual CGCallee EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF, const Expr *E, Address This, llvm::Value *&ThisPtrForCall, llvm::Value *MemPtr, const MemberPointerType *MPT)
Load a member function from an object and a member function pointer.
Definition: CGCXXABI.cpp:41
clang::CXXDynamicCastExpr
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition: ExprCXX.h:477
clang::CodeGen::CodeGenTypes::arrangeCXXMethodDeclaration
const CGFunctionInfo & arrangeCXXMethodDeclaration(const CXXMethodDecl *MD)
C++ methods have some special rules and also have implicit parameters.
Definition: CGCall.cpp:283
clang::CodeGen::CGCUDARuntime::EmitCUDAKernelCallExpr
virtual RValue EmitCUDAKernelCallExpr(CodeGenFunction &CGF, const CUDAKernelCallExpr *E, ReturnValueSlot ReturnValue)
Definition: CGCUDARuntime.cpp:26
clang::InitListExpr::isStringLiteralInit
bool isStringLiteralInit() const
Definition: Expr.cpp:2291
clang::CodeGen::CodeGenFunction::pushCallObjectDeleteCleanup
void pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete, llvm::Value *CompletePtr, QualType ElementType)
Definition: CGExprCXX.cpp:1869
clang::CXXConstructExpr::CK_Delegating
@ CK_Delegating
Definition: ExprCXX.h:1468
clang::Type::getPointeeType
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition: Type.cpp:625
clang::CXXDeleteExpr::getOperatorDelete
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:2437
clang::CodeGen::CodeGenModule::getTypes
CodeGenTypes & getTypes()
Definition: CodeGenModule.h:726
clang::CXXTypeidExpr::getTypeOperand
QualType getTypeOperand(ASTContext &Context) const
Retrieves the type operand of this typeid() expression after various required adjustments (removing r...
Definition: ExprCXX.cpp:161
clang::CXXConstructExpr::getConstructor
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1532
clang::ExprWithCleanups
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition: ExprCXX.h:3342
clang::Type::getAsCXXRecordDecl
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1760
clang::TagDecl::isUnion
bool isUnion() const
Definition: Decl.h:3521
clang::CodeGen::AggValueSlot::IsDestructed
@ IsDestructed
Definition: CGValue.h:525
clang::CodeGen::CGCXXABI::getVBPtrOffsets
virtual std::vector< CharUnits > getVBPtrOffsets(const CXXRecordDecl *RD)
Gets the offsets of all the virtual base pointers in a given class.
Definition: CGCXXABI.cpp:293
EmitDynamicCastToNull
static llvm::Value * EmitDynamicCastToNull(CodeGenFunction &CGF, QualType DestTy)
Definition: CGExprCXX.cpp:2221
clang::CodeGen::CGBuilderTy::getSize
llvm::ConstantInt * getSize(CharUnits N)
Definition: CGBuilder.h:59
clang::CodeGen::CGBuilderTy::CreateConstInBoundsByteGEP
Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset, const llvm::Twine &Name="")
Given a pointer to i8, adjust it by a given constant offset.
Definition: CGBuilder.h:254
clang::CodeGen::CodeGenFunction::EvaluationOrder::ForceRightToLeft
@ ForceRightToLeft
! Language semantics require right-to-left evaluation.
clang::CodeGen::CodeGenFunction::getContext
ASTContext & getContext() const
Definition: CodeGenFunction.h:1975
clang::CodeGen::CodeGenTypeCache::getPointerSize
CharUnits getPointerSize() const
Definition: CodeGenTypeCache.h:114
clang::CharUnits::Zero
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
clang::CodeGen::CodeGenFunction::DeactivateCleanupBlock
void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)
DeactivateCleanupBlock - Deactivates the given cleanup block.
Definition: CGCleanup.cpp:1271
clang::CodeGen::Address
An aligned address.
Definition: Address.h:24
Base
clang::FunctionDecl::getOverloadedOperator
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
Definition: Decl.cpp:3658
clang::CodeGen::CodeGenFunction::SanOpts
SanitizerSet SanOpts
Sanitizers enabled for this function.
Definition: CodeGenFunction.h:518
clang::CodeGen::CodeGenFunction::getEvaluationKind
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
Definition: CodeGenFunction.cpp:215
clang::CodeGen::CodeGenFunction::TCK_ConstructorCall
@ TCK_ConstructorCall
Checking the 'this' pointer for a constructor call.
Definition: CodeGenFunction.h:2956
clang::CXXNewExpr::getAllocatedTypeSourceInfo
TypeSourceInfo * getAllocatedTypeSourceInfo() const
Definition: ExprCXX.h:2236
clang::CodeGen::CodeGenFunction::ConditionalEvaluation
An object to manage conditionally-evaluated expressions.
Definition: CodeGenFunction.h:1174
clang::ast_matchers::arrayType
const AstTypeMatcher< ArrayType > arrayType
Matches all kinds of arrays.
Definition: ASTMatchersInternal.cpp:1034
clang::CharUnits::isNegative
bool isNegative() const
isNegative - Test whether the quantity is less than zero.
Definition: CharUnits.h:125
clang::Qualifiers::OCL_Autoreleasing
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
Definition: Type.h:179
clang::MemberExpr::getMemberDecl
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:3245
clang::CodeGen::CGCallee::forDirect
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
Definition: CGCall.h:135
clang::interp::Null
bool Null(InterpState &S, CodePtr OpPC)
Definition: Interp.h:820
clang::CodeGen::CodeGenFunction::CurGD
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
Definition: CodeGenFunction.h:350
clang::CodeGen::CodeGenFunction::EmitDeleteCall
void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr, QualType DeleteTy, llvm::Value *NumElements=nullptr, CharUnits CookieSize=CharUnits())
Definition: CGExprCXX.cpp:1779
clang::CodeGen::CodeGenFunction::EmitIgnoredExpr
void EmitIgnoredExpr(const Expr *E)
EmitIgnoredExpr - Emit an expression in a context which ignores the result.
Definition: CGExpr.cpp:190
clang::CXXConstructorDecl::isDefaultConstructor
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:2635
clang::Type::isAlignValT
bool isAlignValT() const
Definition: Type.cpp:2733
clang::CXXRecordDecl::isEmpty
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Definition: DeclCXX.h:1141
clang::LangAS
LangAS
Defines the address space values used by the address space qualifier of QualType.
Definition: AddressSpaces.h:25
clang::FunctionDecl::isDestroyingOperatorDelete
bool isDestroyingOperatorDelete() const
Determine whether this is a destroying operator delete.
Definition: Decl.cpp:3203
clang::CodeGen::CodeGenTypes::GetFunctionType
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition: CGCall.cpp:1595
clang::Type::castAs
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7230
clang::CodeGen::ApplyDebugLocation
A scoped helper to set the current debug location to the specified location or preferred location of ...
Definition: CGDebugInfo.h:785
clang::ASTRecordLayout
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:38
clang::CodeGen::AggValueSlot::isSanitizerChecked
bool isSanitizerChecked() const
Definition: CGValue.h:635
clang::MemberExpr::getBase
Expr * getBase() const
Definition: Expr.h:3239
EnterNewDeleteCleanup
static void EnterNewDeleteCleanup(CodeGenFunction &CGF, const CXXNewExpr *E, Address NewPtr, llvm::Value *AllocSize, CharUnits AllocAlign, const CallArgList &NewArgs)
Enter a cleanup to call 'operator delete' if the initializer in a new-expression throws.
Definition: CGExprCXX.cpp:1488
clang::CodeGen::CodeGenTypes::arrangeCXXMethodCall
const CGFunctionInfo & arrangeCXXMethodCall(const CallArgList &args, const FunctionProtoType *type, RequiredArgs required, unsigned numPrefixArgs)
Arrange a call to a C++ method, passing the given arguments.
Definition: CGCall.cpp:679
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:255
clang::CXXMethodDecl::getMethodQualifiers
Qualifiers getMethodQualifiers() const
Definition: DeclCXX.h:2093
clang::CodeGen::CodeGenFunction::EmitCXXMemberOrOperatorMemberCallExpr
RValue EmitCXXMemberOrOperatorMemberCallExpr(const CallExpr *CE, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue, bool HasQualifier, NestedNameSpecifier *Qualifier, bool IsArrow, const Expr *Base)
Definition: CGExprCXX.cpp:208
clang::CodeGen::CodeGenTypes::DeriveThisType
CanQualType DeriveThisType(const CXXRecordDecl *RD, const CXXMethodDecl *MD)
Derives the 'this' type for codegen purposes, i.e.
Definition: CGCall.cpp:77
clang::CodeGen::CodeGenFunction::initFullExprCleanup
void initFullExprCleanup()
Set up the last cleanup that was pushed as a conditional full-expression cleanup.
Definition: CodeGenFunction.h:820
clang::CodeGen::LValue
LValue - This represents an lvalue references.
Definition: CGValue.h:167
clang::CodeGen::CodeGenFunction::EHStack
EHScopeStack EHStack
Definition: CodeGenFunction.h:613
getUsualDeleteParams
static UsualDeleteParams getUsualDeleteParams(const FunctionDecl *FD)
Definition: CGExprCXX.cpp:1361
clang::CodeGen::AggValueSlot::forAddr
static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)
forAddr - Make a slot for an aggregate value.
Definition: CGValue.h:548
clang::CodeGen::CodeGenFunction::getTargetHooks
const TargetCodeGenInfo & getTargetHooks() const
Definition: CodeGenFunction.h:2019
clang::Type::isPointerType
bool isPointerType() const
Definition: Type.h:6676
clang::CodeGen::CodeGenModule::EmitExplicitCastExprType
void EmitExplicitCastExprType(const ExplicitCastExpr *E, CodeGenFunction *CGF=nullptr)
Emit type info if type of an expression is a variably modified type.
Definition: CGExpr.cpp:1043
clang::CodeGen::Address::getPointer
llvm::Value * getPointer() const
Definition: Address.h:37
clang::CodeGen::CodeGenFunction
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
Definition: CodeGenFunction.h:235
clang::CodeGen::CodeGenFunction::EmitAggregateAssign
void EmitAggregateAssign(LValue Dest, LValue Src, QualType EltTy)
Emit an aggregate assignment.
Definition: CodeGenFunction.h:2685
clang::CodeGen::RequiredArgs
A class for recording the number of arguments that a function signature requires.
Definition: CGFunctionInfo.h:480
clang::BinaryOperator::getLHS
Expr * getLHS() const
Definition: Expr.h:3852
clang::ASTContext::getPreferredTypeAlignInChars
CharUnits getPreferredTypeAlignInChars(QualType T) const
Return the PreferredAlignment of a (complete) type T, in characters.
Definition: ASTContext.h:2310
clang::CharUnits::isZero
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
clang::CodeGen::CodeGenModule::getCXXABI
CGCXXABI & getCXXABI() const
Definition: CodeGenModule.h:719
clang::FunctionProtoType
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3885
clang::CodeGen::AggValueSlot::IsNotAliased
@ IsNotAliased
Definition: CGValue.h:524
clang::CodeGen::CodeGenTypes::arrangeCXXStructorDeclaration
const CGFunctionInfo & arrangeCXXStructorDeclaration(GlobalDecl GD)
Definition: CGCall.cpp:310
clang::DeclContext::getParent
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1860
clang::CodeGen::CodeGenFunction::emitArrayDestroy
void emitArrayDestroy(llvm::Value *begin, llvm::Value *end, QualType elementType, CharUnits elementAlign, Destroyer *destroyer, bool checkZeroLength, bool useEHCleanup)
emitArrayDestroy - Destroys all the elements of the given array, beginning from last to first.
Definition: CGDecl.cpp:2224
clang::Expr::getExprLoc
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:229
EmitNewDeleteCall
static RValue EmitNewDeleteCall(CodeGenFunction &CGF, const FunctionDecl *CalleeDecl, const FunctionProtoType *CalleeType, const CallArgList &Args)
Emit a call to an operator new or operator delete function, as implicitly created by new-expressions ...
Definition: CGExprCXX.cpp:1309
clang::CXXDeleteExpr
Represents a delete expression for memory deallocation and destructor calls, e.g.
Definition: ExprCXX.h:2398
clang::CodeGen::CodeGenFunction::EmitARCRelease
void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
Release the given object.
Definition: CGObjC.cpp:2406
clang::QualType::isNull
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:738
clang::CodeGen::CodeGenModule::GetAddrOfRTTIDescriptor
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
Definition: CodeGenModule.cpp:6363
clang::CodeGen::CodeGenFunction::EmitScalarInit
void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
Definition: CGDecl.cpp:763
Value
Value
Definition: UninitializedValues.cpp:102
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:89
clang::CXXTypeidExpr::isTypeOperand
bool isTypeOperand() const
Definition: ExprCXX.h:875
clang::CodeGen::CodeGenFunction::EmitAggExpr
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type.
Definition: CGExprAgg.cpp:1991
clang::CXXNewExpr::shouldNullCheckAllocation
bool shouldNullCheckAllocation() const
True if the allocation result needs to be null-checked.
Definition: ExprCXX.cpp:277
clang::CodeGen::CodeGenFunction::EmitCXXMemberPointerCallExpr
RValue EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E, ReturnValueSlot ReturnValue)
Definition: CGExprCXX.cpp:431
clang::FunctionDecl::isReplaceableGlobalAllocationFunction
bool isReplaceableGlobalAllocationFunction(Optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
Definition: Decl.cpp:3124
clang::CodeGen::Address::invalid
static Address invalid()
Definition: Address.h:34
clang::CodeGen::CGCallee
All available information about a concrete callee.
Definition: CGCall.h:67
clang::QualType::isPODType
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:2350
clang::QualType::DestructionKind
DestructionKind
Definition: Type.h:1202
clang::CodeGen::CodeGenFunction::getTypes
CodeGenTypes & getTypes() const
Definition: CodeGenFunction.h:1974
clang::FunctionProtoType::getNumParams
unsigned getNumParams() const
Definition: Type.h:4095
clang::CodeGen::AggValueSlot
An aggregate value slot.
Definition: CGValue.h:471
clang::CodeGen::CodeGenFunction::ConvertType
llvm::Type * ConvertType(QualType T)
Definition: CodeGenFunction.cpp:211
clang::CodeGen::EHScopeStack::pushCleanupWithExtra
T * pushCleanupWithExtra(CleanupKind Kind, size_t N, As... A)
Push a cleanup with non-constant storage requirements on the stack.
Definition: EHScopeStack.h:308
clang::CXXDeleteExpr::getDestroyedType
QualType getDestroyedType() const
Retrieve the type being destroyed.
Definition: ExprCXX.cpp:287
clang::CodeGen::CodeGenFunction::EmitCXXConstructorCall
void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type, bool ForVirtualBase, bool Delegating, AggValueSlot ThisAVS, const CXXConstructExpr *E)
Definition: CGClass.cpp:2056
clang::CodeGen::NormalAndEHCleanup
@ NormalAndEHCleanup
Definition: EHScopeStack.h:86
clang::CodeGen::AggValueSlot::isZeroed
IsZeroed_t isZeroed() const
Definition: CGValue.h:648
clang::CodeGen::Address::getElementType
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:51
clang::CodeGen::CodeGenFunction::MakeAddrLValue
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
Definition: CodeGenFunction.h:2484
clang::CXXRecordDecl::hasTrivialDestructor
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1311
clang::CodeGen::CodeGenFunction::EmitSynthesizedCXXCopyCtor
void EmitSynthesizedCXXCopyCtor(Address Dest, Address Src, const Expr *Exp)
Definition: CGExprCXX.cpp:659
clang::CodeGen::CGCXXABI::shouldTypeidBeNullChecked
virtual bool shouldTypeidBeNullChecked(bool IsDeref, QualType SrcRecordTy)=0
clang::CodeGen::CGBuilderTy::CreateElementBitCast
Address CreateElementBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Cast the element type of the given address to a different type, preserving information like the align...
Definition: CGBuilder.h:166
clang::Expr::isTemporaryObject
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:3050
clang::CodeGen::CodeGenFunction::EmitScalarExpr
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...
Definition: CGExprScalar.cpp:4848
clang::CXXRecordDecl::getDestructor
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:1889
clang::CodeGen::LValueBaseInfo::getAlignmentSource
AlignmentSource getAlignmentSource() const
Definition: CGValue.h:156
clang::MemberPointerType
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2831
getCXXRecord
static CXXRecordDecl * getCXXRecord(const Expr *E)
Definition: CGExprCXX.cpp:171
clang::CodeGen::CGFunctionInfo
CGFunctionInfo - Class to encapsulate the information about a function definition.
Definition: CGFunctionInfo.h:546
EmitCXXNewAllocSize
static llvm::Value * EmitCXXNewAllocSize(CodeGenFunction &CGF, const CXXNewExpr *e, unsigned minElements, llvm::Value *&numElements, llvm::Value *&sizeWithoutCookie)
Definition: CGExprCXX.cpp:694
clang::CodeGen::CodeGenFunction::EmitCXXTypeidExpr
llvm::Value * EmitCXXTypeidExpr(const CXXTypeidExpr *E)
Definition: CGExprCXX.cpp:2196
clang::CodeGen::AggValueSlot::Overlap_t
Overlap_t
Definition: CGValue.h:527
CGCXXABI.h
clang::CodeGen::AggValueSlot::isIgnored
bool isIgnored() const
Definition: CGValue.h:619
EmitNullBaseClassInitialization
static void EmitNullBaseClassInitialization(CodeGenFunction &CGF, Address DestPtr, const CXXRecordDecl *Base)
Definition: CGExprCXX.cpp:496
clang::CodeGen::CGCXXABI::shouldDynamicCastCallBeNullChecked
virtual bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr, QualType SrcRecordTy)=0
clang::PointerType
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2640
clang::CodeGen::RequiredArgs::forPrototypePlus
static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype, unsigned additional)
Compute the arguments required by the given formal prototype, given that there may be some additional...
Definition: CGFunctionInfo.h:497
clang::CUDAKernelCallExpr
Represents a call to a CUDA kernel function.
Definition: ExprCXX.h:232
clang::Qualifiers::OCL_None
@ OCL_None
There is no lifetime qualification on this type.
Definition: Type.h:162
clang::EnumType::getDecl
EnumDecl * getDecl() const
Definition: Type.h:4646
clang::CodeGen::CodeGenFunction::CGM
CodeGenModule & CGM
Definition: CodeGenFunction.h:266
clang::interp::This
bool This(InterpState &S, CodePtr OpPC)
Definition: Interp.h:829
clang::CXXConstructExpr::CK_NonVirtualBase
@ CK_NonVirtualBase
Definition: ExprCXX.h:1466
clang::CodeGen::TEK_Scalar
@ TEK_Scalar
Definition: CodeGenFunction.h:113
clang::FunctionDecl::isReservedGlobalPlacementOperator
bool isReservedGlobalPlacementOperator() const
Determines whether this operator new or delete is one of the reserved global placement operators: voi...
Definition: Decl.cpp:3101
clang::CodeGen::CGCXXABI::EmitDynamicCastToVoid
virtual llvm::Value * EmitDynamicCastToVoid(CodeGenFunction &CGF, Address Value, QualType SrcRecordTy, QualType DestTy)=0
clang::CodeGen::CodeGenFunction::CFITCK_NVCall
@ CFITCK_NVCall
Definition: CodeGenFunction.h:2289
clang::Expr::IgnoreParens
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
Definition: Expr.cpp:2912
clang
Definition: CalledOnceCheck.h:17
clang::DeclContext::lookup
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1645
clang::CXXDynamicCastExpr::isAlwaysNull
bool isAlwaysNull() const
isAlwaysNull - Return whether the result of the dynamic_cast is proven to always be null.
Definition: ExprCXX.cpp:767
clang::CodeGen::RValue::get
static RValue get(llvm::Value *V)
Definition: CGValue.h:86
clang::CodeGen::CodeGenFunction::EmitCallArgs
void EmitCallArgs(CallArgList &Args, PrototypeWrapper Prototype, llvm::iterator_range< CallExpr::const_arg_iterator > ArgRange, AbstractCallee AC=AbstractCallee(), unsigned ParamsToSkip=0, EvaluationOrder Order=EvaluationOrder::Default)
EmitCallArgs - Emit call arguments for a function.
Definition: CGCall.cpp:4078
clang::ASTContext::toCharUnitsFromBits
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
Definition: ASTContext.cpp:2439
clang::CodeGen::CodeGenTypes::arrangeFreeFunctionCall
const CGFunctionInfo & arrangeFreeFunctionCall(const CallArgList &Args, const FunctionType *Ty, bool ChainCall)
Figure out the rules for calling a function with the given formal type using the given arguments.
Definition: CGCall.cpp:615
CGCUDARuntime.h
clang::CodeGen::CallArgList::addFrom
void addFrom(const CallArgList &other)
Add all the arguments from another CallArgList to this one.
Definition: CGCall.h:297
clang::CodeGen::AggValueSlot::getAddress
Address getAddress() const
Definition: CGValue.h:615
clang::CXXConstructExpr::CK_VirtualBase
@ CK_VirtualBase
Definition: ExprCXX.h:1467
clang::BinaryOperator::getRHS
Expr * getRHS() const
Definition: Expr.h:3854
std::arg
__DEVICE__ _Tp arg(const std::complex< _Tp > &__c)
Definition: complex_cmath.h:40
clang::CXXNewExpr::placement_arguments
llvm::iterator_range< arg_iterator > placement_arguments()
Definition: ExprCXX.h:2344
clang::CodeGen::CodeGenModule::getNaturalTypeAlignment
CharUnits getNaturalTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, bool forPointeeType=false)
Definition: CodeGenModule.cpp:6527
clang::EnumDecl::getIntegerType
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
Definition: Decl.h:3755
clang::CodeGen::CodeGenFunction::EmitCXXDeleteExpr
void EmitCXXDeleteExpr(const CXXDeleteExpr *E)
Definition: CGExprCXX.cpp:2060
clang::CodeGen::CGCallee::forVirtual
static CGCallee forVirtual(const CallExpr *CE, GlobalDecl MD, Address Addr, llvm::FunctionType *FTy)
Definition: CGCall.h:145
clang::Expr::getType
QualType getType() const
Definition: Expr.h:141
clang::CodeGen::CodeGenFunction::EmitCXXOperatorMemberCallExpr
RValue EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue)
Definition: CGExprCXX.cpp:481
clang::CXXRecordDecl::hasDefinition
bool hasDefinition() const
Definition: DeclCXX.h:542
clang::CodeGen::RValue::getScalarVal
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition: CGValue.h:59
clang::CXXNewExpr::getOperatorDelete
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:2259
clang::GlobalDecl::getCtorType
CXXCtorType getCtorType() const
Definition: GlobalDecl.h:105
clang::CXXNewExpr::hasInitializer
bool hasInitializer() const
Whether this new-expression has any initializer at all.
Definition: ExprCXX.h:2301
clang::CXXPseudoDestructorExpr::getBase
Expr * getBase() const
Definition: ExprCXX.h:2560
clang::CXXDeleteExpr::getArgument
Expr * getArgument()
Definition: ExprCXX.h:2439
clang::CodeGen::CodeGenFunction::BuildAppleKextVirtualCall
CGCallee BuildAppleKextVirtualCall(const CXXMethodDecl *MD, NestedNameSpecifier *Qual, llvm::Type *Ty)
BuildAppleKextVirtualCall - This routine is to support gcc's kext ABI making indirect call to virtual...
Definition: CGCXX.cpp:276
clang::CXXMethodDecl::getDevirtualizedMethod
CXXMethodDecl * getDevirtualizedMethod(const Expr *Base, bool IsAppleKext)
If it's possible to devirtualize a call to this method, return the called function.
Definition: DeclCXX.cpp:2199
clang::FunctionDecl::isVariadic
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2922
clang::Type::isConstantArrayType
bool isConstantArrayType() const
Definition: Type.h:6746
clang::CodeGen::EHScopeStack::stable_begin
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
Definition: EHScopeStack.h:384
clang::SanitizerSet::set
void set(SanitizerMask K, bool Value)
Enable or disable a certain (single) sanitizer.
Definition: Sanitizers.h:164
clang::ASTContext::getASTRecordLayout
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
Definition: RecordLayoutBuilder.cpp:3246
clang::GlobalDecl::getDecl
const Decl * getDecl() const
Definition: GlobalDecl.h:103
clang::CodeGen::CodeGenModule::getCUDARuntime
CGCUDARuntime & getCUDARuntime()
Return a reference to the configured CUDA runtime.
Definition: CodeGenModule.h:622
clang::CXXPseudoDestructorExpr::isArrow
bool isArrow() const
Determine whether this pseudo-destructor expression was written using an '->' (otherwise,...
Definition: ExprCXX.h:2580
clang::CodeGen::ConstantEmitter
Definition: ConstantEmitter.h:23
clang::MemberExpr
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:3162
clang::CodeGen::CodeGenFunction::EmitLValue
LValue EmitLValue(const Expr *E)
EmitLValue - Emit code to compute a designator that specifies the location of the expression.
Definition: CGExpr.cpp:1272
clang::CXXRecordDecl::isDynamicClass
bool isDynamicClass() const
Definition: DeclCXX.h:555
clang::RecordType::getDecl
RecordDecl * getDecl() const
Definition: Type.h:4623
clang::ASTContext::getPointerType
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
Definition: ASTContext.cpp:3249
clang::CodeGen::CGCXXABI::EmitVirtualDestructorCall
virtual llvm::Value * EmitVirtualDestructorCall(CodeGenFunction &CGF, const CXXDestructorDecl *Dtor, CXXDtorType DtorType, Address This, DeleteOrMemberCallExpr E)=0
Emit the ABI-specific virtual destructor call.
clang::CodeGen::TargetCodeGenInfo::performAddrSpaceCast
virtual llvm::Value * performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, llvm::Value *V, LangAS SrcAddr, LangAS DestAddr, llvm::Type *DestTy, bool IsNonNull=false) const
Perform address space cast of an expression of pointer type.
Definition: TargetInfo.cpp:497
clang::ReferenceType
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2751
clang::CodeGen::ConstantEmitter::tryEmitAbstract
llvm::Constant * tryEmitAbstract(const Expr *E, QualType T)
Try to emit the result of the given expression as an abstract constant.
Definition: CGExprConstant.cpp:1353
clang::CharUnits
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
clang::CodeGen::CodeGenFunction::EmitBuiltinNewDeleteCall
RValue EmitBuiltinNewDeleteCall(const FunctionProtoType *Type, const CallExpr *TheCallExpr, bool IsDelete)
Definition: CGExprCXX.cpp:1335
clang::PointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2650
clang::CodeGen::CodeGenFunction::TCK_MemberCall
@ TCK_MemberCall
Checking the 'this' pointer for a call to a non-static member function.
Definition: CodeGenFunction.h:2954
clang::CodeGen::CodeGenTypes::isZeroInitializable
bool isZeroInitializable(QualType T)
IsZeroInitializable - Return whether a type can be zero-initialized (in the C++ sense) with an LLVM z...
Definition: CodeGenTypes.cpp:897
clang::CXXConstructExpr::getArg
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1611
clang::ASTContext::hasSameType
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2490
clang::CXXNewExpr::getArraySize
Optional< Expr * > getArraySize()
Definition: ExprCXX.h:2264
clang::CodeGen::CodeGenFunction::IsWrappedCXXThis
static bool IsWrappedCXXThis(const Expr *E)
Check if E is a C++ "this" pointer wrapped in value-preserving casts.
Definition: CGExpr.cpp:1213
clang::CodeGen::CodeGenFunction::AbstractCallee
An abstract representation of regular/ObjC call/message targets.
Definition: CodeGenFunction.h:493
clang::CallExpr::arguments
arg_range arguments()
Definition: Expr.h:3034
clang::ValueDecl::getType
QualType getType() const
Definition: Decl.h:687
clang::Type::isIntegerType
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6991
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::CodeGen::CodeGenModule::getAddrOfCXXStructor
llvm::Constant * getAddrOfCXXStructor(GlobalDecl GD, const CGFunctionInfo *FnInfo=nullptr, llvm::FunctionType *FnType=nullptr, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the constructor/destructor of the given type.
Definition: CodeGenModule.h:1022
clang::CodeGen::CodeGenFunction::EmitPointerWithAlignment
Address EmitPointerWithAlignment(const Expr *Addr, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
EmitPointerWithAlignment - Given an expression with a pointer type, emit the value and compute our be...
Definition: CGExpr.cpp:1059
clang::QualType::isDestructedType
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
Definition: Type.h:1214
clang::CodeGen::CodeGenTypeCache::Int8Ty
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
Definition: CodeGenTypeCache.h:37
clang::CodeGen::CodeGenModule::getIntrinsic
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys=None)
Definition: CodeGenModule.cpp:5181
commonEmitCXXMemberOrOperatorCall
static MemberCallInfo commonEmitCXXMemberOrOperatorCall(CodeGenFunction &CGF, const CXXMethodDecl *MD, llvm::Value *This, llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *CE, CallArgList &Args, CallArgList *RtlArgs)
Definition: CGExprCXX.cpp:36
clang::EnumType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
Definition: Type.h:4639
clang::CodeGen::CodeGenFunction::isInConditionalBranch
bool isInConditionalBranch() const
isInConditionalBranch - Return true if we're currently emitting one branch or the other of a conditio...
Definition: CodeGenFunction.h:1202
clang::CodeGen::CallArgList
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:264
EmitDestroyingObjectDelete
static void EmitDestroyingObjectDelete(CodeGenFunction &CGF, const CXXDeleteExpr *DE, Address Ptr, QualType ElementType)
Emit the code for deleting a single object with a destroying operator delete.
Definition: CGExprCXX.cpp:1880
clang::CodeGen::CGBuilderTy::CreateMemSet
llvm::CallInst * CreateMemSet(Address Dest, llvm::Value *Value, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:315
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1857
clang::CodeGen::AggValueSlot::IsNotZeroed
@ IsNotZeroed
Definition: CGValue.h:526
clang::CallExpr
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2795
clang::CodeGen::CodeGenFunction::EmitBlock
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:532
clang::InitListExpr::getNumInits
unsigned getNumInits() const
Definition: Expr.h:4816
clang::CXXOperatorCallExpr
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:82
clang::CodeGen::CGCXXABI::GetArrayCookieSize
virtual CharUnits GetArrayCookieSize(const CXXNewExpr *expr)
Returns the extra size required in order to store the array cookie for the given new-expression.
Definition: CGCXXABI.cpp:164
clang::CXXConstructExpr
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1460
clang::CXXConstructExpr::getConstructionKind
ConstructionKind getConstructionKind() const
Determine whether this constructor is actually constructing a base class (rather than a complete obje...
Definition: ExprCXX.h:1580
clang::CXXMemberCallExpr
Represents a call to a member function that may be written either with member call syntax (e....
Definition: ExprCXX.h:177
clang::CharUnits::getQuantity
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
clang::CodeGen::EHScopeStack::stable_iterator
A saved depth on the scope stack.
Definition: EHScopeStack.h:101
clang::CodeGen::CodeGenFunction::getLangOpts
const LangOptions & getLangOpts() const
Definition: CodeGenFunction.h:1988
clang::CXXConstructExpr::isElidable
bool isElidable() const
Whether this construction is elidable.
Definition: ExprCXX.h:1538
clang::CodeGen::CGCXXABI::EmitDynamicCastCall
virtual llvm::Value * EmitDynamicCastCall(CodeGenFunction &CGF, Address Value, QualType SrcRecordTy, QualType DestTy, QualType DestRecordTy, llvm::BasicBlock *CastEnd)=0
clang::CXXMethodDecl::isVirtual
bool isVirtual() const
Definition: DeclCXX.h:1992
clang::ExplicitCastExpr::getTypeAsWritten
QualType getTypeAsWritten() const
getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...
Definition: Expr.h:3720
clang::CodeGen::CodeGenModule::EmitNullConstantForBase
llvm::Constant * EmitNullConstantForBase(const CXXRecordDecl *Record)
Return a null constant appropriate for zero-initializing a base class with the given type.
Definition: CGExprConstant.cpp:2339
clang::declaresSameEntity
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1198
clang::TypeSourceInfo::getTypeLoc
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:244
clang::CodeGen::CGBuilderTy::CreateLoad
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:68
clang::CodeGen::CodeGenFunction::EmitBranch
void EmitBranch(llvm::BasicBlock *Block)
EmitBranch - Emit a branch to the specified basic block from the current insert block,...
Definition: CGStmt.cpp:552
clang::CXXMethodDecl::getParent
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
Definition: DeclCXX.h:2063
clang::CXXMethodDecl
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1948
clang::CodeGen::CodeGenFunction::ConditionalEvaluation::end
void end(CodeGenFunction &CGF)
Definition: CodeGenFunction.h:1187
clang::CodeGen::CodeGenFunction::ReturnValue
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
Definition: CodeGenFunction.h:361
clang::CodeGen::CodeGenFunction::Target
const TargetInfo & Target
Definition: CodeGenFunction.h:267
clang::CodeGen::AggValueSlot::DoesNotOverlap
@ DoesNotOverlap
Definition: CGValue.h:527