clang  6.0.0svn
CGClass.cpp
Go to the documentation of this file.
1 //===--- CGClass.cpp - Emit LLVM Code for C++ classes -----------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This contains code dealing with C++ code generation of classes
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CGBlocks.h"
15 #include "CGCXXABI.h"
16 #include "CGDebugInfo.h"
17 #include "CGRecordLayout.h"
18 #include "CodeGenFunction.h"
20 #include "clang/AST/DeclTemplate.h"
22 #include "clang/AST/RecordLayout.h"
23 #include "clang/AST/StmtCXX.h"
27 #include "llvm/IR/Intrinsics.h"
28 #include "llvm/IR/Metadata.h"
29 #include "llvm/Transforms/Utils/SanitizerStats.h"
30 
31 using namespace clang;
32 using namespace CodeGen;
33 
34 /// Return the best known alignment for an unknown pointer to a
35 /// particular class.
37  if (!RD->isCompleteDefinition())
38  return CharUnits::One(); // Hopefully won't be used anywhere.
39 
40  auto &layout = getContext().getASTRecordLayout(RD);
41 
42  // If the class is final, then we know that the pointer points to an
43  // object of that type and can use the full alignment.
44  if (RD->hasAttr<FinalAttr>()) {
45  return layout.getAlignment();
46 
47  // Otherwise, we have to assume it could be a subclass.
48  } else {
49  return layout.getNonVirtualAlignment();
50  }
51 }
52 
53 /// Return the best known alignment for a pointer to a virtual base,
54 /// given the alignment of a pointer to the derived class.
56  const CXXRecordDecl *derivedClass,
57  const CXXRecordDecl *vbaseClass) {
58  // The basic idea here is that an underaligned derived pointer might
59  // indicate an underaligned base pointer.
60 
61  assert(vbaseClass->isCompleteDefinition());
62  auto &baseLayout = getContext().getASTRecordLayout(vbaseClass);
63  CharUnits expectedVBaseAlign = baseLayout.getNonVirtualAlignment();
64 
65  return getDynamicOffsetAlignment(actualDerivedAlign, derivedClass,
66  expectedVBaseAlign);
67 }
68 
71  const CXXRecordDecl *baseDecl,
72  CharUnits expectedTargetAlign) {
73  // If the base is an incomplete type (which is, alas, possible with
74  // member pointers), be pessimistic.
75  if (!baseDecl->isCompleteDefinition())
76  return std::min(actualBaseAlign, expectedTargetAlign);
77 
78  auto &baseLayout = getContext().getASTRecordLayout(baseDecl);
79  CharUnits expectedBaseAlign = baseLayout.getNonVirtualAlignment();
80 
81  // If the class is properly aligned, assume the target offset is, too.
82  //
83  // This actually isn't necessarily the right thing to do --- if the
84  // class is a complete object, but it's only properly aligned for a
85  // base subobject, then the alignments of things relative to it are
86  // probably off as well. (Note that this requires the alignment of
87  // the target to be greater than the NV alignment of the derived
88  // class.)
89  //
90  // However, our approach to this kind of under-alignment can only
91  // ever be best effort; after all, we're never going to propagate
92  // alignments through variables or parameters. Note, in particular,
93  // that constructing a polymorphic type in an address that's less
94  // than pointer-aligned will generally trap in the constructor,
95  // unless we someday add some sort of attribute to change the
96  // assumed alignment of 'this'. So our goal here is pretty much
97  // just to allow the user to explicitly say that a pointer is
98  // under-aligned and then safely access its fields and vtables.
99  if (actualBaseAlign >= expectedBaseAlign) {
100  return expectedTargetAlign;
101  }
102 
103  // Otherwise, we might be offset by an arbitrary multiple of the
104  // actual alignment. The correct adjustment is to take the min of
105  // the two alignments.
106  return std::min(actualBaseAlign, expectedTargetAlign);
107 }
108 
110  assert(CurFuncDecl && "loading 'this' without a func declaration?");
111  assert(isa<CXXMethodDecl>(CurFuncDecl));
112 
113  // Lazily compute CXXThisAlignment.
114  if (CXXThisAlignment.isZero()) {
115  // Just use the best known alignment for the parent.
116  // TODO: if we're currently emitting a complete-object ctor/dtor,
117  // we can always use the complete-object alignment.
118  auto RD = cast<CXXMethodDecl>(CurFuncDecl)->getParent();
119  CXXThisAlignment = CGM.getClassPointerAlignment(RD);
120  }
121 
122  return Address(LoadCXXThis(), CXXThisAlignment);
123 }
124 
125 /// Emit the address of a field using a member data pointer.
126 ///
127 /// \param E Only used for emergency diagnostics
128 Address
130  llvm::Value *memberPtr,
131  const MemberPointerType *memberPtrType,
132  LValueBaseInfo *BaseInfo,
133  TBAAAccessInfo *TBAAInfo) {
134  // Ask the ABI to compute the actual address.
135  llvm::Value *ptr =
136  CGM.getCXXABI().EmitMemberDataPointerAddress(*this, E, base,
137  memberPtr, memberPtrType);
138 
139  QualType memberType = memberPtrType->getPointeeType();
140  CharUnits memberAlign = getNaturalTypeAlignment(memberType, BaseInfo,
141  TBAAInfo);
142  memberAlign =
143  CGM.getDynamicOffsetAlignment(base.getAlignment(),
144  memberPtrType->getClass()->getAsCXXRecordDecl(),
145  memberAlign);
146  return Address(ptr, memberAlign);
147 }
148 
150  const CXXRecordDecl *DerivedClass, CastExpr::path_const_iterator Start,
153 
154  const ASTContext &Context = getContext();
155  const CXXRecordDecl *RD = DerivedClass;
156 
157  for (CastExpr::path_const_iterator I = Start; I != End; ++I) {
158  const CXXBaseSpecifier *Base = *I;
159  assert(!Base->isVirtual() && "Should not see virtual bases here!");
160 
161  // Get the layout.
162  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
163 
164  const CXXRecordDecl *BaseDecl =
165  cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
166 
167  // Add the offset.
168  Offset += Layout.getBaseClassOffset(BaseDecl);
169 
170  RD = BaseDecl;
171  }
172 
173  return Offset;
174 }
175 
176 llvm::Constant *
180  assert(PathBegin != PathEnd && "Base path should not be empty!");
181 
182  CharUnits Offset =
183  computeNonVirtualBaseClassOffset(ClassDecl, PathBegin, PathEnd);
184  if (Offset.isZero())
185  return nullptr;
186 
188  Types.ConvertType(getContext().getPointerDiffType());
189 
190  return llvm::ConstantInt::get(PtrDiffTy, Offset.getQuantity());
191 }
192 
193 /// Gets the address of a direct base class within a complete object.
194 /// This should only be used for (1) non-virtual bases or (2) virtual bases
195 /// when the type is known to be complete (e.g. in complete destructors).
196 ///
197 /// The object pointed to by 'This' is assumed to be non-null.
198 Address
200  const CXXRecordDecl *Derived,
201  const CXXRecordDecl *Base,
202  bool BaseIsVirtual) {
203  // 'this' must be a pointer (in some address space) to Derived.
204  assert(This.getElementType() == ConvertType(Derived));
205 
206  // Compute the offset of the virtual base.
208  const ASTRecordLayout &Layout = getContext().getASTRecordLayout(Derived);
209  if (BaseIsVirtual)
210  Offset = Layout.getVBaseClassOffset(Base);
211  else
212  Offset = Layout.getBaseClassOffset(Base);
213 
214  // Shift and cast down to the base type.
215  // TODO: for complete types, this should be possible with a GEP.
216  Address V = This;
217  if (!Offset.isZero()) {
218  V = Builder.CreateElementBitCast(V, Int8Ty);
219  V = Builder.CreateConstInBoundsByteGEP(V, Offset);
220  }
221  V = Builder.CreateElementBitCast(V, ConvertType(Base));
222 
223  return V;
224 }
225 
226 static Address
228  CharUnits nonVirtualOffset,
229  llvm::Value *virtualOffset,
230  const CXXRecordDecl *derivedClass,
231  const CXXRecordDecl *nearestVBase) {
232  // Assert that we have something to do.
233  assert(!nonVirtualOffset.isZero() || virtualOffset != nullptr);
234 
235  // Compute the offset from the static and dynamic components.
236  llvm::Value *baseOffset;
237  if (!nonVirtualOffset.isZero()) {
238  baseOffset = llvm::ConstantInt::get(CGF.PtrDiffTy,
239  nonVirtualOffset.getQuantity());
240  if (virtualOffset) {
241  baseOffset = CGF.Builder.CreateAdd(virtualOffset, baseOffset);
242  }
243  } else {
244  baseOffset = virtualOffset;
245  }
246 
247  // Apply the base offset.
248  llvm::Value *ptr = addr.getPointer();
249  ptr = CGF.Builder.CreateBitCast(ptr, CGF.Int8PtrTy);
250  ptr = CGF.Builder.CreateInBoundsGEP(ptr, baseOffset, "add.ptr");
251 
252  // If we have a virtual component, the alignment of the result will
253  // be relative only to the known alignment of that vbase.
254  CharUnits alignment;
255  if (virtualOffset) {
256  assert(nearestVBase && "virtual offset without vbase?");
257  alignment = CGF.CGM.getVBaseAlignment(addr.getAlignment(),
258  derivedClass, nearestVBase);
259  } else {
260  alignment = addr.getAlignment();
261  }
262  alignment = alignment.alignmentAtOffset(nonVirtualOffset);
263 
264  return Address(ptr, alignment);
265 }
266 
268  Address Value, const CXXRecordDecl *Derived,
270  CastExpr::path_const_iterator PathEnd, bool NullCheckValue,
271  SourceLocation Loc) {
272  assert(PathBegin != PathEnd && "Base path should not be empty!");
273 
274  CastExpr::path_const_iterator Start = PathBegin;
275  const CXXRecordDecl *VBase = nullptr;
276 
277  // Sema has done some convenient canonicalization here: if the
278  // access path involved any virtual steps, the conversion path will
279  // *start* with a step down to the correct virtual base subobject,
280  // and hence will not require any further steps.
281  if ((*Start)->isVirtual()) {
282  VBase =
283  cast<CXXRecordDecl>((*Start)->getType()->getAs<RecordType>()->getDecl());
284  ++Start;
285  }
286 
287  // Compute the static offset of the ultimate destination within its
288  // allocating subobject (the virtual base, if there is one, or else
289  // the "complete" object that we see).
290  CharUnits NonVirtualOffset = CGM.computeNonVirtualBaseClassOffset(
291  VBase ? VBase : Derived, Start, PathEnd);
292 
293  // If there's a virtual step, we can sometimes "devirtualize" it.
294  // For now, that's limited to when the derived type is final.
295  // TODO: "devirtualize" this for accesses to known-complete objects.
296  if (VBase && Derived->hasAttr<FinalAttr>()) {
297  const ASTRecordLayout &layout = getContext().getASTRecordLayout(Derived);
298  CharUnits vBaseOffset = layout.getVBaseClassOffset(VBase);
299  NonVirtualOffset += vBaseOffset;
300  VBase = nullptr; // we no longer have a virtual step
301  }
302 
303  // Get the base pointer type.
304  llvm::Type *BasePtrTy =
305  ConvertType((PathEnd[-1])->getType())->getPointerTo();
306 
307  QualType DerivedTy = getContext().getRecordType(Derived);
308  CharUnits DerivedAlign = CGM.getClassPointerAlignment(Derived);
309 
310  // If the static offset is zero and we don't have a virtual step,
311  // just do a bitcast; null checks are unnecessary.
312  if (NonVirtualOffset.isZero() && !VBase) {
313  if (sanitizePerformTypeCheck()) {
314  SanitizerSet SkippedChecks;
315  SkippedChecks.set(SanitizerKind::Null, !NullCheckValue);
316  EmitTypeCheck(TCK_Upcast, Loc, Value.getPointer(),
317  DerivedTy, DerivedAlign, SkippedChecks);
318  }
319  return Builder.CreateBitCast(Value, BasePtrTy);
320  }
321 
322  llvm::BasicBlock *origBB = nullptr;
323  llvm::BasicBlock *endBB = nullptr;
324 
325  // Skip over the offset (and the vtable load) if we're supposed to
326  // null-check the pointer.
327  if (NullCheckValue) {
328  origBB = Builder.GetInsertBlock();
329  llvm::BasicBlock *notNullBB = createBasicBlock("cast.notnull");
330  endBB = createBasicBlock("cast.end");
331 
332  llvm::Value *isNull = Builder.CreateIsNull(Value.getPointer());
333  Builder.CreateCondBr(isNull, endBB, notNullBB);
334  EmitBlock(notNullBB);
335  }
336 
337  if (sanitizePerformTypeCheck()) {
338  SanitizerSet SkippedChecks;
339  SkippedChecks.set(SanitizerKind::Null, true);
340  EmitTypeCheck(VBase ? TCK_UpcastToVirtualBase : TCK_Upcast, Loc,
341  Value.getPointer(), DerivedTy, DerivedAlign, SkippedChecks);
342  }
343 
344  // Compute the virtual offset.
345  llvm::Value *VirtualOffset = nullptr;
346  if (VBase) {
347  VirtualOffset =
348  CGM.getCXXABI().GetVirtualBaseClassOffset(*this, Value, Derived, VBase);
349  }
350 
351  // Apply both offsets.
352  Value = ApplyNonVirtualAndVirtualOffset(*this, Value, NonVirtualOffset,
353  VirtualOffset, Derived, VBase);
354 
355  // Cast to the destination type.
356  Value = Builder.CreateBitCast(Value, BasePtrTy);
357 
358  // Build a phi if we needed a null check.
359  if (NullCheckValue) {
360  llvm::BasicBlock *notNullBB = Builder.GetInsertBlock();
361  Builder.CreateBr(endBB);
362  EmitBlock(endBB);
363 
364  llvm::PHINode *PHI = Builder.CreatePHI(BasePtrTy, 2, "cast.result");
365  PHI->addIncoming(Value.getPointer(), notNullBB);
366  PHI->addIncoming(llvm::Constant::getNullValue(BasePtrTy), origBB);
367  Value = Address(PHI, Value.getAlignment());
368  }
369 
370  return Value;
371 }
372 
373 Address
375  const CXXRecordDecl *Derived,
378  bool NullCheckValue) {
379  assert(PathBegin != PathEnd && "Base path should not be empty!");
380 
381  QualType DerivedTy =
382  getContext().getCanonicalType(getContext().getTagDeclType(Derived));
383  llvm::Type *DerivedPtrTy = ConvertType(DerivedTy)->getPointerTo();
384 
385  llvm::Value *NonVirtualOffset =
386  CGM.GetNonVirtualBaseClassOffset(Derived, PathBegin, PathEnd);
387 
388  if (!NonVirtualOffset) {
389  // No offset, we can just cast back.
390  return Builder.CreateBitCast(BaseAddr, DerivedPtrTy);
391  }
392 
393  llvm::BasicBlock *CastNull = nullptr;
394  llvm::BasicBlock *CastNotNull = nullptr;
395  llvm::BasicBlock *CastEnd = nullptr;
396 
397  if (NullCheckValue) {
398  CastNull = createBasicBlock("cast.null");
399  CastNotNull = createBasicBlock("cast.notnull");
400  CastEnd = createBasicBlock("cast.end");
401 
402  llvm::Value *IsNull = Builder.CreateIsNull(BaseAddr.getPointer());
403  Builder.CreateCondBr(IsNull, CastNull, CastNotNull);
404  EmitBlock(CastNotNull);
405  }
406 
407  // Apply the offset.
408  llvm::Value *Value = Builder.CreateBitCast(BaseAddr.getPointer(), Int8PtrTy);
409  Value = Builder.CreateGEP(Value, Builder.CreateNeg(NonVirtualOffset),
410  "sub.ptr");
411 
412  // Just cast.
413  Value = Builder.CreateBitCast(Value, DerivedPtrTy);
414 
415  // Produce a PHI if we had a null-check.
416  if (NullCheckValue) {
417  Builder.CreateBr(CastEnd);
418  EmitBlock(CastNull);
419  Builder.CreateBr(CastEnd);
420  EmitBlock(CastEnd);
421 
422  llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2);
423  PHI->addIncoming(Value, CastNotNull);
424  PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()), CastNull);
425  Value = PHI;
426  }
427 
428  return Address(Value, CGM.getClassPointerAlignment(Derived));
429 }
430 
432  bool ForVirtualBase,
433  bool Delegating) {
434  if (!CGM.getCXXABI().NeedsVTTParameter(GD)) {
435  // This constructor/destructor does not need a VTT parameter.
436  return nullptr;
437  }
438 
439  const CXXRecordDecl *RD = cast<CXXMethodDecl>(CurCodeDecl)->getParent();
440  const CXXRecordDecl *Base = cast<CXXMethodDecl>(GD.getDecl())->getParent();
441 
442  llvm::Value *VTT;
443 
444  uint64_t SubVTTIndex;
445 
446  if (Delegating) {
447  // If this is a delegating constructor call, just load the VTT.
448  return LoadCXXVTT();
449  } else if (RD == Base) {
450  // If the record matches the base, this is the complete ctor/dtor
451  // variant calling the base variant in a class with virtual bases.
452  assert(!CGM.getCXXABI().NeedsVTTParameter(CurGD) &&
453  "doing no-op VTT offset in base dtor/ctor?");
454  assert(!ForVirtualBase && "Can't have same class as virtual base!");
455  SubVTTIndex = 0;
456  } else {
457  const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
458  CharUnits BaseOffset = ForVirtualBase ?
459  Layout.getVBaseClassOffset(Base) :
460  Layout.getBaseClassOffset(Base);
461 
462  SubVTTIndex =
463  CGM.getVTables().getSubVTTIndex(RD, BaseSubobject(Base, BaseOffset));
464  assert(SubVTTIndex != 0 && "Sub-VTT index must be greater than zero!");
465  }
466 
467  if (CGM.getCXXABI().NeedsVTTParameter(CurGD)) {
468  // A VTT parameter was passed to the constructor, use it.
469  VTT = LoadCXXVTT();
470  VTT = Builder.CreateConstInBoundsGEP1_64(VTT, SubVTTIndex);
471  } else {
472  // We're the complete constructor, so get the VTT by name.
473  VTT = CGM.getVTables().GetAddrOfVTT(RD);
474  VTT = Builder.CreateConstInBoundsGEP2_64(VTT, 0, SubVTTIndex);
475  }
476 
477  return VTT;
478 }
479 
480 namespace {
481  /// Call the destructor for a direct base class.
482  struct CallBaseDtor final : EHScopeStack::Cleanup {
483  const CXXRecordDecl *BaseClass;
484  bool BaseIsVirtual;
485  CallBaseDtor(const CXXRecordDecl *Base, bool BaseIsVirtual)
486  : BaseClass(Base), BaseIsVirtual(BaseIsVirtual) {}
487 
488  void Emit(CodeGenFunction &CGF, Flags flags) override {
489  const CXXRecordDecl *DerivedClass =
490  cast<CXXMethodDecl>(CGF.CurCodeDecl)->getParent();
491 
492  const CXXDestructorDecl *D = BaseClass->getDestructor();
493  Address Addr =
495  DerivedClass, BaseClass,
496  BaseIsVirtual);
497  CGF.EmitCXXDestructorCall(D, Dtor_Base, BaseIsVirtual,
498  /*Delegating=*/false, Addr);
499  }
500  };
501 
502  /// A visitor which checks whether an initializer uses 'this' in a
503  /// way which requires the vtable to be properly set.
504  struct DynamicThisUseChecker : ConstEvaluatedExprVisitor<DynamicThisUseChecker> {
506 
507  bool UsesThis;
508 
509  DynamicThisUseChecker(const ASTContext &C) : super(C), UsesThis(false) {}
510 
511  // Black-list all explicit and implicit references to 'this'.
512  //
513  // Do we need to worry about external references to 'this' derived
514  // from arbitrary code? If so, then anything which runs arbitrary
515  // external code might potentially access the vtable.
516  void VisitCXXThisExpr(const CXXThisExpr *E) { UsesThis = true; }
517  };
518 } // end anonymous namespace
519 
520 static bool BaseInitializerUsesThis(ASTContext &C, const Expr *Init) {
521  DynamicThisUseChecker Checker(C);
522  Checker.Visit(Init);
523  return Checker.UsesThis;
524 }
525 
527  const CXXRecordDecl *ClassDecl,
528  CXXCtorInitializer *BaseInit,
529  CXXCtorType CtorType) {
530  assert(BaseInit->isBaseInitializer() &&
531  "Must have base initializer!");
532 
533  Address ThisPtr = CGF.LoadCXXThisAddress();
534 
535  const Type *BaseType = BaseInit->getBaseClass();
536  CXXRecordDecl *BaseClassDecl =
537  cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl());
538 
539  bool isBaseVirtual = BaseInit->isBaseVirtual();
540 
541  // The base constructor doesn't construct virtual bases.
542  if (CtorType == Ctor_Base && isBaseVirtual)
543  return;
544 
545  // If the initializer for the base (other than the constructor
546  // itself) accesses 'this' in any way, we need to initialize the
547  // vtables.
548  if (BaseInitializerUsesThis(CGF.getContext(), BaseInit->getInit()))
549  CGF.InitializeVTablePointers(ClassDecl);
550 
551  // We can pretend to be a complete class because it only matters for
552  // virtual bases, and we only do virtual bases for complete ctors.
553  Address V =
554  CGF.GetAddressOfDirectBaseInCompleteClass(ThisPtr, ClassDecl,
555  BaseClassDecl,
556  isBaseVirtual);
557  AggValueSlot AggSlot =
562 
563  CGF.EmitAggExpr(BaseInit->getInit(), AggSlot);
564 
565  if (CGF.CGM.getLangOpts().Exceptions &&
566  !BaseClassDecl->hasTrivialDestructor())
567  CGF.EHStack.pushCleanup<CallBaseDtor>(EHCleanup, BaseClassDecl,
568  isBaseVirtual);
569 }
570 
572  auto *CD = dyn_cast<CXXConstructorDecl>(D);
573  if (!(CD && CD->isCopyOrMoveConstructor()) &&
575  return false;
576 
577  // We can emit a memcpy for a trivial copy or move constructor/assignment.
578  if (D->isTrivial() && !D->getParent()->mayInsertExtraPadding())
579  return true;
580 
581  // We *must* emit a memcpy for a defaulted union copy or move op.
582  if (D->getParent()->isUnion() && D->isDefaulted())
583  return true;
584 
585  return false;
586 }
587 
589  CXXCtorInitializer *MemberInit,
590  LValue &LHS) {
591  FieldDecl *Field = MemberInit->getAnyMember();
592  if (MemberInit->isIndirectMemberInitializer()) {
593  // If we are initializing an anonymous union field, drill down to the field.
594  IndirectFieldDecl *IndirectField = MemberInit->getIndirectMember();
595  for (const auto *I : IndirectField->chain())
596  LHS = CGF.EmitLValueForFieldInitialization(LHS, cast<FieldDecl>(I));
597  } else {
598  LHS = CGF.EmitLValueForFieldInitialization(LHS, Field);
599  }
600 }
601 
603  const CXXRecordDecl *ClassDecl,
604  CXXCtorInitializer *MemberInit,
605  const CXXConstructorDecl *Constructor,
606  FunctionArgList &Args) {
607  ApplyDebugLocation Loc(CGF, MemberInit->getSourceLocation());
608  assert(MemberInit->isAnyMemberInitializer() &&
609  "Must have member initializer!");
610  assert(MemberInit->getInit() && "Must have initializer!");
611 
612  // non-static data member initializers.
613  FieldDecl *Field = MemberInit->getAnyMember();
614  QualType FieldType = Field->getType();
615 
616  llvm::Value *ThisPtr = CGF.LoadCXXThis();
617  QualType RecordTy = CGF.getContext().getTypeDeclType(ClassDecl);
618  LValue LHS = CGF.MakeNaturalAlignAddrLValue(ThisPtr, RecordTy);
619 
620  EmitLValueForAnyFieldInitialization(CGF, MemberInit, LHS);
621 
622  // Special case: if we are in a copy or move constructor, and we are copying
623  // an array of PODs or classes with trivial copy constructors, ignore the
624  // AST and perform the copy we know is equivalent.
625  // FIXME: This is hacky at best... if we had a bit more explicit information
626  // in the AST, we could generalize it more easily.
627  const ConstantArrayType *Array
628  = CGF.getContext().getAsConstantArrayType(FieldType);
629  if (Array && Constructor->isDefaulted() &&
630  Constructor->isCopyOrMoveConstructor()) {
631  QualType BaseElementTy = CGF.getContext().getBaseElementType(Array);
632  CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(MemberInit->getInit());
633  if (BaseElementTy.isPODType(CGF.getContext()) ||
635  unsigned SrcArgIndex =
636  CGF.CGM.getCXXABI().getSrcArgforCopyCtor(Constructor, Args);
637  llvm::Value *SrcPtr
638  = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(Args[SrcArgIndex]));
639  LValue ThisRHSLV = CGF.MakeNaturalAlignAddrLValue(SrcPtr, RecordTy);
640  LValue Src = CGF.EmitLValueForFieldInitialization(ThisRHSLV, Field);
641 
642  // Copy the aggregate.
643  CGF.EmitAggregateCopy(LHS.getAddress(), Src.getAddress(), FieldType,
644  LHS.isVolatileQualified());
645  // Ensure that we destroy the objects if an exception is thrown later in
646  // the constructor.
647  QualType::DestructionKind dtorKind = FieldType.isDestructedType();
648  if (CGF.needsEHCleanup(dtorKind))
649  CGF.pushEHDestroy(dtorKind, LHS.getAddress(), FieldType);
650  return;
651  }
652  }
653 
654  CGF.EmitInitializerForField(Field, LHS, MemberInit->getInit());
655 }
656 
658  Expr *Init) {
659  QualType FieldType = Field->getType();
660  switch (getEvaluationKind(FieldType)) {
661  case TEK_Scalar:
662  if (LHS.isSimple()) {
663  EmitExprAsInit(Init, Field, LHS, false);
664  } else {
665  RValue RHS = RValue::get(EmitScalarExpr(Init));
666  EmitStoreThroughLValue(RHS, LHS);
667  }
668  break;
669  case TEK_Complex:
670  EmitComplexExprIntoLValue(Init, LHS, /*isInit*/ true);
671  break;
672  case TEK_Aggregate: {
673  AggValueSlot Slot =
678  EmitAggExpr(Init, Slot);
679  break;
680  }
681  }
682 
683  // Ensure that we destroy this object if an exception is thrown
684  // later in the constructor.
685  QualType::DestructionKind dtorKind = FieldType.isDestructedType();
686  if (needsEHCleanup(dtorKind))
687  pushEHDestroy(dtorKind, LHS.getAddress(), FieldType);
688 }
689 
690 /// Checks whether the given constructor is a valid subject for the
691 /// complete-to-base constructor delegation optimization, i.e.
692 /// emitting the complete constructor as a simple call to the base
693 /// constructor.
695  const CXXConstructorDecl *Ctor) {
696 
697  // Currently we disable the optimization for classes with virtual
698  // bases because (1) the addresses of parameter variables need to be
699  // consistent across all initializers but (2) the delegate function
700  // call necessarily creates a second copy of the parameter variable.
701  //
702  // The limiting example (purely theoretical AFAIK):
703  // struct A { A(int &c) { c++; } };
704  // struct B : virtual A {
705  // B(int count) : A(count) { printf("%d\n", count); }
706  // };
707  // ...although even this example could in principle be emitted as a
708  // delegation since the address of the parameter doesn't escape.
709  if (Ctor->getParent()->getNumVBases()) {
710  // TODO: white-list trivial vbase initializers. This case wouldn't
711  // be subject to the restrictions below.
712 
713  // TODO: white-list cases where:
714  // - there are no non-reference parameters to the constructor
715  // - the initializers don't access any non-reference parameters
716  // - the initializers don't take the address of non-reference
717  // parameters
718  // - etc.
719  // If we ever add any of the above cases, remember that:
720  // - function-try-blocks will always blacklist this optimization
721  // - we need to perform the constructor prologue and cleanup in
722  // EmitConstructorBody.
723 
724  return false;
725  }
726 
727  // We also disable the optimization for variadic functions because
728  // it's impossible to "re-pass" varargs.
729  if (Ctor->getType()->getAs<FunctionProtoType>()->isVariadic())
730  return false;
731 
732  // FIXME: Decide if we can do a delegation of a delegating constructor.
733  if (Ctor->isDelegatingConstructor())
734  return false;
735 
736  return true;
737 }
738 
739 // Emit code in ctor (Prologue==true) or dtor (Prologue==false)
740 // to poison the extra field paddings inserted under
741 // -fsanitize-address-field-padding=1|2.
743  ASTContext &Context = getContext();
744  const CXXRecordDecl *ClassDecl =
745  Prologue ? cast<CXXConstructorDecl>(CurGD.getDecl())->getParent()
746  : cast<CXXDestructorDecl>(CurGD.getDecl())->getParent();
747  if (!ClassDecl->mayInsertExtraPadding()) return;
748 
749  struct SizeAndOffset {
750  uint64_t Size;
751  uint64_t Offset;
752  };
753 
754  unsigned PtrSize = CGM.getDataLayout().getPointerSizeInBits();
755  const ASTRecordLayout &Info = Context.getASTRecordLayout(ClassDecl);
756 
757  // Populate sizes and offsets of fields.
759  for (unsigned i = 0, e = Info.getFieldCount(); i != e; ++i)
760  SSV[i].Offset =
761  Context.toCharUnitsFromBits(Info.getFieldOffset(i)).getQuantity();
762 
763  size_t NumFields = 0;
764  for (const auto *Field : ClassDecl->fields()) {
765  const FieldDecl *D = Field;
766  std::pair<CharUnits, CharUnits> FieldInfo =
767  Context.getTypeInfoInChars(D->getType());
768  CharUnits FieldSize = FieldInfo.first;
769  assert(NumFields < SSV.size());
770  SSV[NumFields].Size = D->isBitField() ? 0 : FieldSize.getQuantity();
771  NumFields++;
772  }
773  assert(NumFields == SSV.size());
774  if (SSV.size() <= 1) return;
775 
776  // We will insert calls to __asan_* run-time functions.
777  // LLVM AddressSanitizer pass may decide to inline them later.
778  llvm::Type *Args[2] = {IntPtrTy, IntPtrTy};
779  llvm::FunctionType *FTy =
780  llvm::FunctionType::get(CGM.VoidTy, Args, false);
781  llvm::Constant *F = CGM.CreateRuntimeFunction(
782  FTy, Prologue ? "__asan_poison_intra_object_redzone"
783  : "__asan_unpoison_intra_object_redzone");
784 
785  llvm::Value *ThisPtr = LoadCXXThis();
786  ThisPtr = Builder.CreatePtrToInt(ThisPtr, IntPtrTy);
787  uint64_t TypeSize = Info.getNonVirtualSize().getQuantity();
788  // For each field check if it has sufficient padding,
789  // if so (un)poison it with a call.
790  for (size_t i = 0; i < SSV.size(); i++) {
791  uint64_t AsanAlignment = 8;
792  uint64_t NextField = i == SSV.size() - 1 ? TypeSize : SSV[i + 1].Offset;
793  uint64_t PoisonSize = NextField - SSV[i].Offset - SSV[i].Size;
794  uint64_t EndOffset = SSV[i].Offset + SSV[i].Size;
795  if (PoisonSize < AsanAlignment || !SSV[i].Size ||
796  (NextField % AsanAlignment) != 0)
797  continue;
798  Builder.CreateCall(
799  F, {Builder.CreateAdd(ThisPtr, Builder.getIntN(PtrSize, EndOffset)),
800  Builder.getIntN(PtrSize, PoisonSize)});
801  }
802 }
803 
804 /// EmitConstructorBody - Emits the body of the current constructor.
806  EmitAsanPrologueOrEpilogue(true);
807  const CXXConstructorDecl *Ctor = cast<CXXConstructorDecl>(CurGD.getDecl());
808  CXXCtorType CtorType = CurGD.getCtorType();
809 
810  assert((CGM.getTarget().getCXXABI().hasConstructorVariants() ||
811  CtorType == Ctor_Complete) &&
812  "can only generate complete ctor for this ABI");
813 
814  // Before we go any further, try the complete->base constructor
815  // delegation optimization.
816  if (CtorType == Ctor_Complete && IsConstructorDelegationValid(Ctor) &&
817  CGM.getTarget().getCXXABI().hasConstructorVariants()) {
818  EmitDelegateCXXConstructorCall(Ctor, Ctor_Base, Args, Ctor->getLocEnd());
819  return;
820  }
821 
822  const FunctionDecl *Definition = nullptr;
823  Stmt *Body = Ctor->getBody(Definition);
824  assert(Definition == Ctor && "emitting wrong constructor body");
825 
826  // Enter the function-try-block before the constructor prologue if
827  // applicable.
828  bool IsTryBody = (Body && isa<CXXTryStmt>(Body));
829  if (IsTryBody)
830  EnterCXXTryStmt(*cast<CXXTryStmt>(Body), true);
831 
832  incrementProfileCounter(Body);
833 
834  RunCleanupsScope RunCleanups(*this);
835 
836  // TODO: in restricted cases, we can emit the vbase initializers of
837  // a complete ctor and then delegate to the base ctor.
838 
839  // Emit the constructor prologue, i.e. the base and member
840  // initializers.
841  EmitCtorPrologue(Ctor, CtorType, Args);
842 
843  // Emit the body of the statement.
844  if (IsTryBody)
845  EmitStmt(cast<CXXTryStmt>(Body)->getTryBlock());
846  else if (Body)
847  EmitStmt(Body);
848 
849  // Emit any cleanup blocks associated with the member or base
850  // initializers, which includes (along the exceptional path) the
851  // destructors for those members and bases that were fully
852  // constructed.
853  RunCleanups.ForceCleanup();
854 
855  if (IsTryBody)
856  ExitCXXTryStmt(*cast<CXXTryStmt>(Body), true);
857 }
858 
859 namespace {
860  /// RAII object to indicate that codegen is copying the value representation
861  /// instead of the object representation. Useful when copying a struct or
862  /// class which has uninitialized members and we're only performing
863  /// lvalue-to-rvalue conversion on the object but not its members.
864  class CopyingValueRepresentation {
865  public:
866  explicit CopyingValueRepresentation(CodeGenFunction &CGF)
867  : CGF(CGF), OldSanOpts(CGF.SanOpts) {
868  CGF.SanOpts.set(SanitizerKind::Bool, false);
869  CGF.SanOpts.set(SanitizerKind::Enum, false);
870  }
871  ~CopyingValueRepresentation() {
872  CGF.SanOpts = OldSanOpts;
873  }
874  private:
875  CodeGenFunction &CGF;
876  SanitizerSet OldSanOpts;
877  };
878 } // end anonymous namespace
879 
880 namespace {
881  class FieldMemcpyizer {
882  public:
883  FieldMemcpyizer(CodeGenFunction &CGF, const CXXRecordDecl *ClassDecl,
884  const VarDecl *SrcRec)
885  : CGF(CGF), ClassDecl(ClassDecl), SrcRec(SrcRec),
886  RecLayout(CGF.getContext().getASTRecordLayout(ClassDecl)),
887  FirstField(nullptr), LastField(nullptr), FirstFieldOffset(0),
888  LastFieldOffset(0), LastAddedFieldIndex(0) {}
889 
890  bool isMemcpyableField(FieldDecl *F) const {
891  // Never memcpy fields when we are adding poisoned paddings.
892  if (CGF.getContext().getLangOpts().SanitizeAddressFieldPadding)
893  return false;
894  Qualifiers Qual = F->getType().getQualifiers();
895  if (Qual.hasVolatile() || Qual.hasObjCLifetime())
896  return false;
897  return true;
898  }
899 
900  void addMemcpyableField(FieldDecl *F) {
901  if (!FirstField)
902  addInitialField(F);
903  else
904  addNextField(F);
905  }
906 
907  CharUnits getMemcpySize(uint64_t FirstByteOffset) const {
908  unsigned LastFieldSize =
909  LastField->isBitField() ?
910  LastField->getBitWidthValue(CGF.getContext()) :
911  CGF.getContext().getTypeSize(LastField->getType());
912  uint64_t MemcpySizeBits =
913  LastFieldOffset + LastFieldSize - FirstByteOffset +
914  CGF.getContext().getCharWidth() - 1;
915  CharUnits MemcpySize =
916  CGF.getContext().toCharUnitsFromBits(MemcpySizeBits);
917  return MemcpySize;
918  }
919 
920  void emitMemcpy() {
921  // Give the subclass a chance to bail out if it feels the memcpy isn't
922  // worth it (e.g. Hasn't aggregated enough data).
923  if (!FirstField) {
924  return;
925  }
926 
927  uint64_t FirstByteOffset;
928  if (FirstField->isBitField()) {
929  const CGRecordLayout &RL =
930  CGF.getTypes().getCGRecordLayout(FirstField->getParent());
931  const CGBitFieldInfo &BFInfo = RL.getBitFieldInfo(FirstField);
932  // FirstFieldOffset is not appropriate for bitfields,
933  // we need to use the storage offset instead.
934  FirstByteOffset = CGF.getContext().toBits(BFInfo.StorageOffset);
935  } else {
936  FirstByteOffset = FirstFieldOffset;
937  }
938 
939  CharUnits MemcpySize = getMemcpySize(FirstByteOffset);
940  QualType RecordTy = CGF.getContext().getTypeDeclType(ClassDecl);
941  Address ThisPtr = CGF.LoadCXXThisAddress();
942  LValue DestLV = CGF.MakeAddrLValue(ThisPtr, RecordTy);
943  LValue Dest = CGF.EmitLValueForFieldInitialization(DestLV, FirstField);
944  llvm::Value *SrcPtr = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(SrcRec));
945  LValue SrcLV = CGF.MakeNaturalAlignAddrLValue(SrcPtr, RecordTy);
946  LValue Src = CGF.EmitLValueForFieldInitialization(SrcLV, FirstField);
947 
948  emitMemcpyIR(Dest.isBitField() ? Dest.getBitFieldAddress() : Dest.getAddress(),
949  Src.isBitField() ? Src.getBitFieldAddress() : Src.getAddress(),
950  MemcpySize);
951  reset();
952  }
953 
954  void reset() {
955  FirstField = nullptr;
956  }
957 
958  protected:
959  CodeGenFunction &CGF;
960  const CXXRecordDecl *ClassDecl;
961 
962  private:
963  void emitMemcpyIR(Address DestPtr, Address SrcPtr, CharUnits Size) {
964  llvm::PointerType *DPT = DestPtr.getType();
965  llvm::Type *DBP =
966  llvm::Type::getInt8PtrTy(CGF.getLLVMContext(), DPT->getAddressSpace());
967  DestPtr = CGF.Builder.CreateBitCast(DestPtr, DBP);
968 
969  llvm::PointerType *SPT = SrcPtr.getType();
970  llvm::Type *SBP =
971  llvm::Type::getInt8PtrTy(CGF.getLLVMContext(), SPT->getAddressSpace());
972  SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, SBP);
973 
974  CGF.Builder.CreateMemCpy(DestPtr, SrcPtr, Size.getQuantity());
975  }
976 
977  void addInitialField(FieldDecl *F) {
978  FirstField = F;
979  LastField = F;
980  FirstFieldOffset = RecLayout.getFieldOffset(F->getFieldIndex());
981  LastFieldOffset = FirstFieldOffset;
982  LastAddedFieldIndex = F->getFieldIndex();
983  }
984 
985  void addNextField(FieldDecl *F) {
986  // For the most part, the following invariant will hold:
987  // F->getFieldIndex() == LastAddedFieldIndex + 1
988  // The one exception is that Sema won't add a copy-initializer for an
989  // unnamed bitfield, which will show up here as a gap in the sequence.
990  assert(F->getFieldIndex() >= LastAddedFieldIndex + 1 &&
991  "Cannot aggregate fields out of order.");
992  LastAddedFieldIndex = F->getFieldIndex();
993 
994  // The 'first' and 'last' fields are chosen by offset, rather than field
995  // index. This allows the code to support bitfields, as well as regular
996  // fields.
997  uint64_t FOffset = RecLayout.getFieldOffset(F->getFieldIndex());
998  if (FOffset < FirstFieldOffset) {
999  FirstField = F;
1000  FirstFieldOffset = FOffset;
1001  } else if (FOffset > LastFieldOffset) {
1002  LastField = F;
1003  LastFieldOffset = FOffset;
1004  }
1005  }
1006 
1007  const VarDecl *SrcRec;
1008  const ASTRecordLayout &RecLayout;
1009  FieldDecl *FirstField;
1010  FieldDecl *LastField;
1011  uint64_t FirstFieldOffset, LastFieldOffset;
1012  unsigned LastAddedFieldIndex;
1013  };
1014 
1015  class ConstructorMemcpyizer : public FieldMemcpyizer {
1016  private:
1017  /// Get source argument for copy constructor. Returns null if not a copy
1018  /// constructor.
1019  static const VarDecl *getTrivialCopySource(CodeGenFunction &CGF,
1020  const CXXConstructorDecl *CD,
1021  FunctionArgList &Args) {
1022  if (CD->isCopyOrMoveConstructor() && CD->isDefaulted())
1023  return Args[CGF.CGM.getCXXABI().getSrcArgforCopyCtor(CD, Args)];
1024  return nullptr;
1025  }
1026 
1027  // Returns true if a CXXCtorInitializer represents a member initialization
1028  // that can be rolled into a memcpy.
1029  bool isMemberInitMemcpyable(CXXCtorInitializer *MemberInit) const {
1030  if (!MemcpyableCtor)
1031  return false;
1032  FieldDecl *Field = MemberInit->getMember();
1033  assert(Field && "No field for member init.");
1034  QualType FieldType = Field->getType();
1035  CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(MemberInit->getInit());
1036 
1037  // Bail out on non-memcpyable, not-trivially-copyable members.
1038  if (!(CE && isMemcpyEquivalentSpecialMember(CE->getConstructor())) &&
1039  !(FieldType.isTriviallyCopyableType(CGF.getContext()) ||
1040  FieldType->isReferenceType()))
1041  return false;
1042 
1043  // Bail out on volatile fields.
1044  if (!isMemcpyableField(Field))
1045  return false;
1046 
1047  // Otherwise we're good.
1048  return true;
1049  }
1050 
1051  public:
1052  ConstructorMemcpyizer(CodeGenFunction &CGF, const CXXConstructorDecl *CD,
1053  FunctionArgList &Args)
1054  : FieldMemcpyizer(CGF, CD->getParent(), getTrivialCopySource(CGF, CD, Args)),
1055  ConstructorDecl(CD),
1056  MemcpyableCtor(CD->isDefaulted() &&
1057  CD->isCopyOrMoveConstructor() &&
1058  CGF.getLangOpts().getGC() == LangOptions::NonGC),
1059  Args(Args) { }
1060 
1061  void addMemberInitializer(CXXCtorInitializer *MemberInit) {
1062  if (isMemberInitMemcpyable(MemberInit)) {
1063  AggregatedInits.push_back(MemberInit);
1064  addMemcpyableField(MemberInit->getMember());
1065  } else {
1066  emitAggregatedInits();
1067  EmitMemberInitializer(CGF, ConstructorDecl->getParent(), MemberInit,
1068  ConstructorDecl, Args);
1069  }
1070  }
1071 
1072  void emitAggregatedInits() {
1073  if (AggregatedInits.size() <= 1) {
1074  // This memcpy is too small to be worthwhile. Fall back on default
1075  // codegen.
1076  if (!AggregatedInits.empty()) {
1077  CopyingValueRepresentation CVR(CGF);
1078  EmitMemberInitializer(CGF, ConstructorDecl->getParent(),
1079  AggregatedInits[0], ConstructorDecl, Args);
1080  AggregatedInits.clear();
1081  }
1082  reset();
1083  return;
1084  }
1085 
1086  pushEHDestructors();
1087  emitMemcpy();
1088  AggregatedInits.clear();
1089  }
1090 
1091  void pushEHDestructors() {
1092  Address ThisPtr = CGF.LoadCXXThisAddress();
1093  QualType RecordTy = CGF.getContext().getTypeDeclType(ClassDecl);
1094  LValue LHS = CGF.MakeAddrLValue(ThisPtr, RecordTy);
1095 
1096  for (unsigned i = 0; i < AggregatedInits.size(); ++i) {
1097  CXXCtorInitializer *MemberInit = AggregatedInits[i];
1098  QualType FieldType = MemberInit->getAnyMember()->getType();
1099  QualType::DestructionKind dtorKind = FieldType.isDestructedType();
1100  if (!CGF.needsEHCleanup(dtorKind))
1101  continue;
1102  LValue FieldLHS = LHS;
1103  EmitLValueForAnyFieldInitialization(CGF, MemberInit, FieldLHS);
1104  CGF.pushEHDestroy(dtorKind, FieldLHS.getAddress(), FieldType);
1105  }
1106  }
1107 
1108  void finish() {
1109  emitAggregatedInits();
1110  }
1111 
1112  private:
1113  const CXXConstructorDecl *ConstructorDecl;
1114  bool MemcpyableCtor;
1115  FunctionArgList &Args;
1116  SmallVector<CXXCtorInitializer*, 16> AggregatedInits;
1117  };
1118 
1119  class AssignmentMemcpyizer : public FieldMemcpyizer {
1120  private:
1121  // Returns the memcpyable field copied by the given statement, if one
1122  // exists. Otherwise returns null.
1123  FieldDecl *getMemcpyableField(Stmt *S) {
1124  if (!AssignmentsMemcpyable)
1125  return nullptr;
1126  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(S)) {
1127  // Recognise trivial assignments.
1128  if (BO->getOpcode() != BO_Assign)
1129  return nullptr;
1130  MemberExpr *ME = dyn_cast<MemberExpr>(BO->getLHS());
1131  if (!ME)
1132  return nullptr;
1133  FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl());
1134  if (!Field || !isMemcpyableField(Field))
1135  return nullptr;
1136  Stmt *RHS = BO->getRHS();
1137  if (ImplicitCastExpr *EC = dyn_cast<ImplicitCastExpr>(RHS))
1138  RHS = EC->getSubExpr();
1139  if (!RHS)
1140  return nullptr;
1141  if (MemberExpr *ME2 = dyn_cast<MemberExpr>(RHS)) {
1142  if (ME2->getMemberDecl() == Field)
1143  return Field;
1144  }
1145  return nullptr;
1146  } else if (CXXMemberCallExpr *MCE = dyn_cast<CXXMemberCallExpr>(S)) {
1147  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MCE->getCalleeDecl());
1148  if (!(MD && isMemcpyEquivalentSpecialMember(MD)))
1149  return nullptr;
1150  MemberExpr *IOA = dyn_cast<MemberExpr>(MCE->getImplicitObjectArgument());
1151  if (!IOA)
1152  return nullptr;
1153  FieldDecl *Field = dyn_cast<FieldDecl>(IOA->getMemberDecl());
1154  if (!Field || !isMemcpyableField(Field))
1155  return nullptr;
1156  MemberExpr *Arg0 = dyn_cast<MemberExpr>(MCE->getArg(0));
1157  if (!Arg0 || Field != dyn_cast<FieldDecl>(Arg0->getMemberDecl()))
1158  return nullptr;
1159  return Field;
1160  } else if (CallExpr *CE = dyn_cast<CallExpr>(S)) {
1161  FunctionDecl *FD = dyn_cast<FunctionDecl>(CE->getCalleeDecl());
1162  if (!FD || FD->getBuiltinID() != Builtin::BI__builtin_memcpy)
1163  return nullptr;
1164  Expr *DstPtr = CE->getArg(0);
1165  if (ImplicitCastExpr *DC = dyn_cast<ImplicitCastExpr>(DstPtr))
1166  DstPtr = DC->getSubExpr();
1167  UnaryOperator *DUO = dyn_cast<UnaryOperator>(DstPtr);
1168  if (!DUO || DUO->getOpcode() != UO_AddrOf)
1169  return nullptr;
1170  MemberExpr *ME = dyn_cast<MemberExpr>(DUO->getSubExpr());
1171  if (!ME)
1172  return nullptr;
1173  FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl());
1174  if (!Field || !isMemcpyableField(Field))
1175  return nullptr;
1176  Expr *SrcPtr = CE->getArg(1);
1177  if (ImplicitCastExpr *SC = dyn_cast<ImplicitCastExpr>(SrcPtr))
1178  SrcPtr = SC->getSubExpr();
1179  UnaryOperator *SUO = dyn_cast<UnaryOperator>(SrcPtr);
1180  if (!SUO || SUO->getOpcode() != UO_AddrOf)
1181  return nullptr;
1182  MemberExpr *ME2 = dyn_cast<MemberExpr>(SUO->getSubExpr());
1183  if (!ME2 || Field != dyn_cast<FieldDecl>(ME2->getMemberDecl()))
1184  return nullptr;
1185  return Field;
1186  }
1187 
1188  return nullptr;
1189  }
1190 
1191  bool AssignmentsMemcpyable;
1192  SmallVector<Stmt*, 16> AggregatedStmts;
1193 
1194  public:
1195  AssignmentMemcpyizer(CodeGenFunction &CGF, const CXXMethodDecl *AD,
1196  FunctionArgList &Args)
1197  : FieldMemcpyizer(CGF, AD->getParent(), Args[Args.size() - 1]),
1198  AssignmentsMemcpyable(CGF.getLangOpts().getGC() == LangOptions::NonGC) {
1199  assert(Args.size() == 2);
1200  }
1201 
1202  void emitAssignment(Stmt *S) {
1203  FieldDecl *F = getMemcpyableField(S);
1204  if (F) {
1205  addMemcpyableField(F);
1206  AggregatedStmts.push_back(S);
1207  } else {
1208  emitAggregatedStmts();
1209  CGF.EmitStmt(S);
1210  }
1211  }
1212 
1213  void emitAggregatedStmts() {
1214  if (AggregatedStmts.size() <= 1) {
1215  if (!AggregatedStmts.empty()) {
1216  CopyingValueRepresentation CVR(CGF);
1217  CGF.EmitStmt(AggregatedStmts[0]);
1218  }
1219  reset();
1220  }
1221 
1222  emitMemcpy();
1223  AggregatedStmts.clear();
1224  }
1225 
1226  void finish() {
1227  emitAggregatedStmts();
1228  }
1229  };
1230 } // end anonymous namespace
1231 
1232 static bool isInitializerOfDynamicClass(const CXXCtorInitializer *BaseInit) {
1233  const Type *BaseType = BaseInit->getBaseClass();
1234  const auto *BaseClassDecl =
1235  cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl());
1236  return BaseClassDecl->isDynamicClass();
1237 }
1238 
1239 /// EmitCtorPrologue - This routine generates necessary code to initialize
1240 /// base classes and non-static data members belonging to this constructor.
1242  CXXCtorType CtorType,
1243  FunctionArgList &Args) {
1244  if (CD->isDelegatingConstructor())
1245  return EmitDelegatingCXXConstructorCall(CD, Args);
1246 
1247  const CXXRecordDecl *ClassDecl = CD->getParent();
1248 
1250  E = CD->init_end();
1251 
1252  llvm::BasicBlock *BaseCtorContinueBB = nullptr;
1253  if (ClassDecl->getNumVBases() &&
1254  !CGM.getTarget().getCXXABI().hasConstructorVariants()) {
1255  // The ABIs that don't have constructor variants need to put a branch
1256  // before the virtual base initialization code.
1257  BaseCtorContinueBB =
1258  CGM.getCXXABI().EmitCtorCompleteObjectHandler(*this, ClassDecl);
1259  assert(BaseCtorContinueBB);
1260  }
1261 
1262  llvm::Value *const OldThis = CXXThisValue;
1263  // Virtual base initializers first.
1264  for (; B != E && (*B)->isBaseInitializer() && (*B)->isBaseVirtual(); B++) {
1265  if (CGM.getCodeGenOpts().StrictVTablePointers &&
1266  CGM.getCodeGenOpts().OptimizationLevel > 0 &&
1268  CXXThisValue = Builder.CreateInvariantGroupBarrier(LoadCXXThis());
1269  EmitBaseInitializer(*this, ClassDecl, *B, CtorType);
1270  }
1271 
1272  if (BaseCtorContinueBB) {
1273  // Complete object handler should continue to the remaining initializers.
1274  Builder.CreateBr(BaseCtorContinueBB);
1275  EmitBlock(BaseCtorContinueBB);
1276  }
1277 
1278  // Then, non-virtual base initializers.
1279  for (; B != E && (*B)->isBaseInitializer(); B++) {
1280  assert(!(*B)->isBaseVirtual());
1281 
1282  if (CGM.getCodeGenOpts().StrictVTablePointers &&
1283  CGM.getCodeGenOpts().OptimizationLevel > 0 &&
1285  CXXThisValue = Builder.CreateInvariantGroupBarrier(LoadCXXThis());
1286  EmitBaseInitializer(*this, ClassDecl, *B, CtorType);
1287  }
1288 
1289  CXXThisValue = OldThis;
1290 
1291  InitializeVTablePointers(ClassDecl);
1292 
1293  // And finally, initialize class members.
1294  FieldConstructionScope FCS(*this, LoadCXXThisAddress());
1295  ConstructorMemcpyizer CM(*this, CD, Args);
1296  for (; B != E; B++) {
1297  CXXCtorInitializer *Member = (*B);
1298  assert(!Member->isBaseInitializer());
1299  assert(Member->isAnyMemberInitializer() &&
1300  "Delegating initializer on non-delegating constructor");
1301  CM.addMemberInitializer(Member);
1302  }
1303  CM.finish();
1304 }
1305 
1306 static bool
1307 FieldHasTrivialDestructorBody(ASTContext &Context, const FieldDecl *Field);
1308 
1309 static bool
1311  const CXXRecordDecl *BaseClassDecl,
1312  const CXXRecordDecl *MostDerivedClassDecl)
1313 {
1314  // If the destructor is trivial we don't have to check anything else.
1315  if (BaseClassDecl->hasTrivialDestructor())
1316  return true;
1317 
1318  if (!BaseClassDecl->getDestructor()->hasTrivialBody())
1319  return false;
1320 
1321  // Check fields.
1322  for (const auto *Field : BaseClassDecl->fields())
1323  if (!FieldHasTrivialDestructorBody(Context, Field))
1324  return false;
1325 
1326  // Check non-virtual bases.
1327  for (const auto &I : BaseClassDecl->bases()) {
1328  if (I.isVirtual())
1329  continue;
1330 
1331  const CXXRecordDecl *NonVirtualBase =
1332  cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
1333  if (!HasTrivialDestructorBody(Context, NonVirtualBase,
1334  MostDerivedClassDecl))
1335  return false;
1336  }
1337 
1338  if (BaseClassDecl == MostDerivedClassDecl) {
1339  // Check virtual bases.
1340  for (const auto &I : BaseClassDecl->vbases()) {
1341  const CXXRecordDecl *VirtualBase =
1342  cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
1343  if (!HasTrivialDestructorBody(Context, VirtualBase,
1344  MostDerivedClassDecl))
1345  return false;
1346  }
1347  }
1348 
1349  return true;
1350 }
1351 
1352 static bool
1354  const FieldDecl *Field)
1355 {
1356  QualType FieldBaseElementType = Context.getBaseElementType(Field->getType());
1357 
1358  const RecordType *RT = FieldBaseElementType->getAs<RecordType>();
1359  if (!RT)
1360  return true;
1361 
1362  CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1363 
1364  // The destructor for an implicit anonymous union member is never invoked.
1365  if (FieldClassDecl->isUnion() && FieldClassDecl->isAnonymousStructOrUnion())
1366  return false;
1367 
1368  return HasTrivialDestructorBody(Context, FieldClassDecl, FieldClassDecl);
1369 }
1370 
1371 /// CanSkipVTablePointerInitialization - Check whether we need to initialize
1372 /// any vtable pointers before calling this destructor.
1374  const CXXDestructorDecl *Dtor) {
1375  const CXXRecordDecl *ClassDecl = Dtor->getParent();
1376  if (!ClassDecl->isDynamicClass())
1377  return true;
1378 
1379  if (!Dtor->hasTrivialBody())
1380  return false;
1381 
1382  // Check the fields.
1383  for (const auto *Field : ClassDecl->fields())
1384  if (!FieldHasTrivialDestructorBody(CGF.getContext(), Field))
1385  return false;
1386 
1387  return true;
1388 }
1389 
1390 /// EmitDestructorBody - Emits the body of the current destructor.
1392  const CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(CurGD.getDecl());
1393  CXXDtorType DtorType = CurGD.getDtorType();
1394 
1395  // For an abstract class, non-base destructors are never used (and can't
1396  // be emitted in general, because vbase dtors may not have been validated
1397  // by Sema), but the Itanium ABI doesn't make them optional and Clang may
1398  // in fact emit references to them from other compilations, so emit them
1399  // as functions containing a trap instruction.
1400  if (DtorType != Dtor_Base && Dtor->getParent()->isAbstract()) {
1401  llvm::CallInst *TrapCall = EmitTrapCall(llvm::Intrinsic::trap);
1402  TrapCall->setDoesNotReturn();
1403  TrapCall->setDoesNotThrow();
1404  Builder.CreateUnreachable();
1405  Builder.ClearInsertionPoint();
1406  return;
1407  }
1408 
1409  Stmt *Body = Dtor->getBody();
1410  if (Body)
1411  incrementProfileCounter(Body);
1412 
1413  // The call to operator delete in a deleting destructor happens
1414  // outside of the function-try-block, which means it's always
1415  // possible to delegate the destructor body to the complete
1416  // destructor. Do so.
1417  if (DtorType == Dtor_Deleting) {
1418  RunCleanupsScope DtorEpilogue(*this);
1419  EnterDtorCleanups(Dtor, Dtor_Deleting);
1420  if (HaveInsertPoint())
1421  EmitCXXDestructorCall(Dtor, Dtor_Complete, /*ForVirtualBase=*/false,
1422  /*Delegating=*/false, LoadCXXThisAddress());
1423  return;
1424  }
1425 
1426  // If the body is a function-try-block, enter the try before
1427  // anything else.
1428  bool isTryBody = (Body && isa<CXXTryStmt>(Body));
1429  if (isTryBody)
1430  EnterCXXTryStmt(*cast<CXXTryStmt>(Body), true);
1431  EmitAsanPrologueOrEpilogue(false);
1432 
1433  // Enter the epilogue cleanups.
1434  RunCleanupsScope DtorEpilogue(*this);
1435 
1436  // If this is the complete variant, just invoke the base variant;
1437  // the epilogue will destruct the virtual bases. But we can't do
1438  // this optimization if the body is a function-try-block, because
1439  // we'd introduce *two* handler blocks. In the Microsoft ABI, we
1440  // always delegate because we might not have a definition in this TU.
1441  switch (DtorType) {
1442  case Dtor_Comdat: llvm_unreachable("not expecting a COMDAT");
1443  case Dtor_Deleting: llvm_unreachable("already handled deleting case");
1444 
1445  case Dtor_Complete:
1446  assert((Body || getTarget().getCXXABI().isMicrosoft()) &&
1447  "can't emit a dtor without a body for non-Microsoft ABIs");
1448 
1449  // Enter the cleanup scopes for virtual bases.
1450  EnterDtorCleanups(Dtor, Dtor_Complete);
1451 
1452  if (!isTryBody) {
1453  EmitCXXDestructorCall(Dtor, Dtor_Base, /*ForVirtualBase=*/false,
1454  /*Delegating=*/false, LoadCXXThisAddress());
1455  break;
1456  }
1457 
1458  // Fallthrough: act like we're in the base variant.
1459  LLVM_FALLTHROUGH;
1460 
1461  case Dtor_Base:
1462  assert(Body);
1463 
1464  // Enter the cleanup scopes for fields and non-virtual bases.
1465  EnterDtorCleanups(Dtor, Dtor_Base);
1466 
1467  // Initialize the vtable pointers before entering the body.
1468  if (!CanSkipVTablePointerInitialization(*this, Dtor)) {
1469  // Insert the llvm.invariant.group.barrier intrinsic before initializing
1470  // the vptrs to cancel any previous assumptions we might have made.
1471  if (CGM.getCodeGenOpts().StrictVTablePointers &&
1472  CGM.getCodeGenOpts().OptimizationLevel > 0)
1473  CXXThisValue = Builder.CreateInvariantGroupBarrier(LoadCXXThis());
1474  InitializeVTablePointers(Dtor->getParent());
1475  }
1476 
1477  if (isTryBody)
1478  EmitStmt(cast<CXXTryStmt>(Body)->getTryBlock());
1479  else if (Body)
1480  EmitStmt(Body);
1481  else {
1482  assert(Dtor->isImplicit() && "bodyless dtor not implicit");
1483  // nothing to do besides what's in the epilogue
1484  }
1485  // -fapple-kext must inline any call to this dtor into
1486  // the caller's body.
1487  if (getLangOpts().AppleKext)
1488  CurFn->addFnAttr(llvm::Attribute::AlwaysInline);
1489 
1490  break;
1491  }
1492 
1493  // Jump out through the epilogue cleanups.
1494  DtorEpilogue.ForceCleanup();
1495 
1496  // Exit the try if applicable.
1497  if (isTryBody)
1498  ExitCXXTryStmt(*cast<CXXTryStmt>(Body), true);
1499 }
1500 
1502  const CXXMethodDecl *AssignOp = cast<CXXMethodDecl>(CurGD.getDecl());
1503  const Stmt *RootS = AssignOp->getBody();
1504  assert(isa<CompoundStmt>(RootS) &&
1505  "Body of an implicit assignment operator should be compound stmt.");
1506  const CompoundStmt *RootCS = cast<CompoundStmt>(RootS);
1507 
1508  LexicalScope Scope(*this, RootCS->getSourceRange());
1509 
1510  incrementProfileCounter(RootCS);
1511  AssignmentMemcpyizer AM(*this, AssignOp, Args);
1512  for (auto *I : RootCS->body())
1513  AM.emitAssignment(I);
1514  AM.finish();
1515 }
1516 
1517 namespace {
1518  llvm::Value *LoadThisForDtorDelete(CodeGenFunction &CGF,
1519  const CXXDestructorDecl *DD) {
1520  if (Expr *ThisArg = DD->getOperatorDeleteThisArg())
1521  return CGF.EmitScalarExpr(ThisArg);
1522  return CGF.LoadCXXThis();
1523  }
1524 
1525  /// Call the operator delete associated with the current destructor.
1526  struct CallDtorDelete final : EHScopeStack::Cleanup {
1527  CallDtorDelete() {}
1528 
1529  void Emit(CodeGenFunction &CGF, Flags flags) override {
1530  const CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(CGF.CurCodeDecl);
1531  const CXXRecordDecl *ClassDecl = Dtor->getParent();
1532  CGF.EmitDeleteCall(Dtor->getOperatorDelete(),
1533  LoadThisForDtorDelete(CGF, Dtor),
1534  CGF.getContext().getTagDeclType(ClassDecl));
1535  }
1536  };
1537 
1538  void EmitConditionalDtorDeleteCall(CodeGenFunction &CGF,
1539  llvm::Value *ShouldDeleteCondition,
1540  bool ReturnAfterDelete) {
1541  llvm::BasicBlock *callDeleteBB = CGF.createBasicBlock("dtor.call_delete");
1542  llvm::BasicBlock *continueBB = CGF.createBasicBlock("dtor.continue");
1543  llvm::Value *ShouldCallDelete
1544  = CGF.Builder.CreateIsNull(ShouldDeleteCondition);
1545  CGF.Builder.CreateCondBr(ShouldCallDelete, continueBB, callDeleteBB);
1546 
1547  CGF.EmitBlock(callDeleteBB);
1548  const CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(CGF.CurCodeDecl);
1549  const CXXRecordDecl *ClassDecl = Dtor->getParent();
1550  CGF.EmitDeleteCall(Dtor->getOperatorDelete(),
1551  LoadThisForDtorDelete(CGF, Dtor),
1552  CGF.getContext().getTagDeclType(ClassDecl));
1553  assert(Dtor->getOperatorDelete()->isDestroyingOperatorDelete() ==
1554  ReturnAfterDelete &&
1555  "unexpected value for ReturnAfterDelete");
1556  if (ReturnAfterDelete)
1558  else
1559  CGF.Builder.CreateBr(continueBB);
1560 
1561  CGF.EmitBlock(continueBB);
1562  }
1563 
1564  struct CallDtorDeleteConditional final : EHScopeStack::Cleanup {
1565  llvm::Value *ShouldDeleteCondition;
1566 
1567  public:
1568  CallDtorDeleteConditional(llvm::Value *ShouldDeleteCondition)
1569  : ShouldDeleteCondition(ShouldDeleteCondition) {
1570  assert(ShouldDeleteCondition != nullptr);
1571  }
1572 
1573  void Emit(CodeGenFunction &CGF, Flags flags) override {
1574  EmitConditionalDtorDeleteCall(CGF, ShouldDeleteCondition,
1575  /*ReturnAfterDelete*/false);
1576  }
1577  };
1578 
1579  class DestroyField final : public EHScopeStack::Cleanup {
1580  const FieldDecl *field;
1581  CodeGenFunction::Destroyer *destroyer;
1582  bool useEHCleanupForArray;
1583 
1584  public:
1585  DestroyField(const FieldDecl *field, CodeGenFunction::Destroyer *destroyer,
1586  bool useEHCleanupForArray)
1587  : field(field), destroyer(destroyer),
1588  useEHCleanupForArray(useEHCleanupForArray) {}
1589 
1590  void Emit(CodeGenFunction &CGF, Flags flags) override {
1591  // Find the address of the field.
1592  Address thisValue = CGF.LoadCXXThisAddress();
1593  QualType RecordTy = CGF.getContext().getTagDeclType(field->getParent());
1594  LValue ThisLV = CGF.MakeAddrLValue(thisValue, RecordTy);
1595  LValue LV = CGF.EmitLValueForField(ThisLV, field);
1596  assert(LV.isSimple());
1597 
1598  CGF.emitDestroy(LV.getAddress(), field->getType(), destroyer,
1599  flags.isForNormalCleanup() && useEHCleanupForArray);
1600  }
1601  };
1602 
1603  static void EmitSanitizerDtorCallback(CodeGenFunction &CGF, llvm::Value *Ptr,
1604  CharUnits::QuantityType PoisonSize) {
1605  CodeGenFunction::SanitizerScope SanScope(&CGF);
1606  // Pass in void pointer and size of region as arguments to runtime
1607  // function
1608  llvm::Value *Args[] = {CGF.Builder.CreateBitCast(Ptr, CGF.VoidPtrTy),
1609  llvm::ConstantInt::get(CGF.SizeTy, PoisonSize)};
1610 
1611  llvm::Type *ArgTypes[] = {CGF.VoidPtrTy, CGF.SizeTy};
1612 
1613  llvm::FunctionType *FnType =
1614  llvm::FunctionType::get(CGF.VoidTy, ArgTypes, false);
1615  llvm::Value *Fn =
1616  CGF.CGM.CreateRuntimeFunction(FnType, "__sanitizer_dtor_callback");
1617  CGF.EmitNounwindRuntimeCall(Fn, Args);
1618  }
1619 
1620  class SanitizeDtorMembers final : public EHScopeStack::Cleanup {
1621  const CXXDestructorDecl *Dtor;
1622 
1623  public:
1624  SanitizeDtorMembers(const CXXDestructorDecl *Dtor) : Dtor(Dtor) {}
1625 
1626  // Generate function call for handling object poisoning.
1627  // Disables tail call elimination, to prevent the current stack frame
1628  // from disappearing from the stack trace.
1629  void Emit(CodeGenFunction &CGF, Flags flags) override {
1630  const ASTRecordLayout &Layout =
1631  CGF.getContext().getASTRecordLayout(Dtor->getParent());
1632 
1633  // Nothing to poison.
1634  if (Layout.getFieldCount() == 0)
1635  return;
1636 
1637  // Prevent the current stack frame from disappearing from the stack trace.
1638  CGF.CurFn->addFnAttr("disable-tail-calls", "true");
1639 
1640  // Construct pointer to region to begin poisoning, and calculate poison
1641  // size, so that only members declared in this class are poisoned.
1642  ASTContext &Context = CGF.getContext();
1643  unsigned fieldIndex = 0;
1644  int startIndex = -1;
1645  // RecordDecl::field_iterator Field;
1646  for (const FieldDecl *Field : Dtor->getParent()->fields()) {
1647  // Poison field if it is trivial
1648  if (FieldHasTrivialDestructorBody(Context, Field)) {
1649  // Start sanitizing at this field
1650  if (startIndex < 0)
1651  startIndex = fieldIndex;
1652 
1653  // Currently on the last field, and it must be poisoned with the
1654  // current block.
1655  if (fieldIndex == Layout.getFieldCount() - 1) {
1656  PoisonMembers(CGF, startIndex, Layout.getFieldCount());
1657  }
1658  } else if (startIndex >= 0) {
1659  // No longer within a block of memory to poison, so poison the block
1660  PoisonMembers(CGF, startIndex, fieldIndex);
1661  // Re-set the start index
1662  startIndex = -1;
1663  }
1664  fieldIndex += 1;
1665  }
1666  }
1667 
1668  private:
1669  /// \param layoutStartOffset index of the ASTRecordLayout field to
1670  /// start poisoning (inclusive)
1671  /// \param layoutEndOffset index of the ASTRecordLayout field to
1672  /// end poisoning (exclusive)
1673  void PoisonMembers(CodeGenFunction &CGF, unsigned layoutStartOffset,
1674  unsigned layoutEndOffset) {
1675  ASTContext &Context = CGF.getContext();
1676  const ASTRecordLayout &Layout =
1677  Context.getASTRecordLayout(Dtor->getParent());
1678 
1679  llvm::ConstantInt *OffsetSizePtr = llvm::ConstantInt::get(
1680  CGF.SizeTy,
1681  Context.toCharUnitsFromBits(Layout.getFieldOffset(layoutStartOffset))
1682  .getQuantity());
1683 
1684  llvm::Value *OffsetPtr = CGF.Builder.CreateGEP(
1685  CGF.Builder.CreateBitCast(CGF.LoadCXXThis(), CGF.Int8PtrTy),
1686  OffsetSizePtr);
1687 
1688  CharUnits::QuantityType PoisonSize;
1689  if (layoutEndOffset >= Layout.getFieldCount()) {
1690  PoisonSize = Layout.getNonVirtualSize().getQuantity() -
1691  Context.toCharUnitsFromBits(
1692  Layout.getFieldOffset(layoutStartOffset))
1693  .getQuantity();
1694  } else {
1695  PoisonSize = Context.toCharUnitsFromBits(
1696  Layout.getFieldOffset(layoutEndOffset) -
1697  Layout.getFieldOffset(layoutStartOffset))
1698  .getQuantity();
1699  }
1700 
1701  if (PoisonSize == 0)
1702  return;
1703 
1704  EmitSanitizerDtorCallback(CGF, OffsetPtr, PoisonSize);
1705  }
1706  };
1707 
1708  class SanitizeDtorVTable final : public EHScopeStack::Cleanup {
1709  const CXXDestructorDecl *Dtor;
1710 
1711  public:
1712  SanitizeDtorVTable(const CXXDestructorDecl *Dtor) : Dtor(Dtor) {}
1713 
1714  // Generate function call for handling vtable pointer poisoning.
1715  void Emit(CodeGenFunction &CGF, Flags flags) override {
1716  assert(Dtor->getParent()->isDynamicClass());
1717  (void)Dtor;
1718  ASTContext &Context = CGF.getContext();
1719  // Poison vtable and vtable ptr if they exist for this class.
1720  llvm::Value *VTablePtr = CGF.LoadCXXThis();
1721 
1722  CharUnits::QuantityType PoisonSize =
1723  Context.toCharUnitsFromBits(CGF.PointerWidthInBits).getQuantity();
1724  // Pass in void pointer and size of region as arguments to runtime
1725  // function
1726  EmitSanitizerDtorCallback(CGF, VTablePtr, PoisonSize);
1727  }
1728  };
1729 } // end anonymous namespace
1730 
1731 /// \brief Emit all code that comes at the end of class's
1732 /// destructor. This is to call destructors on members and base classes
1733 /// in reverse order of their construction.
1734 ///
1735 /// For a deleting destructor, this also handles the case where a destroying
1736 /// operator delete completely overrides the definition.
1738  CXXDtorType DtorType) {
1739  assert((!DD->isTrivial() || DD->hasAttr<DLLExportAttr>()) &&
1740  "Should not emit dtor epilogue for non-exported trivial dtor!");
1741 
1742  // The deleting-destructor phase just needs to call the appropriate
1743  // operator delete that Sema picked up.
1744  if (DtorType == Dtor_Deleting) {
1745  assert(DD->getOperatorDelete() &&
1746  "operator delete missing - EnterDtorCleanups");
1747  if (CXXStructorImplicitParamValue) {
1748  // If there is an implicit param to the deleting dtor, it's a boolean
1749  // telling whether this is a deleting destructor.
1751  EmitConditionalDtorDeleteCall(*this, CXXStructorImplicitParamValue,
1752  /*ReturnAfterDelete*/true);
1753  else
1754  EHStack.pushCleanup<CallDtorDeleteConditional>(
1755  NormalAndEHCleanup, CXXStructorImplicitParamValue);
1756  } else {
1758  const CXXRecordDecl *ClassDecl = DD->getParent();
1759  EmitDeleteCall(DD->getOperatorDelete(),
1760  LoadThisForDtorDelete(*this, DD),
1761  getContext().getTagDeclType(ClassDecl));
1762  EmitBranchThroughCleanup(ReturnBlock);
1763  } else {
1764  EHStack.pushCleanup<CallDtorDelete>(NormalAndEHCleanup);
1765  }
1766  }
1767  return;
1768  }
1769 
1770  const CXXRecordDecl *ClassDecl = DD->getParent();
1771 
1772  // Unions have no bases and do not call field destructors.
1773  if (ClassDecl->isUnion())
1774  return;
1775 
1776  // The complete-destructor phase just destructs all the virtual bases.
1777  if (DtorType == Dtor_Complete) {
1778  // Poison the vtable pointer such that access after the base
1779  // and member destructors are invoked is invalid.
1780  if (CGM.getCodeGenOpts().SanitizeMemoryUseAfterDtor &&
1781  SanOpts.has(SanitizerKind::Memory) && ClassDecl->getNumVBases() &&
1782  ClassDecl->isPolymorphic())
1783  EHStack.pushCleanup<SanitizeDtorVTable>(NormalAndEHCleanup, DD);
1784 
1785  // We push them in the forward order so that they'll be popped in
1786  // the reverse order.
1787  for (const auto &Base : ClassDecl->vbases()) {
1788  CXXRecordDecl *BaseClassDecl
1789  = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
1790 
1791  // Ignore trivial destructors.
1792  if (BaseClassDecl->hasTrivialDestructor())
1793  continue;
1794 
1795  EHStack.pushCleanup<CallBaseDtor>(NormalAndEHCleanup,
1796  BaseClassDecl,
1797  /*BaseIsVirtual*/ true);
1798  }
1799 
1800  return;
1801  }
1802 
1803  assert(DtorType == Dtor_Base);
1804  // Poison the vtable pointer if it has no virtual bases, but inherits
1805  // virtual functions.
1806  if (CGM.getCodeGenOpts().SanitizeMemoryUseAfterDtor &&
1807  SanOpts.has(SanitizerKind::Memory) && !ClassDecl->getNumVBases() &&
1808  ClassDecl->isPolymorphic())
1809  EHStack.pushCleanup<SanitizeDtorVTable>(NormalAndEHCleanup, DD);
1810 
1811  // Destroy non-virtual bases.
1812  for (const auto &Base : ClassDecl->bases()) {
1813  // Ignore virtual bases.
1814  if (Base.isVirtual())
1815  continue;
1816 
1817  CXXRecordDecl *BaseClassDecl = Base.getType()->getAsCXXRecordDecl();
1818 
1819  // Ignore trivial destructors.
1820  if (BaseClassDecl->hasTrivialDestructor())
1821  continue;
1822 
1823  EHStack.pushCleanup<CallBaseDtor>(NormalAndEHCleanup,
1824  BaseClassDecl,
1825  /*BaseIsVirtual*/ false);
1826  }
1827 
1828  // Poison fields such that access after their destructors are
1829  // invoked, and before the base class destructor runs, is invalid.
1830  if (CGM.getCodeGenOpts().SanitizeMemoryUseAfterDtor &&
1831  SanOpts.has(SanitizerKind::Memory))
1832  EHStack.pushCleanup<SanitizeDtorMembers>(NormalAndEHCleanup, DD);
1833 
1834  // Destroy direct fields.
1835  for (const auto *Field : ClassDecl->fields()) {
1836  QualType type = Field->getType();
1837  QualType::DestructionKind dtorKind = type.isDestructedType();
1838  if (!dtorKind) continue;
1839 
1840  // Anonymous union members do not have their destructors called.
1841  const RecordType *RT = type->getAsUnionType();
1842  if (RT && RT->getDecl()->isAnonymousStructOrUnion()) continue;
1843 
1844  CleanupKind cleanupKind = getCleanupKind(dtorKind);
1845  EHStack.pushCleanup<DestroyField>(cleanupKind, Field,
1846  getDestroyer(dtorKind),
1847  cleanupKind & EHCleanup);
1848  }
1849 }
1850 
1851 /// EmitCXXAggrConstructorCall - Emit a loop to call a particular
1852 /// constructor for each of several members of an array.
1853 ///
1854 /// \param ctor the constructor to call for each element
1855 /// \param arrayType the type of the array to initialize
1856 /// \param arrayBegin an arrayType*
1857 /// \param zeroInitialize true if each element should be
1858 /// zero-initialized before it is constructed
1860  const CXXConstructorDecl *ctor, const ArrayType *arrayType,
1861  Address arrayBegin, const CXXConstructExpr *E, bool zeroInitialize) {
1862  QualType elementType;
1863  llvm::Value *numElements =
1864  emitArrayLength(arrayType, elementType, arrayBegin);
1865 
1866  EmitCXXAggrConstructorCall(ctor, numElements, arrayBegin, E, zeroInitialize);
1867 }
1868 
1869 /// EmitCXXAggrConstructorCall - Emit a loop to call a particular
1870 /// constructor for each of several members of an array.
1871 ///
1872 /// \param ctor the constructor to call for each element
1873 /// \param numElements the number of elements in the array;
1874 /// may be zero
1875 /// \param arrayBase a T*, where T is the type constructed by ctor
1876 /// \param zeroInitialize true if each element should be
1877 /// zero-initialized before it is constructed
1879  llvm::Value *numElements,
1880  Address arrayBase,
1881  const CXXConstructExpr *E,
1882  bool zeroInitialize) {
1883  // It's legal for numElements to be zero. This can happen both
1884  // dynamically, because x can be zero in 'new A[x]', and statically,
1885  // because of GCC extensions that permit zero-length arrays. There
1886  // are probably legitimate places where we could assume that this
1887  // doesn't happen, but it's not clear that it's worth it.
1888  llvm::BranchInst *zeroCheckBranch = nullptr;
1889 
1890  // Optimize for a constant count.
1891  llvm::ConstantInt *constantCount
1892  = dyn_cast<llvm::ConstantInt>(numElements);
1893  if (constantCount) {
1894  // Just skip out if the constant count is zero.
1895  if (constantCount->isZero()) return;
1896 
1897  // Otherwise, emit the check.
1898  } else {
1899  llvm::BasicBlock *loopBB = createBasicBlock("new.ctorloop");
1900  llvm::Value *iszero = Builder.CreateIsNull(numElements, "isempty");
1901  zeroCheckBranch = Builder.CreateCondBr(iszero, loopBB, loopBB);
1902  EmitBlock(loopBB);
1903  }
1904 
1905  // Find the end of the array.
1906  llvm::Value *arrayBegin = arrayBase.getPointer();
1907  llvm::Value *arrayEnd = Builder.CreateInBoundsGEP(arrayBegin, numElements,
1908  "arrayctor.end");
1909 
1910  // Enter the loop, setting up a phi for the current location to initialize.
1911  llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
1912  llvm::BasicBlock *loopBB = createBasicBlock("arrayctor.loop");
1913  EmitBlock(loopBB);
1914  llvm::PHINode *cur = Builder.CreatePHI(arrayBegin->getType(), 2,
1915  "arrayctor.cur");
1916  cur->addIncoming(arrayBegin, entryBB);
1917 
1918  // Inside the loop body, emit the constructor call on the array element.
1919 
1920  // The alignment of the base, adjusted by the size of a single element,
1921  // provides a conservative estimate of the alignment of every element.
1922  // (This assumes we never start tracking offsetted alignments.)
1923  //
1924  // Note that these are complete objects and so we don't need to
1925  // use the non-virtual size or alignment.
1927  CharUnits eltAlignment =
1928  arrayBase.getAlignment()
1929  .alignmentOfArrayElement(getContext().getTypeSizeInChars(type));
1930  Address curAddr = Address(cur, eltAlignment);
1931 
1932  // Zero initialize the storage, if requested.
1933  if (zeroInitialize)
1934  EmitNullInitialization(curAddr, type);
1935 
1936  // C++ [class.temporary]p4:
1937  // There are two contexts in which temporaries are destroyed at a different
1938  // point than the end of the full-expression. The first context is when a
1939  // default constructor is called to initialize an element of an array.
1940  // If the constructor has one or more default arguments, the destruction of
1941  // every temporary created in a default argument expression is sequenced
1942  // before the construction of the next array element, if any.
1943 
1944  {
1945  RunCleanupsScope Scope(*this);
1946 
1947  // Evaluate the constructor and its arguments in a regular
1948  // partial-destroy cleanup.
1949  if (getLangOpts().Exceptions &&
1950  !ctor->getParent()->hasTrivialDestructor()) {
1951  Destroyer *destroyer = destroyCXXObject;
1952  pushRegularPartialArrayCleanup(arrayBegin, cur, type, eltAlignment,
1953  *destroyer);
1954  }
1955 
1956  EmitCXXConstructorCall(ctor, Ctor_Complete, /*ForVirtualBase=*/false,
1957  /*Delegating=*/false, curAddr, E);
1958  }
1959 
1960  // Go to the next element.
1961  llvm::Value *next =
1962  Builder.CreateInBoundsGEP(cur, llvm::ConstantInt::get(SizeTy, 1),
1963  "arrayctor.next");
1964  cur->addIncoming(next, Builder.GetInsertBlock());
1965 
1966  // Check whether that's the end of the loop.
1967  llvm::Value *done = Builder.CreateICmpEQ(next, arrayEnd, "arrayctor.done");
1968  llvm::BasicBlock *contBB = createBasicBlock("arrayctor.cont");
1969  Builder.CreateCondBr(done, contBB, loopBB);
1970 
1971  // Patch the earlier check to skip over the loop.
1972  if (zeroCheckBranch) zeroCheckBranch->setSuccessor(0, contBB);
1973 
1974  EmitBlock(contBB);
1975 }
1976 
1978  Address addr,
1979  QualType type) {
1980  const RecordType *rtype = type->castAs<RecordType>();
1981  const CXXRecordDecl *record = cast<CXXRecordDecl>(rtype->getDecl());
1982  const CXXDestructorDecl *dtor = record->getDestructor();
1983  assert(!dtor->isTrivial());
1984  CGF.EmitCXXDestructorCall(dtor, Dtor_Complete, /*for vbase*/ false,
1985  /*Delegating=*/false, addr);
1986 }
1987 
1989  CXXCtorType Type,
1990  bool ForVirtualBase,
1991  bool Delegating, Address This,
1992  const CXXConstructExpr *E) {
1993  CallArgList Args;
1994 
1995  // Push the this ptr.
1996  Args.add(RValue::get(This.getPointer()), D->getThisType(getContext()));
1997 
1998  // If this is a trivial constructor, emit a memcpy now before we lose
1999  // the alignment information on the argument.
2000  // FIXME: It would be better to preserve alignment information into CallArg.
2002  assert(E->getNumArgs() == 1 && "unexpected argcount for trivial ctor");
2003 
2004  const Expr *Arg = E->getArg(0);
2005  QualType SrcTy = Arg->getType();
2006  Address Src = EmitLValue(Arg).getAddress();
2007  QualType DestTy = getContext().getTypeDeclType(D->getParent());
2008  EmitAggregateCopyCtor(This, Src, DestTy, SrcTy);
2009  return;
2010  }
2011 
2012  // Add the rest of the user-supplied arguments.
2013  const FunctionProtoType *FPT = D->getType()->castAs<FunctionProtoType>();
2015  ? EvaluationOrder::ForceLeftToRight
2017  EmitCallArgs(Args, FPT, E->arguments(), E->getConstructor(),
2018  /*ParamsToSkip*/ 0, Order);
2019 
2020  EmitCXXConstructorCall(D, Type, ForVirtualBase, Delegating, This, Args);
2021 }
2022 
2024  const CXXConstructorDecl *Ctor,
2025  CXXCtorType Type, CallArgList &Args) {
2026  // We can't forward a variadic call.
2027  if (Ctor->isVariadic())
2028  return false;
2029 
2031  // If the parameters are callee-cleanup, it's not safe to forward.
2032  for (auto *P : Ctor->parameters())
2033  if (P->getType().isDestructedType())
2034  return false;
2035 
2036  // Likewise if they're inalloca.
2037  const CGFunctionInfo &Info =
2038  CGF.CGM.getTypes().arrangeCXXConstructorCall(Args, Ctor, Type, 0, 0);
2039  if (Info.usesInAlloca())
2040  return false;
2041  }
2042 
2043  // Anything else should be OK.
2044  return true;
2045 }
2046 
2048  CXXCtorType Type,
2049  bool ForVirtualBase,
2050  bool Delegating,
2051  Address This,
2052  CallArgList &Args) {
2053  const CXXRecordDecl *ClassDecl = D->getParent();
2054 
2055  // C++11 [class.mfct.non-static]p2:
2056  // If a non-static member function of a class X is called for an object that
2057  // is not of type X, or of a type derived from X, the behavior is undefined.
2058  // FIXME: Provide a source location here.
2060  This.getPointer(), getContext().getRecordType(ClassDecl));
2061 
2062  if (D->isTrivial() && D->isDefaultConstructor()) {
2063  assert(Args.size() == 1 && "trivial default ctor with args");
2064  return;
2065  }
2066 
2067  // If this is a trivial constructor, just emit what's needed. If this is a
2068  // union copy constructor, we must emit a memcpy, because the AST does not
2069  // model that copy.
2071  assert(Args.size() == 2 && "unexpected argcount for trivial ctor");
2072 
2073  QualType SrcTy = D->getParamDecl(0)->getType().getNonReferenceType();
2074  Address Src(Args[1].RV.getScalarVal(), getNaturalTypeAlignment(SrcTy));
2075  QualType DestTy = getContext().getTypeDeclType(ClassDecl);
2076  EmitAggregateCopyCtor(This, Src, DestTy, SrcTy);
2077  return;
2078  }
2079 
2080  bool PassPrototypeArgs = true;
2081  // Check whether we can actually emit the constructor before trying to do so.
2082  if (auto Inherited = D->getInheritedConstructor()) {
2083  PassPrototypeArgs = getTypes().inheritingCtorHasParams(Inherited, Type);
2084  if (PassPrototypeArgs && !canEmitDelegateCallArgs(*this, D, Type, Args)) {
2085  EmitInlinedInheritingCXXConstructorCall(D, Type, ForVirtualBase,
2086  Delegating, Args);
2087  return;
2088  }
2089  }
2090 
2091  // Insert any ABI-specific implicit constructor arguments.
2092  CGCXXABI::AddedStructorArgs ExtraArgs =
2093  CGM.getCXXABI().addImplicitConstructorArgs(*this, D, Type, ForVirtualBase,
2094  Delegating, Args);
2095 
2096  // Emit the call.
2097  llvm::Constant *CalleePtr =
2098  CGM.getAddrOfCXXStructor(D, getFromCtorType(Type));
2099  const CGFunctionInfo &Info = CGM.getTypes().arrangeCXXConstructorCall(
2100  Args, D, Type, ExtraArgs.Prefix, ExtraArgs.Suffix, PassPrototypeArgs);
2101  CGCallee Callee = CGCallee::forDirect(CalleePtr, D);
2102  EmitCall(Info, Callee, ReturnValueSlot(), Args);
2103 
2104  // Generate vtable assumptions if we're constructing a complete object
2105  // with a vtable. We don't do this for base subobjects for two reasons:
2106  // first, it's incorrect for classes with virtual bases, and second, we're
2107  // about to overwrite the vptrs anyway.
2108  // We also have to make sure if we can refer to vtable:
2109  // - Otherwise we can refer to vtable if it's safe to speculatively emit.
2110  // FIXME: If vtable is used by ctor/dtor, or if vtable is external and we are
2111  // sure that definition of vtable is not hidden,
2112  // then we are always safe to refer to it.
2113  // FIXME: It looks like InstCombine is very inefficient on dealing with
2114  // assumes. Make assumption loads require -fstrict-vtable-pointers temporarily.
2115  if (CGM.getCodeGenOpts().OptimizationLevel > 0 &&
2116  ClassDecl->isDynamicClass() && Type != Ctor_Base &&
2117  CGM.getCXXABI().canSpeculativelyEmitVTable(ClassDecl) &&
2118  CGM.getCodeGenOpts().StrictVTablePointers)
2119  EmitVTableAssumptionLoads(ClassDecl, This);
2120 }
2121 
2123  const CXXConstructorDecl *D, bool ForVirtualBase, Address This,
2124  bool InheritedFromVBase, const CXXInheritedCtorInitExpr *E) {
2125  CallArgList Args;
2126  CallArg ThisArg(RValue::get(This.getPointer()), D->getThisType(getContext()),
2127  /*NeedsCopy=*/false);
2128 
2129  // Forward the parameters.
2130  if (InheritedFromVBase &&
2131  CGM.getTarget().getCXXABI().hasConstructorVariants()) {
2132  // Nothing to do; this construction is not responsible for constructing
2133  // the base class containing the inherited constructor.
2134  // FIXME: Can we just pass undef's for the remaining arguments if we don't
2135  // have constructor variants?
2136  Args.push_back(ThisArg);
2137  } else if (!CXXInheritedCtorInitExprArgs.empty()) {
2138  // The inheriting constructor was inlined; just inject its arguments.
2139  assert(CXXInheritedCtorInitExprArgs.size() >= D->getNumParams() &&
2140  "wrong number of parameters for inherited constructor call");
2141  Args = CXXInheritedCtorInitExprArgs;
2142  Args[0] = ThisArg;
2143  } else {
2144  // The inheriting constructor was not inlined. Emit delegating arguments.
2145  Args.push_back(ThisArg);
2146  const auto *OuterCtor = cast<CXXConstructorDecl>(CurCodeDecl);
2147  assert(OuterCtor->getNumParams() == D->getNumParams());
2148  assert(!OuterCtor->isVariadic() && "should have been inlined");
2149 
2150  for (const auto *Param : OuterCtor->parameters()) {
2151  assert(getContext().hasSameUnqualifiedType(
2152  OuterCtor->getParamDecl(Param->getFunctionScopeIndex())->getType(),
2153  Param->getType()));
2154  EmitDelegateCallArg(Args, Param, E->getLocation());
2155 
2156  // Forward __attribute__(pass_object_size).
2157  if (Param->hasAttr<PassObjectSizeAttr>()) {
2158  auto *POSParam = SizeArguments[Param];
2159  assert(POSParam && "missing pass_object_size value for forwarding");
2160  EmitDelegateCallArg(Args, POSParam, E->getLocation());
2161  }
2162  }
2163  }
2164 
2165  EmitCXXConstructorCall(D, Ctor_Base, ForVirtualBase, /*Delegating*/false,
2166  This, Args);
2167 }
2168 
2170  const CXXConstructorDecl *Ctor, CXXCtorType CtorType, bool ForVirtualBase,
2171  bool Delegating, CallArgList &Args) {
2172  GlobalDecl GD(Ctor, CtorType);
2174  ApplyInlineDebugLocation DebugScope(*this, GD);
2175 
2176  // Save the arguments to be passed to the inherited constructor.
2177  CXXInheritedCtorInitExprArgs = Args;
2178 
2179  FunctionArgList Params;
2180  QualType RetType = BuildFunctionArgList(CurGD, Params);
2181  FnRetTy = RetType;
2182 
2183  // Insert any ABI-specific implicit constructor arguments.
2184  CGM.getCXXABI().addImplicitConstructorArgs(*this, Ctor, CtorType,
2185  ForVirtualBase, Delegating, Args);
2186 
2187  // Emit a simplified prolog. We only need to emit the implicit params.
2188  assert(Args.size() >= Params.size() && "too few arguments for call");
2189  for (unsigned I = 0, N = Args.size(); I != N; ++I) {
2190  if (I < Params.size() && isa<ImplicitParamDecl>(Params[I])) {
2191  const RValue &RV = Args[I].RV;
2192  assert(!RV.isComplex() && "complex indirect params not supported");
2193  ParamValue Val = RV.isScalar()
2194  ? ParamValue::forDirect(RV.getScalarVal())
2195  : ParamValue::forIndirect(RV.getAggregateAddress());
2196  EmitParmDecl(*Params[I], Val, I + 1);
2197  }
2198  }
2199 
2200  // Create a return value slot if the ABI implementation wants one.
2201  // FIXME: This is dumb, we should ask the ABI not to try to set the return
2202  // value instead.
2203  if (!RetType->isVoidType())
2204  ReturnValue = CreateIRTemp(RetType, "retval.inhctor");
2205 
2206  CGM.getCXXABI().EmitInstanceFunctionProlog(*this);
2207  CXXThisValue = CXXABIThisValue;
2208 
2209  // Directly emit the constructor initializers.
2210  EmitCtorPrologue(Ctor, CtorType, Params);
2211 }
2212 
2214  llvm::Value *VTableGlobal =
2215  CGM.getCXXABI().getVTableAddressPoint(Vptr.Base, Vptr.VTableClass);
2216  if (!VTableGlobal)
2217  return;
2218 
2219  // We can just use the base offset in the complete class.
2220  CharUnits NonVirtualOffset = Vptr.Base.getBaseOffset();
2221 
2222  if (!NonVirtualOffset.isZero())
2223  This =
2224  ApplyNonVirtualAndVirtualOffset(*this, This, NonVirtualOffset, nullptr,
2225  Vptr.VTableClass, Vptr.NearestVBase);
2226 
2227  llvm::Value *VPtrValue =
2228  GetVTablePtr(This, VTableGlobal->getType(), Vptr.VTableClass);
2229  llvm::Value *Cmp =
2230  Builder.CreateICmpEQ(VPtrValue, VTableGlobal, "cmp.vtables");
2231  Builder.CreateAssumption(Cmp);
2232 }
2233 
2235  Address This) {
2236  if (CGM.getCXXABI().doStructorsInitializeVPtrs(ClassDecl))
2237  for (const VPtr &Vptr : getVTablePointers(ClassDecl))
2238  EmitVTableAssumptionLoad(Vptr, This);
2239 }
2240 
2241 void
2243  Address This, Address Src,
2244  const CXXConstructExpr *E) {
2245  const FunctionProtoType *FPT = D->getType()->castAs<FunctionProtoType>();
2246 
2247  CallArgList Args;
2248 
2249  // Push the this ptr.
2250  Args.add(RValue::get(This.getPointer()), D->getThisType(getContext()));
2251 
2252  // Push the src ptr.
2253  QualType QT = *(FPT->param_type_begin());
2254  llvm::Type *t = CGM.getTypes().ConvertType(QT);
2255  Src = Builder.CreateBitCast(Src, t);
2256  Args.add(RValue::get(Src.getPointer()), QT);
2257 
2258  // Skip over first argument (Src).
2259  EmitCallArgs(Args, FPT, drop_begin(E->arguments(), 1), E->getConstructor(),
2260  /*ParamsToSkip*/ 1);
2261 
2262  EmitCXXConstructorCall(D, Ctor_Complete, false, false, This, Args);
2263 }
2264 
2265 void
2267  CXXCtorType CtorType,
2268  const FunctionArgList &Args,
2269  SourceLocation Loc) {
2270  CallArgList DelegateArgs;
2271 
2272  FunctionArgList::const_iterator I = Args.begin(), E = Args.end();
2273  assert(I != E && "no parameters to constructor");
2274 
2275  // this
2276  Address This = LoadCXXThisAddress();
2277  DelegateArgs.add(RValue::get(This.getPointer()), (*I)->getType());
2278  ++I;
2279 
2280  // FIXME: The location of the VTT parameter in the parameter list is
2281  // specific to the Itanium ABI and shouldn't be hardcoded here.
2282  if (CGM.getCXXABI().NeedsVTTParameter(CurGD)) {
2283  assert(I != E && "cannot skip vtt parameter, already done with args");
2284  assert((*I)->getType()->isPointerType() &&
2285  "skipping parameter not of vtt type");
2286  ++I;
2287  }
2288 
2289  // Explicit arguments.
2290  for (; I != E; ++I) {
2291  const VarDecl *param = *I;
2292  // FIXME: per-argument source location
2293  EmitDelegateCallArg(DelegateArgs, param, Loc);
2294  }
2295 
2296  EmitCXXConstructorCall(Ctor, CtorType, /*ForVirtualBase=*/false,
2297  /*Delegating=*/true, This, DelegateArgs);
2298 }
2299 
2300 namespace {
2301  struct CallDelegatingCtorDtor final : EHScopeStack::Cleanup {
2302  const CXXDestructorDecl *Dtor;
2303  Address Addr;
2304  CXXDtorType Type;
2305 
2306  CallDelegatingCtorDtor(const CXXDestructorDecl *D, Address Addr,
2307  CXXDtorType Type)
2308  : Dtor(D), Addr(Addr), Type(Type) {}
2309 
2310  void Emit(CodeGenFunction &CGF, Flags flags) override {
2311  CGF.EmitCXXDestructorCall(Dtor, Type, /*ForVirtualBase=*/false,
2312  /*Delegating=*/true, Addr);
2313  }
2314  };
2315 } // end anonymous namespace
2316 
2317 void
2319  const FunctionArgList &Args) {
2320  assert(Ctor->isDelegatingConstructor());
2321 
2322  Address ThisPtr = LoadCXXThisAddress();
2323 
2324  AggValueSlot AggSlot =
2325  AggValueSlot::forAddr(ThisPtr, Qualifiers(),
2329 
2330  EmitAggExpr(Ctor->init_begin()[0]->getInit(), AggSlot);
2331 
2332  const CXXRecordDecl *ClassDecl = Ctor->getParent();
2333  if (CGM.getLangOpts().Exceptions && !ClassDecl->hasTrivialDestructor()) {
2334  CXXDtorType Type =
2335  CurGD.getCtorType() == Ctor_Complete ? Dtor_Complete : Dtor_Base;
2336 
2337  EHStack.pushCleanup<CallDelegatingCtorDtor>(EHCleanup,
2338  ClassDecl->getDestructor(),
2339  ThisPtr, Type);
2340  }
2341 }
2342 
2344  CXXDtorType Type,
2345  bool ForVirtualBase,
2346  bool Delegating,
2347  Address This) {
2348  CGM.getCXXABI().EmitDestructorCall(*this, DD, Type, ForVirtualBase,
2349  Delegating, This);
2350 }
2351 
2352 namespace {
2353  struct CallLocalDtor final : EHScopeStack::Cleanup {
2354  const CXXDestructorDecl *Dtor;
2355  Address Addr;
2356 
2357  CallLocalDtor(const CXXDestructorDecl *D, Address Addr)
2358  : Dtor(D), Addr(Addr) {}
2359 
2360  void Emit(CodeGenFunction &CGF, Flags flags) override {
2362  /*ForVirtualBase=*/false,
2363  /*Delegating=*/false, Addr);
2364  }
2365  };
2366 } // end anonymous namespace
2367 
2369  Address Addr) {
2370  EHStack.pushCleanup<CallLocalDtor>(NormalAndEHCleanup, D, Addr);
2371 }
2372 
2374  CXXRecordDecl *ClassDecl = T->getAsCXXRecordDecl();
2375  if (!ClassDecl) return;
2376  if (ClassDecl->hasTrivialDestructor()) return;
2377 
2378  const CXXDestructorDecl *D = ClassDecl->getDestructor();
2379  assert(D && D->isUsed() && "destructor not marked as used!");
2380  PushDestructorCleanup(D, Addr);
2381 }
2382 
2384  // Compute the address point.
2385  llvm::Value *VTableAddressPoint =
2386  CGM.getCXXABI().getVTableAddressPointInStructor(
2387  *this, Vptr.VTableClass, Vptr.Base, Vptr.NearestVBase);
2388 
2389  if (!VTableAddressPoint)
2390  return;
2391 
2392  // Compute where to store the address point.
2393  llvm::Value *VirtualOffset = nullptr;
2394  CharUnits NonVirtualOffset = CharUnits::Zero();
2395 
2396  if (CGM.getCXXABI().isVirtualOffsetNeededForVTableField(*this, Vptr)) {
2397  // We need to use the virtual base offset offset because the virtual base
2398  // might have a different offset in the most derived class.
2399 
2400  VirtualOffset = CGM.getCXXABI().GetVirtualBaseClassOffset(
2401  *this, LoadCXXThisAddress(), Vptr.VTableClass, Vptr.NearestVBase);
2402  NonVirtualOffset = Vptr.OffsetFromNearestVBase;
2403  } else {
2404  // We can just use the base offset in the complete class.
2405  NonVirtualOffset = Vptr.Base.getBaseOffset();
2406  }
2407 
2408  // Apply the offsets.
2409  Address VTableField = LoadCXXThisAddress();
2410 
2411  if (!NonVirtualOffset.isZero() || VirtualOffset)
2412  VTableField = ApplyNonVirtualAndVirtualOffset(
2413  *this, VTableField, NonVirtualOffset, VirtualOffset, Vptr.VTableClass,
2414  Vptr.NearestVBase);
2415 
2416  // Finally, store the address point. Use the same LLVM types as the field to
2417  // support optimization.
2418  llvm::Type *VTablePtrTy =
2419  llvm::FunctionType::get(CGM.Int32Ty, /*isVarArg=*/true)
2420  ->getPointerTo()
2421  ->getPointerTo();
2422  VTableField = Builder.CreateBitCast(VTableField, VTablePtrTy->getPointerTo());
2423  VTableAddressPoint = Builder.CreateBitCast(VTableAddressPoint, VTablePtrTy);
2424 
2425  llvm::StoreInst *Store = Builder.CreateStore(VTableAddressPoint, VTableField);
2426  TBAAAccessInfo TBAAInfo = CGM.getTBAAVTablePtrAccessInfo(VTablePtrTy);
2427  CGM.DecorateInstructionWithTBAA(Store, TBAAInfo);
2428  if (CGM.getCodeGenOpts().OptimizationLevel > 0 &&
2429  CGM.getCodeGenOpts().StrictVTablePointers)
2430  CGM.DecorateInstructionWithInvariantGroup(Store, Vptr.VTableClass);
2431 }
2432 
2435  CodeGenFunction::VPtrsVector VPtrsResult;
2436  VisitedVirtualBasesSetTy VBases;
2437  getVTablePointers(BaseSubobject(VTableClass, CharUnits::Zero()),
2438  /*NearestVBase=*/nullptr,
2439  /*OffsetFromNearestVBase=*/CharUnits::Zero(),
2440  /*BaseIsNonVirtualPrimaryBase=*/false, VTableClass, VBases,
2441  VPtrsResult);
2442  return VPtrsResult;
2443 }
2444 
2446  const CXXRecordDecl *NearestVBase,
2447  CharUnits OffsetFromNearestVBase,
2448  bool BaseIsNonVirtualPrimaryBase,
2449  const CXXRecordDecl *VTableClass,
2450  VisitedVirtualBasesSetTy &VBases,
2451  VPtrsVector &Vptrs) {
2452  // If this base is a non-virtual primary base the address point has already
2453  // been set.
2454  if (!BaseIsNonVirtualPrimaryBase) {
2455  // Initialize the vtable pointer for this base.
2456  VPtr Vptr = {Base, NearestVBase, OffsetFromNearestVBase, VTableClass};
2457  Vptrs.push_back(Vptr);
2458  }
2459 
2460  const CXXRecordDecl *RD = Base.getBase();
2461 
2462  // Traverse bases.
2463  for (const auto &I : RD->bases()) {
2464  CXXRecordDecl *BaseDecl
2465  = cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
2466 
2467  // Ignore classes without a vtable.
2468  if (!BaseDecl->isDynamicClass())
2469  continue;
2470 
2471  CharUnits BaseOffset;
2472  CharUnits BaseOffsetFromNearestVBase;
2473  bool BaseDeclIsNonVirtualPrimaryBase;
2474 
2475  if (I.isVirtual()) {
2476  // Check if we've visited this virtual base before.
2477  if (!VBases.insert(BaseDecl).second)
2478  continue;
2479 
2480  const ASTRecordLayout &Layout =
2481  getContext().getASTRecordLayout(VTableClass);
2482 
2483  BaseOffset = Layout.getVBaseClassOffset(BaseDecl);
2484  BaseOffsetFromNearestVBase = CharUnits::Zero();
2485  BaseDeclIsNonVirtualPrimaryBase = false;
2486  } else {
2487  const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
2488 
2489  BaseOffset = Base.getBaseOffset() + Layout.getBaseClassOffset(BaseDecl);
2490  BaseOffsetFromNearestVBase =
2491  OffsetFromNearestVBase + Layout.getBaseClassOffset(BaseDecl);
2492  BaseDeclIsNonVirtualPrimaryBase = Layout.getPrimaryBase() == BaseDecl;
2493  }
2494 
2495  getVTablePointers(
2496  BaseSubobject(BaseDecl, BaseOffset),
2497  I.isVirtual() ? BaseDecl : NearestVBase, BaseOffsetFromNearestVBase,
2498  BaseDeclIsNonVirtualPrimaryBase, VTableClass, VBases, Vptrs);
2499  }
2500 }
2501 
2503  // Ignore classes without a vtable.
2504  if (!RD->isDynamicClass())
2505  return;
2506 
2507  // Initialize the vtable pointers for this class and all of its bases.
2508  if (CGM.getCXXABI().doStructorsInitializeVPtrs(RD))
2509  for (const VPtr &Vptr : getVTablePointers(RD))
2510  InitializeVTablePointer(Vptr);
2511 
2512  if (RD->getNumVBases())
2513  CGM.getCXXABI().initializeHiddenVirtualInheritanceMembers(*this, RD);
2514 }
2515 
2517  llvm::Type *VTableTy,
2518  const CXXRecordDecl *RD) {
2519  Address VTablePtrSrc = Builder.CreateElementBitCast(This, VTableTy);
2520  llvm::Instruction *VTable = Builder.CreateLoad(VTablePtrSrc, "vtable");
2521  TBAAAccessInfo TBAAInfo = CGM.getTBAAVTablePtrAccessInfo(VTableTy);
2522  CGM.DecorateInstructionWithTBAA(VTable, TBAAInfo);
2523 
2524  if (CGM.getCodeGenOpts().OptimizationLevel > 0 &&
2525  CGM.getCodeGenOpts().StrictVTablePointers)
2526  CGM.DecorateInstructionWithInvariantGroup(VTable, RD);
2527 
2528  return VTable;
2529 }
2530 
2531 // If a class has a single non-virtual base and does not introduce or override
2532 // virtual member functions or fields, it will have the same layout as its base.
2533 // This function returns the least derived such class.
2534 //
2535 // Casting an instance of a base class to such a derived class is technically
2536 // undefined behavior, but it is a relatively common hack for introducing member
2537 // functions on class instances with specific properties (e.g. llvm::Operator)
2538 // that works under most compilers and should not have security implications, so
2539 // we allow it by default. It can be disabled with -fsanitize=cfi-cast-strict.
2540 static const CXXRecordDecl *
2542  if (!RD->field_empty())
2543  return RD;
2544 
2545  if (RD->getNumVBases() != 0)
2546  return RD;
2547 
2548  if (RD->getNumBases() != 1)
2549  return RD;
2550 
2551  for (const CXXMethodDecl *MD : RD->methods()) {
2552  if (MD->isVirtual()) {
2553  // Virtual member functions are only ok if they are implicit destructors
2554  // because the implicit destructor will have the same semantics as the
2555  // base class's destructor if no fields are added.
2556  if (isa<CXXDestructorDecl>(MD) && MD->isImplicit())
2557  continue;
2558  return RD;
2559  }
2560  }
2561 
2563  RD->bases_begin()->getType()->getAsCXXRecordDecl());
2564 }
2565 
2567  llvm::Value *VTable,
2568  SourceLocation Loc) {
2569  if (SanOpts.has(SanitizerKind::CFIVCall))
2570  EmitVTablePtrCheckForCall(RD, VTable, CodeGenFunction::CFITCK_VCall, Loc);
2571  else if (CGM.getCodeGenOpts().WholeProgramVTables &&
2572  CGM.HasHiddenLTOVisibility(RD)) {
2573  llvm::Metadata *MD =
2574  CGM.CreateMetadataIdentifierForType(QualType(RD->getTypeForDecl(), 0));
2575  llvm::Value *TypeId =
2576  llvm::MetadataAsValue::get(CGM.getLLVMContext(), MD);
2577 
2578  llvm::Value *CastedVTable = Builder.CreateBitCast(VTable, Int8PtrTy);
2579  llvm::Value *TypeTest =
2580  Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::type_test),
2581  {CastedVTable, TypeId});
2582  Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::assume), TypeTest);
2583  }
2584 }
2585 
2587  llvm::Value *VTable,
2588  CFITypeCheckKind TCK,
2589  SourceLocation Loc) {
2590  if (!SanOpts.has(SanitizerKind::CFICastStrict))
2592 
2593  EmitVTablePtrCheck(RD, VTable, TCK, Loc);
2594 }
2595 
2597  llvm::Value *Derived,
2598  bool MayBeNull,
2599  CFITypeCheckKind TCK,
2600  SourceLocation Loc) {
2601  if (!getLangOpts().CPlusPlus)
2602  return;
2603 
2604  auto *ClassTy = T->getAs<RecordType>();
2605  if (!ClassTy)
2606  return;
2607 
2608  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(ClassTy->getDecl());
2609 
2610  if (!ClassDecl->isCompleteDefinition() || !ClassDecl->isDynamicClass())
2611  return;
2612 
2613  if (!SanOpts.has(SanitizerKind::CFICastStrict))
2614  ClassDecl = LeastDerivedClassWithSameLayout(ClassDecl);
2615 
2616  llvm::BasicBlock *ContBlock = nullptr;
2617 
2618  if (MayBeNull) {
2619  llvm::Value *DerivedNotNull =
2620  Builder.CreateIsNotNull(Derived, "cast.nonnull");
2621 
2622  llvm::BasicBlock *CheckBlock = createBasicBlock("cast.check");
2623  ContBlock = createBasicBlock("cast.cont");
2624 
2625  Builder.CreateCondBr(DerivedNotNull, CheckBlock, ContBlock);
2626 
2627  EmitBlock(CheckBlock);
2628  }
2629 
2630  llvm::Value *VTable;
2631  std::tie(VTable, ClassDecl) = CGM.getCXXABI().LoadVTablePtr(
2632  *this, Address(Derived, getPointerAlign()), ClassDecl);
2633 
2634  EmitVTablePtrCheck(ClassDecl, VTable, TCK, Loc);
2635 
2636  if (MayBeNull) {
2637  Builder.CreateBr(ContBlock);
2638  EmitBlock(ContBlock);
2639  }
2640 }
2641 
2643  llvm::Value *VTable,
2644  CFITypeCheckKind TCK,
2645  SourceLocation Loc) {
2646  if (!CGM.getCodeGenOpts().SanitizeCfiCrossDso &&
2647  !CGM.HasHiddenLTOVisibility(RD))
2648  return;
2649 
2650  SanitizerMask M;
2651  llvm::SanitizerStatKind SSK;
2652  switch (TCK) {
2653  case CFITCK_VCall:
2654  M = SanitizerKind::CFIVCall;
2655  SSK = llvm::SanStat_CFI_VCall;
2656  break;
2657  case CFITCK_NVCall:
2658  M = SanitizerKind::CFINVCall;
2659  SSK = llvm::SanStat_CFI_NVCall;
2660  break;
2661  case CFITCK_DerivedCast:
2662  M = SanitizerKind::CFIDerivedCast;
2663  SSK = llvm::SanStat_CFI_DerivedCast;
2664  break;
2665  case CFITCK_UnrelatedCast:
2666  M = SanitizerKind::CFIUnrelatedCast;
2667  SSK = llvm::SanStat_CFI_UnrelatedCast;
2668  break;
2669  case CFITCK_ICall:
2670  llvm_unreachable("not expecting CFITCK_ICall");
2671  }
2672 
2673  std::string TypeName = RD->getQualifiedNameAsString();
2674  if (getContext().getSanitizerBlacklist().isBlacklistedType(M, TypeName))
2675  return;
2676 
2677  SanitizerScope SanScope(this);
2678  EmitSanitizerStatReport(SSK);
2679 
2680  llvm::Metadata *MD =
2681  CGM.CreateMetadataIdentifierForType(QualType(RD->getTypeForDecl(), 0));
2682  llvm::Value *TypeId = llvm::MetadataAsValue::get(getLLVMContext(), MD);
2683 
2684  llvm::Value *CastedVTable = Builder.CreateBitCast(VTable, Int8PtrTy);
2685  llvm::Value *TypeTest = Builder.CreateCall(
2686  CGM.getIntrinsic(llvm::Intrinsic::type_test), {CastedVTable, TypeId});
2687 
2688  llvm::Constant *StaticData[] = {
2689  llvm::ConstantInt::get(Int8Ty, TCK),
2690  EmitCheckSourceLocation(Loc),
2691  EmitCheckTypeDescriptor(QualType(RD->getTypeForDecl(), 0)),
2692  };
2693 
2694  auto CrossDsoTypeId = CGM.CreateCrossDsoCfiTypeId(MD);
2695  if (CGM.getCodeGenOpts().SanitizeCfiCrossDso && CrossDsoTypeId) {
2696  EmitCfiSlowPathCheck(M, TypeTest, CrossDsoTypeId, CastedVTable, StaticData);
2697  return;
2698  }
2699 
2700  if (CGM.getCodeGenOpts().SanitizeTrap.has(M)) {
2701  EmitTrapCheck(TypeTest);
2702  return;
2703  }
2704 
2705  llvm::Value *AllVtables = llvm::MetadataAsValue::get(
2706  CGM.getLLVMContext(),
2707  llvm::MDString::get(CGM.getLLVMContext(), "all-vtables"));
2708  llvm::Value *ValidVtable = Builder.CreateCall(
2709  CGM.getIntrinsic(llvm::Intrinsic::type_test), {CastedVTable, AllVtables});
2710  EmitCheck(std::make_pair(TypeTest, M), SanitizerHandler::CFICheckFail,
2711  StaticData, {CastedVTable, ValidVtable});
2712 }
2713 
2715  if (!CGM.getCodeGenOpts().WholeProgramVTables ||
2716  !SanOpts.has(SanitizerKind::CFIVCall) ||
2717  !CGM.getCodeGenOpts().SanitizeTrap.has(SanitizerKind::CFIVCall) ||
2718  !CGM.HasHiddenLTOVisibility(RD))
2719  return false;
2720 
2721  std::string TypeName = RD->getQualifiedNameAsString();
2723  SanitizerKind::CFIVCall, TypeName);
2724 }
2725 
2727  const CXXRecordDecl *RD, llvm::Value *VTable, uint64_t VTableByteOffset) {
2728  SanitizerScope SanScope(this);
2729 
2730  EmitSanitizerStatReport(llvm::SanStat_CFI_VCall);
2731 
2732  llvm::Metadata *MD =
2733  CGM.CreateMetadataIdentifierForType(QualType(RD->getTypeForDecl(), 0));
2734  llvm::Value *TypeId = llvm::MetadataAsValue::get(CGM.getLLVMContext(), MD);
2735 
2736  llvm::Value *CastedVTable = Builder.CreateBitCast(VTable, Int8PtrTy);
2737  llvm::Value *CheckedLoad = Builder.CreateCall(
2738  CGM.getIntrinsic(llvm::Intrinsic::type_checked_load),
2739  {CastedVTable, llvm::ConstantInt::get(Int32Ty, VTableByteOffset),
2740  TypeId});
2741  llvm::Value *CheckResult = Builder.CreateExtractValue(CheckedLoad, 1);
2742 
2743  EmitCheck(std::make_pair(CheckResult, SanitizerKind::CFIVCall),
2744  SanitizerHandler::CFICheckFail, nullptr, nullptr);
2745 
2746  return Builder.CreateBitCast(
2747  Builder.CreateExtractValue(CheckedLoad, 0),
2748  cast<llvm::PointerType>(VTable->getType())->getElementType());
2749 }
2750 
2752  const CXXMethodDecl *callOperator,
2753  CallArgList &callArgs) {
2754  // Get the address of the call operator.
2755  const CGFunctionInfo &calleeFnInfo =
2756  CGM.getTypes().arrangeCXXMethodDeclaration(callOperator);
2757  llvm::Constant *calleePtr =
2758  CGM.GetAddrOfFunction(GlobalDecl(callOperator),
2759  CGM.getTypes().GetFunctionType(calleeFnInfo));
2760 
2761  // Prepare the return slot.
2762  const FunctionProtoType *FPT =
2763  callOperator->getType()->castAs<FunctionProtoType>();
2764  QualType resultType = FPT->getReturnType();
2765  ReturnValueSlot returnSlot;
2766  if (!resultType->isVoidType() &&
2767  calleeFnInfo.getReturnInfo().getKind() == ABIArgInfo::Indirect &&
2768  !hasScalarEvaluationKind(calleeFnInfo.getReturnType()))
2769  returnSlot = ReturnValueSlot(ReturnValue, resultType.isVolatileQualified());
2770 
2771  // We don't need to separately arrange the call arguments because
2772  // the call can't be variadic anyway --- it's impossible to forward
2773  // variadic arguments.
2774 
2775  // Now emit our call.
2776  auto callee = CGCallee::forDirect(calleePtr, callOperator);
2777  RValue RV = EmitCall(calleeFnInfo, callee, returnSlot, callArgs);
2778 
2779  // If necessary, copy the returned value into the slot.
2780  if (!resultType->isVoidType() && returnSlot.isNull()) {
2781  if (getLangOpts().ObjCAutoRefCount && resultType->isObjCRetainableType()) {
2782  RV = RValue::get(EmitARCRetainAutoreleasedReturnValue(RV.getScalarVal()));
2783  }
2784  EmitReturnOfRValue(RV, resultType);
2785  } else
2786  EmitBranchThroughCleanup(ReturnBlock);
2787 }
2788 
2790  const BlockDecl *BD = BlockInfo->getBlockDecl();
2791  const VarDecl *variable = BD->capture_begin()->getVariable();
2792  const CXXRecordDecl *Lambda = variable->getType()->getAsCXXRecordDecl();
2793  const CXXMethodDecl *CallOp = Lambda->getLambdaCallOperator();
2794 
2795  if (CallOp->isVariadic()) {
2796  // FIXME: Making this work correctly is nasty because it requires either
2797  // cloning the body of the call operator or making the call operator
2798  // forward.
2799  CGM.ErrorUnsupported(CurCodeDecl, "lambda conversion to variadic function");
2800  return;
2801  }
2802 
2803  // Start building arguments for forwarding call
2804  CallArgList CallArgs;
2805 
2806  QualType ThisType = getContext().getPointerType(getContext().getRecordType(Lambda));
2807  Address ThisPtr = GetAddrOfBlockDecl(variable, false);
2808  CallArgs.add(RValue::get(ThisPtr.getPointer()), ThisType);
2809 
2810  // Add the rest of the parameters.
2811  for (auto param : BD->parameters())
2812  EmitDelegateCallArg(CallArgs, param, param->getLocStart());
2813 
2814  assert(!Lambda->isGenericLambda() &&
2815  "generic lambda interconversion to block not implemented");
2816  EmitForwardingCallToLambda(CallOp, CallArgs);
2817 }
2818 
2820  const CXXRecordDecl *Lambda = MD->getParent();
2821 
2822  // Start building arguments for forwarding call
2823  CallArgList CallArgs;
2824 
2825  QualType ThisType = getContext().getPointerType(getContext().getRecordType(Lambda));
2826  llvm::Value *ThisPtr = llvm::UndefValue::get(getTypes().ConvertType(ThisType));
2827  CallArgs.add(RValue::get(ThisPtr), ThisType);
2828 
2829  // Add the rest of the parameters.
2830  for (auto Param : MD->parameters())
2831  EmitDelegateCallArg(CallArgs, Param, Param->getLocStart());
2832 
2833  const CXXMethodDecl *CallOp = Lambda->getLambdaCallOperator();
2834  // For a generic lambda, find the corresponding call operator specialization
2835  // to which the call to the static-invoker shall be forwarded.
2836  if (Lambda->isGenericLambda()) {
2837  assert(MD->isFunctionTemplateSpecialization());
2839  FunctionTemplateDecl *CallOpTemplate = CallOp->getDescribedFunctionTemplate();
2840  void *InsertPos = nullptr;
2841  FunctionDecl *CorrespondingCallOpSpecialization =
2842  CallOpTemplate->findSpecialization(TAL->asArray(), InsertPos);
2843  assert(CorrespondingCallOpSpecialization);
2844  CallOp = cast<CXXMethodDecl>(CorrespondingCallOpSpecialization);
2845  }
2846  EmitForwardingCallToLambda(CallOp, CallArgs);
2847 }
2848 
2850  if (MD->isVariadic()) {
2851  // FIXME: Making this work correctly is nasty because it requires either
2852  // cloning the body of the call operator or making the call operator forward.
2853  CGM.ErrorUnsupported(MD, "lambda conversion to variadic function");
2854  return;
2855  }
2856 
2857  EmitLambdaDelegatingInvokeBody(MD);
2858 }
bool isBaseInitializer() const
Determine whether this initializer is initializing a base class.
Definition: DeclCXX.h:2238
ReturnValueSlot - Contains the address where the return value of a function can be stored...
Definition: CGCall.h:281
void EnterDtorCleanups(const CXXDestructorDecl *Dtor, CXXDtorType Type)
EnterDtorCleanups - Enter the cleanups necessary to complete the given phase of destruction for a des...
Definition: CGClass.cpp:1737
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1698
int64_t QuantityType
Definition: CharUnits.h:40
Expr * getInit() const
Get the initializer.
Definition: DeclCXX.h:2367
void EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor, CXXCtorType CtorType, const FunctionArgList &Args, SourceLocation Loc)
Definition: CGClass.cpp:2266
Complete object ctor.
Definition: ABI.h:26
A (possibly-)qualified type.
Definition: Type.h:653
const CGBitFieldInfo & getBitFieldInfo(const FieldDecl *FD) const
Return the BitFieldInfo that corresponds to the field FD.
Address EmitCXXMemberDataPointerAddress(const Expr *E, Address base, llvm::Value *memberPtr, const MemberPointerType *memberPtrType, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
Emit the address of a field using a member data pointer.
Definition: CGClass.cpp:129
void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type, FunctionArgList &Args)
EmitCtorPrologue - This routine generates necessary code to initialize base classes and non-static da...
Definition: CGClass.cpp:1241
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:2061
base_class_range bases()
Definition: DeclCXX.h:773
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2483
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition: DeclCXX.h:767
CGRecordLayout - This class handles struct and union layout info while lowering AST types to LLVM typ...
bool isBlacklistedType(SanitizerMask Mask, StringRef MangledTypeName, StringRef Category=StringRef()) const
FunctionDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
capture_const_iterator capture_begin() const
Definition: Decl.h:3817
llvm::LLVMContext & getLLVMContext()
static AggValueSlot forLValue(const LValue &LV, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, IsZeroed_t isZeroed=IsNotZeroed)
Definition: CGValue.h:517
CharUnits getClassPointerAlignment(const CXXRecordDecl *CD)
Returns the assumed alignment of an opaque pointer to the given class.
Definition: CGClass.cpp:36
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
Stmt - This represents one statement.
Definition: Stmt.h:66
Address GetAddressOfDirectBaseInCompleteClass(Address Value, const CXXRecordDecl *Derived, const CXXRecordDecl *Base, bool BaseIsVirtual)
GetAddressOfBaseOfCompleteClass - Convert the given pointer to a complete class to the given direct b...
Definition: CGClass.cpp:199
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:223
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:788
Address GetAddressOfDerivedClass(Address Value, const CXXRecordDecl *Derived, CastExpr::path_const_iterator PathBegin, CastExpr::path_const_iterator PathEnd, bool NullCheckValue)
Definition: CGClass.cpp:374
Checking the &#39;this&#39; pointer for a constructor call.
const Type * getTypeForDecl() const
Definition: Decl.h:2778
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
Definition: DeclCXX.h:244
Defines the C++ template declaration subclasses.
StringRef P
void EmitLambdaStaticInvokeBody(const CXXMethodDecl *MD)
Definition: CGClass.cpp:2849
unsigned getFieldIndex() const
getFieldIndex - Returns the index of this field within its record, as appropriate for passing to ASTR...
Definition: Decl.cpp:3638
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:5893
const void * Store
Store - This opaque type encapsulates an immutable mapping from locations to values.
Definition: StoreRef.h:26
llvm::Value * LoadCXXThis()
LoadCXXThis - Load the value of &#39;this&#39;.
const RecordDecl * getParent() const
getParent - Returns the parent of this field declaration, which is the struct in which this field is ...
Definition: Decl.h:2642
static bool isMemcpyEquivalentSpecialMember(const CXXMethodDecl *D)
Definition: CGClass.cpp:571
The base class of the type hierarchy.
Definition: Type.h:1353
Expr * getOperatorDeleteThisArg() const
Definition: DeclCXX.h:2656
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2560
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1239
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
CharUnits getAlignment() const
getAlignment - Get the record alignment in characters.
Definition: RecordLayout.h:171
LValue EmitLValueForFieldInitialization(LValue Base, const FieldDecl *Field)
EmitLValueForFieldInitialization - Like EmitLValueForField, except that if the Field is a reference...
Definition: CGExpr.cpp:3847
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclBase.h:412
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2397
bool isCompleteDefinition() const
isCompleteDefinition - Return true if this decl has its body fully specified.
Definition: Decl.h:3091
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition: Type.cpp:491
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:2089
bool isIndirectMemberInitializer() const
Definition: DeclCXX.h:2250
const CXXBaseSpecifier *const * path_const_iterator
Definition: Expr.h:2774
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:807
RAII object to set/unset CodeGenFunction::IsSanitizerScope.
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6307
llvm::Value * GetVTTParameter(GlobalDecl GD, bool ForVirtualBase, bool Delegating)
GetVTTParameter - Return the VTT parameter that should be passed to a base constructor/destructor wit...
Definition: CGClass.cpp:431
bool field_empty() const
Definition: Decl.h:3622
llvm::Value * getPointer() const
Definition: Address.h:38
void emitImplicitAssignmentOperatorBody(FunctionArgList &Args)
Definition: CGClass.cpp:1501
The collection of all-type qualifiers we support.
Definition: Type.h:152
bool mayInsertExtraPadding(bool EmitRemark=false) const
Whether we are allowed to insert extra padding between fields.
Definition: Decl.cpp:3984
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Definition: DeclCXX.cpp:1882
CharUnits getBaseOffset() const
getBaseOffset - Returns the base class offset.
Definition: BaseSubobject.h:46
static const CXXRecordDecl * LeastDerivedClassWithSameLayout(const CXXRecordDecl *RD)
Definition: CGClass.cpp:2541
const TargetInfo & getTarget() const
bool usesInAlloca() const
Return true if this function uses inalloca arguments.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:859
void emitDestroy(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
emitDestroy - Immediately perform the destruction of the given object.
Definition: CGDecl.cpp:1537
Address getAddress() const
Definition: CGValue.h:324
Indirect - Pass the argument indirectly via a hidden pointer with the specified alignment (0 indicate...
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
bool hasTrivialBody() const
hasTrivialBody - Returns whether the function has a trivial body that does not require any specific c...
Definition: Decl.cpp:2587
llvm::SmallPtrSet< const CXXRecordDecl *, 4 > VisitedVirtualBasesSetTy
void EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D, Address This, Address Src, const CXXConstructExpr *E)
Definition: CGClass.cpp:2242
field_range fields() const
Definition: Decl.h:3613
bool isVolatileQualified() const
Definition: CGValue.h:255
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2461
bool ShouldEmitVTableTypeCheckedLoad(const CXXRecordDecl *RD)
Returns whether we should perform a type checked load when loading a virtual function for virtual cal...
Definition: CGClass.cpp:2714
bool isReferenceType() const
Definition: Type.h:5956
void pushEHDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)
pushEHDestroy - Push the standard destructor for the given type as an EH-only cleanup.
Definition: CGDecl.cpp:1476
void EmitVTablePtrCheck(const CXXRecordDecl *RD, llvm::Value *VTable, CFITypeCheckKind TCK, SourceLocation Loc)
EmitVTablePtrCheck - Emit a check that VTable is a valid virtual table for RD using llvm...
Definition: CGClass.cpp:2642
InheritedConstructor getInheritedConstructor() const
Get the constructor that this inheriting constructor is based on.
Definition: DeclCXX.h:2593
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
Definition: EHScopeStack.h:81
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
CharUnits getVBaseClassOffset(const CXXRecordDecl *VBase) const
getVBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:231
void EmitCXXConstructorCall(const CXXConstructorDecl *D, CXXCtorType Type, bool ForVirtualBase, bool Delegating, Address This, const CXXConstructExpr *E)
Definition: CGClass.cpp:1988
void EmitLambdaDelegatingInvokeBody(const CXXMethodDecl *MD)
Definition: CGClass.cpp:2819
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2164
void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init)
Definition: CGClass.cpp:657
CharUnits getDynamicOffsetAlignment(CharUnits ActualAlign, const CXXRecordDecl *Class, CharUnits ExpectedTargetAlign)
Given a class pointer with an actual known alignment, and the expected alignment of an object at a dy...
Definition: CGClass.cpp:70
void EmitInheritedCXXConstructorCall(const CXXConstructorDecl *D, bool ForVirtualBase, Address This, bool InheritedFromVBase, const CXXInheritedCtorInitExpr *E)
Emit a call to a constructor inherited from a base class, passing the current constructor&#39;s arguments...
Definition: CGClass.cpp:2122
QualType getThisType(ASTContext &C) const
Returns the type of the this pointer.
Definition: DeclCXX.cpp:1934
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2539
bool isDelegatingConstructor() const
Determine whether this constructor is a delegating constructor.
Definition: DeclCXX.h:2516
Stmt * getBody(const FunctionDecl *&Definition) const
getBody - Retrieve the body (definition) of the function.
Definition: Decl.cpp:2612
Base object ctor.
Definition: ABI.h:27
bool isBaseVirtual() const
Returns whether the base is virtual or not.
Definition: DeclCXX.h:2291
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
void EmitTypeMetadataCodeForVCall(const CXXRecordDecl *RD, llvm::Value *VTable, SourceLocation Loc)
If whole-program virtual table optimization is enabled, emit an assumption that VTable is a member of...
Definition: CGClass.cpp:2566
uint32_t Offset
Definition: CacheTokens.cpp:43
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Definition: Type.cpp:2166
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:3222
CharUnits StorageOffset
The offset of the bitfield storage from the start of the struct.
ArrayRef< NamedDecl * > chain() const
Definition: Decl.h:2727
unsigned char PointerWidthInBits
The width of a pointer into the generic address space.
Deleting dtor.
Definition: ABI.h:35
CharUnits getAlignment() const
Return the alignment of this pointer.
Definition: Address.h:67
bool isComplex() const
Definition: CGValue.h:53
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2985
bool needsEHCleanup(QualType::DestructionKind kind)
Determines whether an EH cleanup is required to destroy a type with the given destruction kind...
const CGFunctionInfo & arrangeCXXConstructorCall(const CallArgList &Args, const CXXConstructorDecl *D, CXXCtorType CtorKind, unsigned ExtraPrefixArgs, unsigned ExtraSuffixArgs, bool PassProtoArgs=true)
Arrange a call to a C++ method, passing the given arguments.
Definition: CGCall.cpp:378
llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:259
const Type * getClass() const
Definition: Type.h:2538
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:39
void EmitDeleteCall(const FunctionDecl *DeleteFD, llvm::Value *Ptr, QualType DeleteTy, llvm::Value *NumElements=nullptr, CharUnits CookieSize=CharUnits())
Definition: CGExprCXX.cpp:1725
param_type_iterator param_type_begin() const
Definition: Type.h:3643
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
bool isAnyMemberInitializer() const
Definition: DeclCXX.h:2246
base_class_iterator bases_begin()
Definition: DeclCXX.h:780
void ForceCleanup(std::initializer_list< llvm::Value **> ValuesToReload={})
Force the emission of cleanups now, instead of waiting until this object is destroyed.
bool isSimple() const
Definition: CGValue.h:249
FieldDecl * getAnyMember() const
Definition: DeclCXX.h:2311
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1404
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:1458
FieldDecl * getMember() const
If this is a member initializer, returns the declaration of the non-static data member being initiali...
Definition: DeclCXX.h:2305
bool isAbstract() const
Determine whether this class has a pure virtual function.
Definition: DeclCXX.h:1296
static bool BaseInitializerUsesThis(ASTContext &C, const Expr *Init)
Definition: CGClass.cpp:520
Address getAggregateAddress() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
Definition: CGValue.h:71
init_iterator init_begin()
Retrieve an iterator to the first initializer.
Definition: DeclCXX.h:2457
bool isAnonymousStructOrUnion() const
isAnonymousStructOrUnion - Whether this is an anonymous struct or union.
Definition: Decl.h:3550
Represents the this expression in C++.
Definition: ExprCXX.h:945
LValue EmitLValueForField(LValue Base, const FieldDecl *Field)
Definition: CGExpr.cpp:3733
llvm::Constant * CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false)
Create a new runtime function with the specified type and name.
bool hasAttr() const
Definition: DeclBase.h:535
CanQualType getReturnType() const
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:58
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:595
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1590
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3270
llvm::CallInst * EmitNounwindRuntimeCall(llvm::Value *callee, const Twine &name="")
bool isDynamicClass() const
Definition: DeclCXX.h:751
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1302
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
Definition: CGValue.h:39
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
static void EmitLValueForAnyFieldInitialization(CodeGenFunction &CGF, CXXCtorInitializer *MemberInit, LValue &LHS)
Definition: CGClass.cpp:588
CXXCtorInitializer *const * init_const_iterator
Iterates through the member/base initializer list.
Definition: DeclCXX.h:2446
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:39
llvm::Value * GetVTablePtr(Address This, llvm::Type *VTableTy, const CXXRecordDecl *VTableClass)
GetVTablePtr - Return the Value of the vtable pointer member pointed to by This.
Definition: CGClass.cpp:2516
CXXDtorType
C++ destructor types.
Definition: ABI.h:34
BlockDecl - This represents a block literal declaration, which is like an unnamed FunctionDecl...
Definition: Decl.h:3689
Expr - This represents one expression.
Definition: Expr.h:106
bool isCopyOrMoveConstructor(unsigned &TypeQuals) const
Determine whether this is a copy or move constructor.
Definition: DeclCXX.cpp:2109
SourceLocation End
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2570
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:2009
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
const FunctionProtoType * T
void EmitVTableAssumptionLoad(const VPtr &vptr, Address This)
Emit assumption that vptr load == global vtable.
Definition: CGClass.cpp:2213
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6370
void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D, const ArrayType *ArrayTy, Address ArrayPtr, const CXXConstructExpr *E, bool ZeroInitialization=false)
EmitCXXAggrConstructorCall - Emit a loop to call a particular constructor for each of several members...
Definition: CGClass.cpp:1859
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
Definition: CGCall.h:125
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2620
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:551
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3343
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
llvm::PointerType * getType() const
Return the type of the pointer value.
Definition: Address.h:44
arg_range arguments()
Definition: ExprCXX.h:1348
const CXXRecordDecl * getPrimaryBase() const
getPrimaryBase - Get the primary base for this record.
Definition: RecordLayout.h:208
unsigned getFieldCount() const
getFieldCount - Get the number of fields in the layout.
Definition: RecordLayout.h:177
void add(RValue rvalue, QualType type, bool needscopy=false)
Definition: CGCall.h:207
void EmitAsanPrologueOrEpilogue(bool Prologue)
Definition: CGClass.cpp:742
char __ovld __cnfn min(char x, char y)
Returns y if y < x, otherwise it returns x.
const AstTypeMatcher< ArrayType > arrayType
Matches all kinds of arrays.
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
Definition: Decl.h:2329
llvm::LLVMContext & getLLVMContext()
const CXXRecordDecl * getBase() const
getBase - Returns the base class declaration.
Definition: BaseSubobject.h:43
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
Definition: DeclCXX.h:1289
Base object dtor.
Definition: ABI.h:37
void EmitConstructorBody(FunctionArgList &Args)
EmitConstructorBody - Emits the body of the current constructor.
Definition: CGClass.cpp:805
CharUnits alignmentOfArrayElement(CharUnits elementSize) const
Given that this is the alignment of the first element of an array, return the minimum alignment of an...
Definition: CharUnits.h:197
LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T)
QualType getRecordType(const RecordDecl *Decl) const
A scoped helper to set the current debug location to an inlined location.
Definition: CGDebugInfo.h:675
void EmitForwardingCallToLambda(const CXXMethodDecl *LambdaCallOperator, CallArgList &CallArgs)
Definition: CGClass.cpp:2751
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1717
const TargetInfo & getTarget() const
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1347
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2004
const LangOptions & getLangOpts() const
ASTContext & getContext() const
static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, IsZeroed_t isZeroed=IsNotZeroed)
forAddr - Make a slot for an aggregate value.
Definition: CGValue.h:495
The COMDAT used for dtors.
Definition: ABI.h:38
const SanitizerBlacklist & getSanitizerBlacklist() const
Definition: ASTContext.h:690
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:35
static const RecordType * getRecordType(QualType QT)
Checks that the passed in QualType either is of RecordType or points to RecordType.
The l-value was considered opaque, so the alignment was determined from a type.
RecordDecl * getDecl() const
Definition: Type.h:3988
static bool CanSkipVTablePointerInitialization(CodeGenFunction &CGF, const CXXDestructorDecl *Dtor)
CanSkipVTablePointerInitialization - Check whether we need to initialize any vtable pointers before c...
Definition: CGClass.cpp:1373
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
Definition: RecordLayout.h:181
void set(SanitizerMask K, bool Value)
Enable or disable a certain (single) sanitizer.
Definition: Sanitizers.h:59
Enumerates target-specific builtins in their own namespaces within namespace clang.
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:142
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1400
void PushDestructorCleanup(QualType T, Address Addr)
PushDestructorCleanup - Push a cleanup to call the complete-object destructor of an object of the giv...
Definition: CGClass.cpp:2373
Encodes a location in the source.
body_range body()
Definition: Stmt.h:624
QualType getReturnType() const
Definition: Type.h:3203
Expr * getSubExpr() const
Definition: Expr.h:1744
void EmitVTableAssumptionLoads(const CXXRecordDecl *ClassDecl, Address This)
Emit assumption load for all bases.
Definition: CGClass.cpp:2234
bool inheritingCtorHasParams(const InheritedConstructor &Inherited, CXXCtorType Type)
Determine if a C++ inheriting constructor should have parameters matching those of its inherited cons...
Definition: CGCall.cpp:278
Represents a call to a member function that may be written either with member call syntax (e...
Definition: ExprCXX.h:164
const Decl * getDecl() const
Definition: GlobalDecl.h:64
An aggregate value slot.
Definition: CGValue.h:434
init_iterator init_end()
Retrieve an iterator past the last initializer.
Definition: DeclCXX.h:2466
A scoped helper to set the current debug location to the specified location or preferred location of ...
Definition: CGDebugInfo.h:620
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1964
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2321
void EmitStmt(const Stmt *S, ArrayRef< const Attr *> Attrs=None)
EmitStmt - Emit the code for the statement.
Definition: CGStmt.cpp:48
virtual size_t getSrcArgforCopyCtor(const CXXConstructorDecl *, FunctionArgList &Args) const =0
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2187
SanitizerSet SanOpts
Sanitizers enabled for this function.
bool isGenericLambda() const
Determine whether this class describes a generic lambda function object (i.e.
Definition: DeclCXX.cpp:1116
An aligned address.
Definition: Address.h:25
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2822
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
Definition: Type.h:1098
All available information about a concrete callee.
Definition: CGCall.h:66
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required...
Definition: DeclBase.cpp:386
Complete object dtor.
Definition: ABI.h:36
void EmitInlinedInheritingCXXConstructorCall(const CXXConstructorDecl *Ctor, CXXCtorType CtorType, bool ForVirtualBase, bool Delegating, CallArgList &Args)
Emit a call to an inheriting constructor (that is, one that invokes a constructor inherited from a ba...
Definition: CGClass.cpp:2169
static void EmitBaseInitializer(CodeGenFunction &CGF, const CXXRecordDecl *ClassDecl, CXXCtorInitializer *BaseInit, CXXCtorType CtorType)
Definition: CGClass.cpp:526
CXXCtorType
C++ constructor types.
Definition: ABI.h:25
std::pair< CharUnits, CharUnits > getTypeInfoInChars(const Type *T) const
SourceLocation getLocation() const LLVM_READONLY
Definition: ExprCXX.h:1451
void InitializeVTablePointer(const VPtr &vptr)
Initialize the vtable pointer of the given subobject.
Definition: CGClass.cpp:2383
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type, returning the result.
FunctionArgList - Type for representing both the decl and type of parameters to a function...
Definition: CGCall.h:276
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition: CGValue.h:59
CGFunctionInfo - Class to encapsulate the information about a function definition.
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:190
Dataflow Directional Tag Classes.
void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating, Address This)
Definition: CGClass.cpp:2343
uint64_t SanitizerMask
Definition: Sanitizers.h:24
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
Definition: DeclCXX.cpp:1121
void EmitVTablePtrCheckForCast(QualType T, llvm::Value *Derived, bool MayBeNull, CFITypeCheckKind TCK, SourceLocation Loc)
Derived is the presumed address of an object of type T after a cast.
Definition: CGClass.cpp:2596
static bool canEmitDelegateCallArgs(CodeGenFunction &CGF, const CXXConstructorDecl *Ctor, CXXCtorType Type, CallArgList &Args)
Definition: CGClass.cpp:2023
A scope within which we are constructing the fields of an object which might use a CXXDefaultInitExpr...
IndirectFieldDecl - An instance of this class is created to represent a field injected from an anonym...
Definition: Decl.h:2705
SourceLocation getSourceLocation() const
Determine the source location of the initializer.
Definition: DeclCXX.cpp:2021
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:70
void EmitDelegatingCXXConstructorCall(const CXXConstructorDecl *Ctor, const FunctionArgList &Args)
Definition: CGClass.cpp:2318
bool areArgsDestroyedLeftToRightInCallee() const
Are arguments to a call destroyed left to right in the callee? This is a fundamental language change...
Definition: TargetCXXABI.h:216
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2085
bool isListInitialization() const
Whether this constructor call was written as list-initialization.
Definition: ExprCXX.h:1317
void InitializeVTablePointers(const CXXRecordDecl *ClassDecl)
Definition: CGClass.cpp:2502
const Type * getBaseClass() const
If this is a base class initializer, returns the type of the base class.
Definition: DeclCXX.cpp:2014
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2504
void EmitAggregateCopy(Address DestPtr, Address SrcPtr, QualType EltTy, bool isVolatile=false, bool isAssignment=false)
EmitAggregateCopy - Emit an aggregate copy.
Definition: CGExprAgg.cpp:1544
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
Definition: DeclCXX.cpp:1861
bool isBitField() const
Definition: CGValue.h:251
bool hasObjCLifetime() const
Definition: Type.h:340
bool isDestroyingOperatorDelete() const
Determine whether this is a destroying operator delete.
Definition: Decl.cpp:2765
ConstEvaluatedExprVisitor - This class visits &#39;const Expr *&#39;s.
CharUnits getVBaseAlignment(CharUnits DerivedAlign, const CXXRecordDecl *Derived, const CXXRecordDecl *VBase)
Returns the assumed alignment of a virtual base of a class.
Definition: CGClass.cpp:55
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type. ...
Definition: CGExprAgg.cpp:1522
JumpDest ReturnBlock
ReturnBlock - Unified return block.
const FunctionDecl * getOperatorDelete() const
Definition: DeclCXX.h:2652
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3978
StructorType getFromCtorType(CXXCtorType T)
Definition: CodeGenTypes.h:77
CodeGenTypes & getTypes() const
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2172
Address getBitFieldAddress() const
Definition: CGValue.h:352
IndirectFieldDecl * getIndirectMember() const
Definition: DeclCXX.h:2319
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:52
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Definition: ASTContext.h:2011
llvm::Constant * GetNonVirtualBaseClassOffset(const CXXRecordDecl *ClassDecl, CastExpr::path_const_iterator PathBegin, CastExpr::path_const_iterator PathEnd)
Returns the offset from a derived class to a class.
Definition: CGClass.cpp:177
Opcode getOpcode() const
Definition: Expr.h:1741
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1365
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:436
Represents a base class of a C++ class.
Definition: DeclCXX.h:191
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2007
VPtrsVector getVTablePointers(const CXXRecordDecl *VTableClass)
Definition: CGClass.cpp:2434
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2174
A template argument list.
Definition: DeclTemplate.h:210
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2387
static void EmitMemberInitializer(CodeGenFunction &CGF, const CXXRecordDecl *ClassDecl, CXXCtorInitializer *MemberInit, const CXXConstructorDecl *Constructor, FunctionArgList &Args)
Definition: CGClass.cpp:602
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299
bool isVoidType() const
Definition: Type.h:6171
unsigned getBuiltinID() const
Returns a value indicating whether this function corresponds to a builtin function.
Definition: Decl.cpp:2852
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5747
static bool IsConstructorDelegationValid(const CXXConstructorDecl *Ctor)
Checks whether the given constructor is a valid subject for the complete-to-base constructor delegati...
Definition: CGClass.cpp:694
CharUnits getNonVirtualSize() const
getNonVirtualSize - Get the non-virtual size (in chars) of an object, which is the size of the object...
Definition: RecordLayout.h:193
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:265
void EmitVTablePtrCheckForCall(const CXXRecordDecl *RD, llvm::Value *VTable, CFITypeCheckKind TCK, SourceLocation Loc)
EmitVTablePtrCheckForCall - Virtual method MD is being called via VTable.
Definition: CGClass.cpp:2586
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2209
CharUnits computeNonVirtualBaseClassOffset(const CXXRecordDecl *DerivedClass, CastExpr::path_const_iterator Start, CastExpr::path_const_iterator End)
Definition: CGClass.cpp:149
static bool isInitializerOfDynamicClass(const CXXCtorInitializer *BaseInit)
Definition: CGClass.cpp:1232
bool hasVolatile() const
Definition: Type.h:276
CGCXXABI & getCXXABI() const
std::string getQualifiedNameAsString() const
Definition: Decl.cpp:1471
static Address ApplyNonVirtualAndVirtualOffset(CodeGenFunction &CGF, Address addr, CharUnits nonVirtualOffset, llvm::Value *virtualOffset, const CXXRecordDecl *derivedClass, const CXXRecordDecl *nearestVBase)
Definition: CGClass.cpp:227
Struct with all informations about dynamic [sub]class needed to set vptr.
static RValue get(llvm::Value *V)
Definition: CGValue.h:86
bool isUnion() const
Definition: Decl.h:3159
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:3774
void EmitDestructorBody(FunctionArgList &Args)
EmitDestructorBody - Emits the body of the current destructor.
Definition: CGClass.cpp:1391
void EmitBranchThroughCleanup(JumpDest Dest)
EmitBranchThroughCleanup - Emit a branch from the current insert block through the normal cleanup han...
Definition: CGCleanup.cpp:1034
QualType getType() const
Definition: Decl.h:639
unsigned getNumArgs() const
Definition: ExprCXX.h:1362
LValue - This represents an lvalue references.
Definition: CGValue.h:167
Information for lazily generating a cleanup.
Definition: EHScopeStack.h:147
static bool HasTrivialDestructorBody(ASTContext &Context, const CXXRecordDecl *BaseClassDecl, const CXXRecordDecl *MostDerivedClassDecl)
Definition: CGClass.cpp:1310
Notes how many arguments were added to the beginning (Prefix) and ending (Suffix) of an arg list...
Definition: CGCXXABI.h:300
const LangOptions & getLangOpts() const
unsigned getNumParams() const
getNumParams - Return the number of parameters this function must have based on its FunctionType...
Definition: Decl.cpp:2906
const CGRecordLayout & getCGRecordLayout(const RecordDecl *)
getCGRecordLayout - Return record layout info for the given record decl.
Address GetAddressOfBaseClass(Address Value, const CXXRecordDecl *Derived, CastExpr::path_const_iterator PathBegin, CastExpr::path_const_iterator PathEnd, bool NullCheckValue, SourceLocation Loc)
GetAddressOfBaseClass - This function will add the necessary delta to the load of &#39;this&#39; and returns ...
Definition: CGClass.cpp:267
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:182
const LangOptions & getLangOpts() const
Definition: ASTContext.h:688
base_class_range vbases()
Definition: DeclCXX.h:790
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2620
Declaration of a template function.
Definition: DeclTemplate.h:967
static bool FieldHasTrivialDestructorBody(ASTContext &Context, const FieldDecl *Field)
Definition: CGClass.cpp:1353
llvm::Value * EmitVTableTypeCheckedLoad(const CXXRecordDecl *RD, llvm::Value *VTable, uint64_t VTableByteOffset)
Emit a type checked load from the given vtable.
Definition: CGClass.cpp:2726
bool isScalar() const
Definition: CGValue.h:52
QualType getPointeeType() const
Definition: Type.h:2524
Structure with information about how a bitfield should be accessed.
void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty)
method_range methods() const
Definition: DeclCXX.h:815
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:290