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