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