blob: 0853d6aa1fb132421125d2101f09391979e26893 [file] [log] [blame]
Hans Wennborgdcfba332015-10-06 23:40:43 +00001//===--- CGClass.cpp - Emit LLVM Code for C++ classes -----------*- C++ -*-===//
Anders Carlsson9a57c5a2009-09-12 04:27:24 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This contains code dealing with C++ code generation of classes
11//
12//===----------------------------------------------------------------------===//
13
Eli Friedman2495ab02012-02-25 02:48:22 +000014#include "CGBlocks.h"
Chandler Carruth5553d0d2014-01-07 11:51:46 +000015#include "CGCXXABI.h"
Devang Pateld76c1db2010-08-11 21:04:37 +000016#include "CGDebugInfo.h"
Lang Hamesbf122742013-02-17 07:22:09 +000017#include "CGRecordLayout.h"
Anders Carlsson9a57c5a2009-09-12 04:27:24 +000018#include "CodeGenFunction.h"
Anders Carlssonc6d171e2009-10-06 22:43:30 +000019#include "clang/AST/CXXInheritance.h"
Faisal Vali571df122013-09-29 08:45:24 +000020#include "clang/AST/DeclTemplate.h"
John McCall769250e2010-09-17 02:31:44 +000021#include "clang/AST/EvaluatedExprVisitor.h"
Anders Carlsson9a57c5a2009-09-12 04:27:24 +000022#include "clang/AST/RecordLayout.h"
John McCallb81884d2010-02-19 09:25:03 +000023#include "clang/AST/StmtCXX.h"
Lang Hamesbf122742013-02-17 07:22:09 +000024#include "clang/Basic/TargetBuiltins.h"
Mark Laceya8e7df32013-10-30 21:53:58 +000025#include "clang/CodeGen/CGFunctionInfo.h"
Devang Patelb6ed3692011-02-22 20:55:26 +000026#include "clang/Frontend/CodeGenOptions.h"
Peter Collingbournea4ccff32015-02-20 20:30:56 +000027#include "llvm/IR/Intrinsics.h"
Piotr Padlewski4b1ac722015-09-15 21:46:55 +000028#include "llvm/IR/Metadata.h"
Peter Collingbournedc134532016-01-16 00:31:22 +000029#include "llvm/Transforms/Utils/SanitizerStats.h"
Anders Carlssonc6d171e2009-10-06 22:43:30 +000030
Anders Carlsson9a57c5a2009-09-12 04:27:24 +000031using namespace clang;
32using namespace CodeGen;
33
John McCall7f416cc2015-09-08 08:05:57 +000034/// Return the best known alignment for an unknown pointer to a
35/// particular class.
36CharUnits CodeGenModule::getClassPointerAlignment(const CXXRecordDecl *RD) {
37 if (!RD->isCompleteDefinition())
38 return CharUnits::One(); // Hopefully won't be used anywhere.
39
40 auto &layout = getContext().getASTRecordLayout(RD);
41
42 // If the class is final, then we know that the pointer points to an
43 // object of that type and can use the full alignment.
44 if (RD->hasAttr<FinalAttr>()) {
45 return layout.getAlignment();
46
47 // Otherwise, we have to assume it could be a subclass.
48 } else {
49 return layout.getNonVirtualAlignment();
50 }
51}
52
53/// Return the best known alignment for a pointer to a virtual base,
54/// given the alignment of a pointer to the derived class.
55CharUnits CodeGenModule::getVBaseAlignment(CharUnits actualDerivedAlign,
56 const CXXRecordDecl *derivedClass,
57 const CXXRecordDecl *vbaseClass) {
58 // The basic idea here is that an underaligned derived pointer might
59 // indicate an underaligned base pointer.
60
61 assert(vbaseClass->isCompleteDefinition());
62 auto &baseLayout = getContext().getASTRecordLayout(vbaseClass);
63 CharUnits expectedVBaseAlign = baseLayout.getNonVirtualAlignment();
64
65 return getDynamicOffsetAlignment(actualDerivedAlign, derivedClass,
66 expectedVBaseAlign);
67}
68
69CharUnits
70CodeGenModule::getDynamicOffsetAlignment(CharUnits actualBaseAlign,
71 const CXXRecordDecl *baseDecl,
72 CharUnits expectedTargetAlign) {
73 // If the base is an incomplete type (which is, alas, possible with
74 // member pointers), be pessimistic.
75 if (!baseDecl->isCompleteDefinition())
76 return std::min(actualBaseAlign, expectedTargetAlign);
77
78 auto &baseLayout = getContext().getASTRecordLayout(baseDecl);
79 CharUnits expectedBaseAlign = baseLayout.getNonVirtualAlignment();
80
81 // If the class is properly aligned, assume the target offset is, too.
82 //
83 // This actually isn't necessarily the right thing to do --- if the
84 // class is a complete object, but it's only properly aligned for a
85 // base subobject, then the alignments of things relative to it are
86 // probably off as well. (Note that this requires the alignment of
87 // the target to be greater than the NV alignment of the derived
88 // class.)
89 //
90 // However, our approach to this kind of under-alignment can only
91 // ever be best effort; after all, we're never going to propagate
92 // alignments through variables or parameters. Note, in particular,
93 // that constructing a polymorphic type in an address that's less
94 // than pointer-aligned will generally trap in the constructor,
95 // unless we someday add some sort of attribute to change the
96 // assumed alignment of 'this'. So our goal here is pretty much
97 // just to allow the user to explicitly say that a pointer is
Eric Christopherd160c502016-01-29 01:35:53 +000098 // under-aligned and then safely access its fields and vtables.
John McCall7f416cc2015-09-08 08:05:57 +000099 if (actualBaseAlign >= expectedBaseAlign) {
100 return expectedTargetAlign;
101 }
102
103 // Otherwise, we might be offset by an arbitrary multiple of the
104 // actual alignment. The correct adjustment is to take the min of
105 // the two alignments.
106 return std::min(actualBaseAlign, expectedTargetAlign);
107}
108
109Address CodeGenFunction::LoadCXXThisAddress() {
110 assert(CurFuncDecl && "loading 'this' without a func declaration?");
111 assert(isa<CXXMethodDecl>(CurFuncDecl));
112
113 // Lazily compute CXXThisAlignment.
114 if (CXXThisAlignment.isZero()) {
115 // Just use the best known alignment for the parent.
116 // TODO: if we're currently emitting a complete-object ctor/dtor,
117 // we can always use the complete-object alignment.
118 auto RD = cast<CXXMethodDecl>(CurFuncDecl)->getParent();
119 CXXThisAlignment = CGM.getClassPointerAlignment(RD);
120 }
121
122 return Address(LoadCXXThis(), CXXThisAlignment);
123}
124
125/// Emit the address of a field using a member data pointer.
126///
127/// \param E Only used for emergency diagnostics
128Address
129CodeGenFunction::EmitCXXMemberDataPointerAddress(const Expr *E, Address base,
130 llvm::Value *memberPtr,
131 const MemberPointerType *memberPtrType,
132 AlignmentSource *alignSource) {
133 // Ask the ABI to compute the actual address.
134 llvm::Value *ptr =
135 CGM.getCXXABI().EmitMemberDataPointerAddress(*this, E, base,
136 memberPtr, memberPtrType);
137
138 QualType memberType = memberPtrType->getPointeeType();
139 CharUnits memberAlign = getNaturalTypeAlignment(memberType, alignSource);
140 memberAlign =
141 CGM.getDynamicOffsetAlignment(base.getAlignment(),
142 memberPtrType->getClass()->getAsCXXRecordDecl(),
143 memberAlign);
144 return Address(ptr, memberAlign);
145}
146
David Majnemerc1709d32015-06-23 07:31:11 +0000147CharUnits CodeGenModule::computeNonVirtualBaseClassOffset(
148 const CXXRecordDecl *DerivedClass, CastExpr::path_const_iterator Start,
149 CastExpr::path_const_iterator End) {
Ken Dycka1a4ae32011-03-22 00:53:26 +0000150 CharUnits Offset = CharUnits::Zero();
Justin Bogner1cd11f12015-05-20 15:53:59 +0000151
David Majnemerc1709d32015-06-23 07:31:11 +0000152 const ASTContext &Context = getContext();
Anders Carlssond829a022010-04-24 21:06:20 +0000153 const CXXRecordDecl *RD = DerivedClass;
Justin Bogner1cd11f12015-05-20 15:53:59 +0000154
John McCallcf142162010-08-07 06:22:56 +0000155 for (CastExpr::path_const_iterator I = Start; I != End; ++I) {
Anders Carlssond829a022010-04-24 21:06:20 +0000156 const CXXBaseSpecifier *Base = *I;
157 assert(!Base->isVirtual() && "Should not see virtual bases here!");
158
159 // Get the layout.
160 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
Justin Bogner1cd11f12015-05-20 15:53:59 +0000161
162 const CXXRecordDecl *BaseDecl =
Anders Carlssond829a022010-04-24 21:06:20 +0000163 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Justin Bogner1cd11f12015-05-20 15:53:59 +0000164
Anders Carlssond829a022010-04-24 21:06:20 +0000165 // Add the offset.
Ken Dycka1a4ae32011-03-22 00:53:26 +0000166 Offset += Layout.getBaseClassOffset(BaseDecl);
Justin Bogner1cd11f12015-05-20 15:53:59 +0000167
Anders Carlssond829a022010-04-24 21:06:20 +0000168 RD = BaseDecl;
169 }
Justin Bogner1cd11f12015-05-20 15:53:59 +0000170
Ken Dycka1a4ae32011-03-22 00:53:26 +0000171 return Offset;
Anders Carlssond829a022010-04-24 21:06:20 +0000172}
Anders Carlsson9a57c5a2009-09-12 04:27:24 +0000173
Anders Carlsson9150a2a2009-09-29 03:13:20 +0000174llvm::Constant *
Anders Carlsson8a64c1c2010-04-24 21:23:59 +0000175CodeGenModule::GetNonVirtualBaseClassOffset(const CXXRecordDecl *ClassDecl,
John McCallcf142162010-08-07 06:22:56 +0000176 CastExpr::path_const_iterator PathBegin,
177 CastExpr::path_const_iterator PathEnd) {
178 assert(PathBegin != PathEnd && "Base path should not be empty!");
Anders Carlsson8a64c1c2010-04-24 21:23:59 +0000179
Justin Bogner1cd11f12015-05-20 15:53:59 +0000180 CharUnits Offset =
David Majnemerc1709d32015-06-23 07:31:11 +0000181 computeNonVirtualBaseClassOffset(ClassDecl, PathBegin, PathEnd);
Ken Dycka1a4ae32011-03-22 00:53:26 +0000182 if (Offset.isZero())
Craig Topper8a13c412014-05-21 05:09:00 +0000183 return nullptr;
184
Justin Bogner1cd11f12015-05-20 15:53:59 +0000185 llvm::Type *PtrDiffTy =
Anders Carlsson8a64c1c2010-04-24 21:23:59 +0000186 Types.ConvertType(getContext().getPointerDiffType());
Justin Bogner1cd11f12015-05-20 15:53:59 +0000187
Ken Dycka1a4ae32011-03-22 00:53:26 +0000188 return llvm::ConstantInt::get(PtrDiffTy, Offset.getQuantity());
Anders Carlsson9150a2a2009-09-29 03:13:20 +0000189}
190
Anders Carlssonc4ba0cd2010-04-24 23:01:49 +0000191/// Gets the address of a direct base class within a complete object.
John McCall6ce74722010-02-16 04:15:37 +0000192/// This should only be used for (1) non-virtual bases or (2) virtual bases
193/// when the type is known to be complete (e.g. in complete destructors).
194///
195/// The object pointed to by 'This' is assumed to be non-null.
John McCall7f416cc2015-09-08 08:05:57 +0000196Address
197CodeGenFunction::GetAddressOfDirectBaseInCompleteClass(Address This,
Anders Carlssonc4ba0cd2010-04-24 23:01:49 +0000198 const CXXRecordDecl *Derived,
199 const CXXRecordDecl *Base,
200 bool BaseIsVirtual) {
John McCall6ce74722010-02-16 04:15:37 +0000201 // 'this' must be a pointer (in some address space) to Derived.
John McCall7f416cc2015-09-08 08:05:57 +0000202 assert(This.getElementType() == ConvertType(Derived));
John McCall6ce74722010-02-16 04:15:37 +0000203
204 // Compute the offset of the virtual base.
Ken Dyck6aa767c2011-03-22 01:21:15 +0000205 CharUnits Offset;
John McCall6ce74722010-02-16 04:15:37 +0000206 const ASTRecordLayout &Layout = getContext().getASTRecordLayout(Derived);
Anders Carlssonc4ba0cd2010-04-24 23:01:49 +0000207 if (BaseIsVirtual)
Ken Dyck6aa767c2011-03-22 01:21:15 +0000208 Offset = Layout.getVBaseClassOffset(Base);
John McCall6ce74722010-02-16 04:15:37 +0000209 else
Ken Dyck6aa767c2011-03-22 01:21:15 +0000210 Offset = Layout.getBaseClassOffset(Base);
John McCall6ce74722010-02-16 04:15:37 +0000211
212 // Shift and cast down to the base type.
213 // TODO: for complete types, this should be possible with a GEP.
John McCall7f416cc2015-09-08 08:05:57 +0000214 Address V = This;
215 if (!Offset.isZero()) {
216 V = Builder.CreateElementBitCast(V, Int8Ty);
217 V = Builder.CreateConstInBoundsByteGEP(V, Offset);
John McCall6ce74722010-02-16 04:15:37 +0000218 }
John McCall7f416cc2015-09-08 08:05:57 +0000219 V = Builder.CreateElementBitCast(V, ConvertType(Base));
John McCall6ce74722010-02-16 04:15:37 +0000220
221 return V;
Anders Carlssone87fae92010-03-28 19:40:00 +0000222}
John McCall6ce74722010-02-16 04:15:37 +0000223
John McCall7f416cc2015-09-08 08:05:57 +0000224static Address
225ApplyNonVirtualAndVirtualOffset(CodeGenFunction &CGF, Address addr,
John McCall13a39c62012-08-01 05:04:58 +0000226 CharUnits nonVirtualOffset,
John McCall7f416cc2015-09-08 08:05:57 +0000227 llvm::Value *virtualOffset,
228 const CXXRecordDecl *derivedClass,
229 const CXXRecordDecl *nearestVBase) {
John McCall13a39c62012-08-01 05:04:58 +0000230 // Assert that we have something to do.
Craig Topper8a13c412014-05-21 05:09:00 +0000231 assert(!nonVirtualOffset.isZero() || virtualOffset != nullptr);
John McCall13a39c62012-08-01 05:04:58 +0000232
233 // Compute the offset from the static and dynamic components.
234 llvm::Value *baseOffset;
235 if (!nonVirtualOffset.isZero()) {
236 baseOffset = llvm::ConstantInt::get(CGF.PtrDiffTy,
237 nonVirtualOffset.getQuantity());
238 if (virtualOffset) {
239 baseOffset = CGF.Builder.CreateAdd(virtualOffset, baseOffset);
240 }
241 } else {
242 baseOffset = virtualOffset;
243 }
Justin Bogner1cd11f12015-05-20 15:53:59 +0000244
Anders Carlsson53cebd12010-04-20 16:03:35 +0000245 // Apply the base offset.
John McCall7f416cc2015-09-08 08:05:57 +0000246 llvm::Value *ptr = addr.getPointer();
John McCall13a39c62012-08-01 05:04:58 +0000247 ptr = CGF.Builder.CreateBitCast(ptr, CGF.Int8PtrTy);
248 ptr = CGF.Builder.CreateInBoundsGEP(ptr, baseOffset, "add.ptr");
John McCall7f416cc2015-09-08 08:05:57 +0000249
250 // If we have a virtual component, the alignment of the result will
251 // be relative only to the known alignment of that vbase.
252 CharUnits alignment;
253 if (virtualOffset) {
254 assert(nearestVBase && "virtual offset without vbase?");
255 alignment = CGF.CGM.getVBaseAlignment(addr.getAlignment(),
256 derivedClass, nearestVBase);
257 } else {
258 alignment = addr.getAlignment();
259 }
260 alignment = alignment.alignmentAtOffset(nonVirtualOffset);
261
262 return Address(ptr, alignment);
Anders Carlsson53cebd12010-04-20 16:03:35 +0000263}
264
John McCall7f416cc2015-09-08 08:05:57 +0000265Address CodeGenFunction::GetAddressOfBaseClass(
266 Address Value, const CXXRecordDecl *Derived,
Alexey Samsonoveb47d8a2014-10-13 23:59:00 +0000267 CastExpr::path_const_iterator PathBegin,
268 CastExpr::path_const_iterator PathEnd, bool NullCheckValue,
269 SourceLocation Loc) {
John McCallcf142162010-08-07 06:22:56 +0000270 assert(PathBegin != PathEnd && "Base path should not be empty!");
Anders Carlssond829a022010-04-24 21:06:20 +0000271
John McCallcf142162010-08-07 06:22:56 +0000272 CastExpr::path_const_iterator Start = PathBegin;
Craig Topper8a13c412014-05-21 05:09:00 +0000273 const CXXRecordDecl *VBase = nullptr;
274
John McCall13a39c62012-08-01 05:04:58 +0000275 // Sema has done some convenient canonicalization here: if the
276 // access path involved any virtual steps, the conversion path will
277 // *start* with a step down to the correct virtual base subobject,
278 // and hence will not require any further steps.
Anders Carlssond829a022010-04-24 21:06:20 +0000279 if ((*Start)->isVirtual()) {
Justin Bogner1cd11f12015-05-20 15:53:59 +0000280 VBase =
Anders Carlssond829a022010-04-24 21:06:20 +0000281 cast<CXXRecordDecl>((*Start)->getType()->getAs<RecordType>()->getDecl());
282 ++Start;
283 }
John McCall13a39c62012-08-01 05:04:58 +0000284
285 // Compute the static offset of the ultimate destination within its
286 // allocating subobject (the virtual base, if there is one, or else
287 // the "complete" object that we see).
David Majnemerc1709d32015-06-23 07:31:11 +0000288 CharUnits NonVirtualOffset = CGM.computeNonVirtualBaseClassOffset(
289 VBase ? VBase : Derived, Start, PathEnd);
Anders Carlssond829a022010-04-24 21:06:20 +0000290
John McCall13a39c62012-08-01 05:04:58 +0000291 // If there's a virtual step, we can sometimes "devirtualize" it.
292 // For now, that's limited to when the derived type is final.
293 // TODO: "devirtualize" this for accesses to known-complete objects.
294 if (VBase && Derived->hasAttr<FinalAttr>()) {
295 const ASTRecordLayout &layout = getContext().getASTRecordLayout(Derived);
296 CharUnits vBaseOffset = layout.getVBaseClassOffset(VBase);
297 NonVirtualOffset += vBaseOffset;
Craig Topper8a13c412014-05-21 05:09:00 +0000298 VBase = nullptr; // we no longer have a virtual step
John McCall13a39c62012-08-01 05:04:58 +0000299 }
300
Anders Carlssond829a022010-04-24 21:06:20 +0000301 // Get the base pointer type.
Justin Bogner1cd11f12015-05-20 15:53:59 +0000302 llvm::Type *BasePtrTy =
John McCallcf142162010-08-07 06:22:56 +0000303 ConvertType((PathEnd[-1])->getType())->getPointerTo();
John McCall13a39c62012-08-01 05:04:58 +0000304
Alexey Samsonoveb47d8a2014-10-13 23:59:00 +0000305 QualType DerivedTy = getContext().getRecordType(Derived);
John McCall7f416cc2015-09-08 08:05:57 +0000306 CharUnits DerivedAlign = CGM.getClassPointerAlignment(Derived);
Alexey Samsonoveb47d8a2014-10-13 23:59:00 +0000307
John McCall13a39c62012-08-01 05:04:58 +0000308 // If the static offset is zero and we don't have a virtual step,
309 // just do a bitcast; null checks are unnecessary.
Ken Dycka1a4ae32011-03-22 00:53:26 +0000310 if (NonVirtualOffset.isZero() && !VBase) {
Alexey Samsonoveb47d8a2014-10-13 23:59:00 +0000311 if (sanitizePerformTypeCheck()) {
John McCall7f416cc2015-09-08 08:05:57 +0000312 EmitTypeCheck(TCK_Upcast, Loc, Value.getPointer(),
313 DerivedTy, DerivedAlign, !NullCheckValue);
Alexey Samsonoveb47d8a2014-10-13 23:59:00 +0000314 }
Anders Carlssond829a022010-04-24 21:06:20 +0000315 return Builder.CreateBitCast(Value, BasePtrTy);
Craig Topper8a13c412014-05-21 05:09:00 +0000316 }
John McCall13a39c62012-08-01 05:04:58 +0000317
Craig Topper8a13c412014-05-21 05:09:00 +0000318 llvm::BasicBlock *origBB = nullptr;
319 llvm::BasicBlock *endBB = nullptr;
320
John McCall13a39c62012-08-01 05:04:58 +0000321 // Skip over the offset (and the vtable load) if we're supposed to
322 // null-check the pointer.
Anders Carlssond829a022010-04-24 21:06:20 +0000323 if (NullCheckValue) {
John McCall13a39c62012-08-01 05:04:58 +0000324 origBB = Builder.GetInsertBlock();
325 llvm::BasicBlock *notNullBB = createBasicBlock("cast.notnull");
326 endBB = createBasicBlock("cast.end");
Justin Bogner1cd11f12015-05-20 15:53:59 +0000327
John McCall7f416cc2015-09-08 08:05:57 +0000328 llvm::Value *isNull = Builder.CreateIsNull(Value.getPointer());
John McCall13a39c62012-08-01 05:04:58 +0000329 Builder.CreateCondBr(isNull, endBB, notNullBB);
330 EmitBlock(notNullBB);
Anders Carlssond829a022010-04-24 21:06:20 +0000331 }
332
Alexey Samsonoveb47d8a2014-10-13 23:59:00 +0000333 if (sanitizePerformTypeCheck()) {
John McCall7f416cc2015-09-08 08:05:57 +0000334 EmitTypeCheck(VBase ? TCK_UpcastToVirtualBase : TCK_Upcast, Loc,
335 Value.getPointer(), DerivedTy, DerivedAlign, true);
Alexey Samsonoveb47d8a2014-10-13 23:59:00 +0000336 }
337
John McCall13a39c62012-08-01 05:04:58 +0000338 // Compute the virtual offset.
Craig Topper8a13c412014-05-21 05:09:00 +0000339 llvm::Value *VirtualOffset = nullptr;
Anders Carlssona376b532011-01-29 03:18:56 +0000340 if (VBase) {
Reid Klecknerd8cbeec2013-05-29 18:02:47 +0000341 VirtualOffset =
342 CGM.getCXXABI().GetVirtualBaseClassOffset(*this, Value, Derived, VBase);
Anders Carlssona376b532011-01-29 03:18:56 +0000343 }
Anders Carlssond829a022010-04-24 21:06:20 +0000344
John McCall13a39c62012-08-01 05:04:58 +0000345 // Apply both offsets.
John McCall7f416cc2015-09-08 08:05:57 +0000346 Value = ApplyNonVirtualAndVirtualOffset(*this, Value, NonVirtualOffset,
347 VirtualOffset, Derived, VBase);
Justin Bogner1cd11f12015-05-20 15:53:59 +0000348
John McCall13a39c62012-08-01 05:04:58 +0000349 // Cast to the destination type.
Anders Carlssond829a022010-04-24 21:06:20 +0000350 Value = Builder.CreateBitCast(Value, BasePtrTy);
John McCall13a39c62012-08-01 05:04:58 +0000351
352 // Build a phi if we needed a null check.
Anders Carlssond829a022010-04-24 21:06:20 +0000353 if (NullCheckValue) {
John McCall13a39c62012-08-01 05:04:58 +0000354 llvm::BasicBlock *notNullBB = Builder.GetInsertBlock();
355 Builder.CreateBr(endBB);
356 EmitBlock(endBB);
Justin Bogner1cd11f12015-05-20 15:53:59 +0000357
John McCall13a39c62012-08-01 05:04:58 +0000358 llvm::PHINode *PHI = Builder.CreatePHI(BasePtrTy, 2, "cast.result");
John McCall7f416cc2015-09-08 08:05:57 +0000359 PHI->addIncoming(Value.getPointer(), notNullBB);
John McCall13a39c62012-08-01 05:04:58 +0000360 PHI->addIncoming(llvm::Constant::getNullValue(BasePtrTy), origBB);
John McCall7f416cc2015-09-08 08:05:57 +0000361 Value = Address(PHI, Value.getAlignment());
Anders Carlssond829a022010-04-24 21:06:20 +0000362 }
Justin Bogner1cd11f12015-05-20 15:53:59 +0000363
Anders Carlssond829a022010-04-24 21:06:20 +0000364 return Value;
365}
366
John McCall7f416cc2015-09-08 08:05:57 +0000367Address
368CodeGenFunction::GetAddressOfDerivedClass(Address BaseAddr,
Anders Carlssonc4ba0cd2010-04-24 23:01:49 +0000369 const CXXRecordDecl *Derived,
John McCallcf142162010-08-07 06:22:56 +0000370 CastExpr::path_const_iterator PathBegin,
371 CastExpr::path_const_iterator PathEnd,
Anders Carlsson8c793172009-11-23 17:57:54 +0000372 bool NullCheckValue) {
John McCallcf142162010-08-07 06:22:56 +0000373 assert(PathBegin != PathEnd && "Base path should not be empty!");
Anders Carlsson8a64c1c2010-04-24 21:23:59 +0000374
Anders Carlsson8c793172009-11-23 17:57:54 +0000375 QualType DerivedTy =
Anders Carlssonc4ba0cd2010-04-24 23:01:49 +0000376 getContext().getCanonicalType(getContext().getTagDeclType(Derived));
Chris Lattner2192fe52011-07-18 04:24:23 +0000377 llvm::Type *DerivedPtrTy = ConvertType(DerivedTy)->getPointerTo();
Richard Smith2c5868c2013-02-13 21:18:23 +0000378
Anders Carlsson600f7372010-01-31 01:43:37 +0000379 llvm::Value *NonVirtualOffset =
John McCallcf142162010-08-07 06:22:56 +0000380 CGM.GetNonVirtualBaseClassOffset(Derived, PathBegin, PathEnd);
Justin Bogner1cd11f12015-05-20 15:53:59 +0000381
Anders Carlsson600f7372010-01-31 01:43:37 +0000382 if (!NonVirtualOffset) {
383 // No offset, we can just cast back.
John McCall7f416cc2015-09-08 08:05:57 +0000384 return Builder.CreateBitCast(BaseAddr, DerivedPtrTy);
Anders Carlsson600f7372010-01-31 01:43:37 +0000385 }
Craig Topper8a13c412014-05-21 05:09:00 +0000386
387 llvm::BasicBlock *CastNull = nullptr;
388 llvm::BasicBlock *CastNotNull = nullptr;
389 llvm::BasicBlock *CastEnd = nullptr;
390
Anders Carlsson8c793172009-11-23 17:57:54 +0000391 if (NullCheckValue) {
392 CastNull = createBasicBlock("cast.null");
393 CastNotNull = createBasicBlock("cast.notnull");
394 CastEnd = createBasicBlock("cast.end");
Justin Bogner1cd11f12015-05-20 15:53:59 +0000395
John McCall7f416cc2015-09-08 08:05:57 +0000396 llvm::Value *IsNull = Builder.CreateIsNull(BaseAddr.getPointer());
Anders Carlsson8c793172009-11-23 17:57:54 +0000397 Builder.CreateCondBr(IsNull, CastNull, CastNotNull);
398 EmitBlock(CastNotNull);
399 }
Justin Bogner1cd11f12015-05-20 15:53:59 +0000400
Anders Carlsson600f7372010-01-31 01:43:37 +0000401 // Apply the offset.
John McCall7f416cc2015-09-08 08:05:57 +0000402 llvm::Value *Value = Builder.CreateBitCast(BaseAddr.getPointer(), Int8PtrTy);
Eli Friedman87549262012-02-28 22:07:56 +0000403 Value = Builder.CreateGEP(Value, Builder.CreateNeg(NonVirtualOffset),
404 "sub.ptr");
Anders Carlsson600f7372010-01-31 01:43:37 +0000405
406 // Just cast.
407 Value = Builder.CreateBitCast(Value, DerivedPtrTy);
Anders Carlsson8c793172009-11-23 17:57:54 +0000408
John McCall7f416cc2015-09-08 08:05:57 +0000409 // Produce a PHI if we had a null-check.
Anders Carlsson8c793172009-11-23 17:57:54 +0000410 if (NullCheckValue) {
411 Builder.CreateBr(CastEnd);
412 EmitBlock(CastNull);
413 Builder.CreateBr(CastEnd);
414 EmitBlock(CastEnd);
Justin Bogner1cd11f12015-05-20 15:53:59 +0000415
Jay Foad20c0f022011-03-30 11:28:58 +0000416 llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2);
Anders Carlsson8c793172009-11-23 17:57:54 +0000417 PHI->addIncoming(Value, CastNotNull);
John McCall7f416cc2015-09-08 08:05:57 +0000418 PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()), CastNull);
Anders Carlsson8c793172009-11-23 17:57:54 +0000419 Value = PHI;
420 }
Justin Bogner1cd11f12015-05-20 15:53:59 +0000421
John McCall7f416cc2015-09-08 08:05:57 +0000422 return Address(Value, CGM.getClassPointerAlignment(Derived));
Anders Carlsson9a57c5a2009-09-12 04:27:24 +0000423}
Timur Iskhodzhanov57cbe5c2013-02-27 13:46:31 +0000424
425llvm::Value *CodeGenFunction::GetVTTParameter(GlobalDecl GD,
426 bool ForVirtualBase,
427 bool Delegating) {
Peter Collingbourne66f82e62013-06-28 20:45:28 +0000428 if (!CGM.getCXXABI().NeedsVTTParameter(GD)) {
Anders Carlssone36a6b32010-01-02 01:01:18 +0000429 // This constructor/destructor does not need a VTT parameter.
Craig Topper8a13c412014-05-21 05:09:00 +0000430 return nullptr;
Anders Carlssone36a6b32010-01-02 01:01:18 +0000431 }
Justin Bogner1cd11f12015-05-20 15:53:59 +0000432
John McCalldec348f72013-05-03 07:33:41 +0000433 const CXXRecordDecl *RD = cast<CXXMethodDecl>(CurCodeDecl)->getParent();
Anders Carlssone36a6b32010-01-02 01:01:18 +0000434 const CXXRecordDecl *Base = cast<CXXMethodDecl>(GD.getDecl())->getParent();
John McCall5c60a6f2010-02-18 19:59:28 +0000435
Anders Carlssone36a6b32010-01-02 01:01:18 +0000436 llvm::Value *VTT;
437
John McCall5c60a6f2010-02-18 19:59:28 +0000438 uint64_t SubVTTIndex;
439
Douglas Gregor61535002013-01-31 05:50:40 +0000440 if (Delegating) {
441 // If this is a delegating constructor call, just load the VTT.
Timur Iskhodzhanov57cbe5c2013-02-27 13:46:31 +0000442 return LoadCXXVTT();
Douglas Gregor61535002013-01-31 05:50:40 +0000443 } else if (RD == Base) {
444 // If the record matches the base, this is the complete ctor/dtor
445 // variant calling the base variant in a class with virtual bases.
Peter Collingbourne66f82e62013-06-28 20:45:28 +0000446 assert(!CGM.getCXXABI().NeedsVTTParameter(CurGD) &&
John McCall5c60a6f2010-02-18 19:59:28 +0000447 "doing no-op VTT offset in base dtor/ctor?");
Anders Carlsson4d205ba2010-05-02 23:33:10 +0000448 assert(!ForVirtualBase && "Can't have same class as virtual base!");
John McCall5c60a6f2010-02-18 19:59:28 +0000449 SubVTTIndex = 0;
450 } else {
Timur Iskhodzhanov57cbe5c2013-02-27 13:46:31 +0000451 const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
Justin Bogner1cd11f12015-05-20 15:53:59 +0000452 CharUnits BaseOffset = ForVirtualBase ?
453 Layout.getVBaseClassOffset(Base) :
Ken Dyck16ffcac2011-03-24 01:21:01 +0000454 Layout.getBaseClassOffset(Base);
Anders Carlsson859b3062010-05-02 23:53:25 +0000455
Justin Bogner1cd11f12015-05-20 15:53:59 +0000456 SubVTTIndex =
Timur Iskhodzhanov57cbe5c2013-02-27 13:46:31 +0000457 CGM.getVTables().getSubVTTIndex(RD, BaseSubobject(Base, BaseOffset));
John McCall5c60a6f2010-02-18 19:59:28 +0000458 assert(SubVTTIndex != 0 && "Sub-VTT index must be greater than zero!");
459 }
Justin Bogner1cd11f12015-05-20 15:53:59 +0000460
Peter Collingbourne66f82e62013-06-28 20:45:28 +0000461 if (CGM.getCXXABI().NeedsVTTParameter(CurGD)) {
Anders Carlssone36a6b32010-01-02 01:01:18 +0000462 // A VTT parameter was passed to the constructor, use it.
Timur Iskhodzhanov57cbe5c2013-02-27 13:46:31 +0000463 VTT = LoadCXXVTT();
464 VTT = Builder.CreateConstInBoundsGEP1_64(VTT, SubVTTIndex);
Anders Carlssone36a6b32010-01-02 01:01:18 +0000465 } else {
466 // We're the complete constructor, so get the VTT by name.
Timur Iskhodzhanov57cbe5c2013-02-27 13:46:31 +0000467 VTT = CGM.getVTables().GetAddrOfVTT(RD);
468 VTT = Builder.CreateConstInBoundsGEP2_64(VTT, 0, SubVTTIndex);
Anders Carlssone36a6b32010-01-02 01:01:18 +0000469 }
470
471 return VTT;
472}
473
John McCall1d987562010-07-21 01:23:41 +0000474namespace {
John McCallf99a6312010-07-21 05:30:47 +0000475 /// Call the destructor for a direct base class.
David Blaikie7e70d682015-08-18 22:40:54 +0000476 struct CallBaseDtor final : EHScopeStack::Cleanup {
John McCallf99a6312010-07-21 05:30:47 +0000477 const CXXRecordDecl *BaseClass;
478 bool BaseIsVirtual;
479 CallBaseDtor(const CXXRecordDecl *Base, bool BaseIsVirtual)
480 : BaseClass(Base), BaseIsVirtual(BaseIsVirtual) {}
John McCall1d987562010-07-21 01:23:41 +0000481
Craig Topper4f12f102014-03-12 06:41:41 +0000482 void Emit(CodeGenFunction &CGF, Flags flags) override {
John McCallf99a6312010-07-21 05:30:47 +0000483 const CXXRecordDecl *DerivedClass =
484 cast<CXXMethodDecl>(CGF.CurCodeDecl)->getParent();
485
486 const CXXDestructorDecl *D = BaseClass->getDestructor();
John McCall7f416cc2015-09-08 08:05:57 +0000487 Address Addr =
488 CGF.GetAddressOfDirectBaseInCompleteClass(CGF.LoadCXXThisAddress(),
John McCallf99a6312010-07-21 05:30:47 +0000489 DerivedClass, BaseClass,
490 BaseIsVirtual);
Douglas Gregor61535002013-01-31 05:50:40 +0000491 CGF.EmitCXXDestructorCall(D, Dtor_Base, BaseIsVirtual,
492 /*Delegating=*/false, Addr);
John McCall1d987562010-07-21 01:23:41 +0000493 }
494 };
John McCall769250e2010-09-17 02:31:44 +0000495
496 /// A visitor which checks whether an initializer uses 'this' in a
497 /// way which requires the vtable to be properly set.
Scott Douglass503fc392015-06-10 13:53:15 +0000498 struct DynamicThisUseChecker : ConstEvaluatedExprVisitor<DynamicThisUseChecker> {
499 typedef ConstEvaluatedExprVisitor<DynamicThisUseChecker> super;
John McCall769250e2010-09-17 02:31:44 +0000500
501 bool UsesThis;
502
Scott Douglass503fc392015-06-10 13:53:15 +0000503 DynamicThisUseChecker(const ASTContext &C) : super(C), UsesThis(false) {}
John McCall769250e2010-09-17 02:31:44 +0000504
505 // Black-list all explicit and implicit references to 'this'.
506 //
507 // Do we need to worry about external references to 'this' derived
508 // from arbitrary code? If so, then anything which runs arbitrary
509 // external code might potentially access the vtable.
Scott Douglass503fc392015-06-10 13:53:15 +0000510 void VisitCXXThisExpr(const CXXThisExpr *E) { UsesThis = true; }
John McCall769250e2010-09-17 02:31:44 +0000511 };
Hans Wennborgdcfba332015-10-06 23:40:43 +0000512} // end anonymous namespace
John McCall769250e2010-09-17 02:31:44 +0000513
514static bool BaseInitializerUsesThis(ASTContext &C, const Expr *Init) {
515 DynamicThisUseChecker Checker(C);
Scott Douglass503fc392015-06-10 13:53:15 +0000516 Checker.Visit(Init);
John McCall769250e2010-09-17 02:31:44 +0000517 return Checker.UsesThis;
John McCall1d987562010-07-21 01:23:41 +0000518}
519
Justin Bogner1cd11f12015-05-20 15:53:59 +0000520static void EmitBaseInitializer(CodeGenFunction &CGF,
Anders Carlssonfb404882009-12-24 22:46:43 +0000521 const CXXRecordDecl *ClassDecl,
Alexis Hunt1d792652011-01-08 20:30:50 +0000522 CXXCtorInitializer *BaseInit,
Anders Carlssonfb404882009-12-24 22:46:43 +0000523 CXXCtorType CtorType) {
524 assert(BaseInit->isBaseInitializer() &&
525 "Must have base initializer!");
526
John McCall7f416cc2015-09-08 08:05:57 +0000527 Address ThisPtr = CGF.LoadCXXThisAddress();
Justin Bogner1cd11f12015-05-20 15:53:59 +0000528
Anders Carlssonfb404882009-12-24 22:46:43 +0000529 const Type *BaseType = BaseInit->getBaseClass();
530 CXXRecordDecl *BaseClassDecl =
531 cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl());
532
Anders Carlsson1c0f8bb2010-04-12 00:51:03 +0000533 bool isBaseVirtual = BaseInit->isBaseVirtual();
Anders Carlssonfb404882009-12-24 22:46:43 +0000534
535 // The base constructor doesn't construct virtual bases.
536 if (CtorType == Ctor_Base && isBaseVirtual)
537 return;
538
John McCall769250e2010-09-17 02:31:44 +0000539 // If the initializer for the base (other than the constructor
540 // itself) accesses 'this' in any way, we need to initialize the
541 // vtables.
542 if (BaseInitializerUsesThis(CGF.getContext(), BaseInit->getInit()))
543 CGF.InitializeVTablePointers(ClassDecl);
544
John McCall6ce74722010-02-16 04:15:37 +0000545 // We can pretend to be a complete class because it only matters for
546 // virtual bases, and we only do virtual bases for complete ctors.
John McCall7f416cc2015-09-08 08:05:57 +0000547 Address V =
Anders Carlssonc4ba0cd2010-04-24 23:01:49 +0000548 CGF.GetAddressOfDirectBaseInCompleteClass(ThisPtr, ClassDecl,
John McCallf99a6312010-07-21 05:30:47 +0000549 BaseClassDecl,
550 isBaseVirtual);
John McCall8d6fc952011-08-25 20:40:09 +0000551 AggValueSlot AggSlot =
John McCall7f416cc2015-09-08 08:05:57 +0000552 AggValueSlot::forAddr(V, Qualifiers(),
John McCall8d6fc952011-08-25 20:40:09 +0000553 AggValueSlot::IsDestructed,
John McCalla5efa732011-08-25 23:04:34 +0000554 AggValueSlot::DoesNotNeedGCBarriers,
Chad Rosier615ed1a2012-03-29 17:37:10 +0000555 AggValueSlot::IsNotAliased);
John McCall7a626f62010-09-15 10:14:12 +0000556
557 CGF.EmitAggExpr(BaseInit->getInit(), AggSlot);
Justin Bogner1cd11f12015-05-20 15:53:59 +0000558
559 if (CGF.CGM.getLangOpts().Exceptions &&
Anders Carlsson08ce5ed2011-02-20 00:20:27 +0000560 !BaseClassDecl->hasTrivialDestructor())
John McCallcda666c2010-07-21 07:22:38 +0000561 CGF.EHStack.pushCleanup<CallBaseDtor>(EHCleanup, BaseClassDecl,
562 isBaseVirtual);
Anders Carlssonfb404882009-12-24 22:46:43 +0000563}
564
Douglas Gregor94f9a482010-05-05 05:51:00 +0000565static void EmitAggMemberInitializer(CodeGenFunction &CGF,
566 LValue LHS,
Eli Friedman6ae63022012-02-14 02:15:49 +0000567 Expr *Init,
John McCall7f416cc2015-09-08 08:05:57 +0000568 Address ArrayIndexVar,
Douglas Gregor94f9a482010-05-05 05:51:00 +0000569 QualType T,
Eli Friedman6ae63022012-02-14 02:15:49 +0000570 ArrayRef<VarDecl *> ArrayIndexes,
Douglas Gregor94f9a482010-05-05 05:51:00 +0000571 unsigned Index) {
Eli Friedman6ae63022012-02-14 02:15:49 +0000572 if (Index == ArrayIndexes.size()) {
Eli Friedmanc1d85b92011-12-03 00:54:26 +0000573 LValue LV = LHS;
Eli Friedmanc1d85b92011-12-03 00:54:26 +0000574
John McCall7f416cc2015-09-08 08:05:57 +0000575 if (ArrayIndexVar.isValid()) {
Richard Smithcc1b96d2013-06-12 22:31:48 +0000576 // If we have an array index variable, load it and use it as an offset.
577 // Then, increment the value.
John McCall7f416cc2015-09-08 08:05:57 +0000578 llvm::Value *Dest = LHS.getPointer();
Richard Smithcc1b96d2013-06-12 22:31:48 +0000579 llvm::Value *ArrayIndex = CGF.Builder.CreateLoad(ArrayIndexVar);
580 Dest = CGF.Builder.CreateInBoundsGEP(Dest, ArrayIndex, "destaddress");
581 llvm::Value *Next = llvm::ConstantInt::get(ArrayIndex->getType(), 1);
582 Next = CGF.Builder.CreateAdd(ArrayIndex, Next, "inc");
583 CGF.Builder.CreateStore(Next, ArrayIndexVar);
Sebastian Redl4e04dd12012-02-19 15:41:54 +0000584
Richard Smithcc1b96d2013-06-12 22:31:48 +0000585 // Update the LValue.
John McCall7f416cc2015-09-08 08:05:57 +0000586 CharUnits EltSize = CGF.getContext().getTypeSizeInChars(T);
587 CharUnits Align = LV.getAlignment().alignmentOfArrayElement(EltSize);
588 LV.setAddress(Address(Dest, Align));
Douglas Gregor94f9a482010-05-05 05:51:00 +0000589 }
John McCall7a626f62010-09-15 10:14:12 +0000590
Richard Smithcc1b96d2013-06-12 22:31:48 +0000591 switch (CGF.getEvaluationKind(T)) {
592 case TEK_Scalar:
Craig Topper8a13c412014-05-21 05:09:00 +0000593 CGF.EmitScalarInit(Init, /*decl*/ nullptr, LV, false);
Richard Smithcc1b96d2013-06-12 22:31:48 +0000594 break;
595 case TEK_Complex:
596 CGF.EmitComplexExprIntoLValue(Init, LV, /*isInit*/ true);
597 break;
598 case TEK_Aggregate: {
599 AggValueSlot Slot =
600 AggValueSlot::forLValue(LV,
601 AggValueSlot::IsDestructed,
602 AggValueSlot::DoesNotNeedGCBarriers,
603 AggValueSlot::IsNotAliased);
604
605 CGF.EmitAggExpr(Init, Slot);
606 break;
607 }
608 }
Sebastian Redl4e04dd12012-02-19 15:41:54 +0000609
Douglas Gregor94f9a482010-05-05 05:51:00 +0000610 return;
611 }
Richard Smithcc1b96d2013-06-12 22:31:48 +0000612
Douglas Gregor94f9a482010-05-05 05:51:00 +0000613 const ConstantArrayType *Array = CGF.getContext().getAsConstantArrayType(T);
614 assert(Array && "Array initialization without the array type?");
John McCall7f416cc2015-09-08 08:05:57 +0000615 Address IndexVar = CGF.GetAddrOfLocalVar(ArrayIndexes[Index]);
Justin Bogner1cd11f12015-05-20 15:53:59 +0000616
Douglas Gregor94f9a482010-05-05 05:51:00 +0000617 // Initialize this index variable to zero.
618 llvm::Value* Zero
John McCall7f416cc2015-09-08 08:05:57 +0000619 = llvm::Constant::getNullValue(IndexVar.getElementType());
Douglas Gregor94f9a482010-05-05 05:51:00 +0000620 CGF.Builder.CreateStore(Zero, IndexVar);
Justin Bogner1cd11f12015-05-20 15:53:59 +0000621
Douglas Gregor94f9a482010-05-05 05:51:00 +0000622 // Start the loop with a block that tests the condition.
623 llvm::BasicBlock *CondBlock = CGF.createBasicBlock("for.cond");
624 llvm::BasicBlock *AfterFor = CGF.createBasicBlock("for.end");
Justin Bogner1cd11f12015-05-20 15:53:59 +0000625
Douglas Gregor94f9a482010-05-05 05:51:00 +0000626 CGF.EmitBlock(CondBlock);
627
628 llvm::BasicBlock *ForBody = CGF.createBasicBlock("for.body");
629 // Generate: if (loop-index < number-of-elements) fall to the loop body,
630 // otherwise, go to the block after the for-loop.
631 uint64_t NumElements = Array->getSize().getZExtValue();
Douglas Gregor94f9a482010-05-05 05:51:00 +0000632 llvm::Value *Counter = CGF.Builder.CreateLoad(IndexVar);
Chris Lattner44456d22010-05-06 06:35:23 +0000633 llvm::Value *NumElementsPtr =
634 llvm::ConstantInt::get(Counter->getType(), NumElements);
Douglas Gregor94f9a482010-05-05 05:51:00 +0000635 llvm::Value *IsLess = CGF.Builder.CreateICmpULT(Counter, NumElementsPtr,
636 "isless");
Justin Bogner1cd11f12015-05-20 15:53:59 +0000637
Douglas Gregor94f9a482010-05-05 05:51:00 +0000638 // If the condition is true, execute the body.
639 CGF.Builder.CreateCondBr(IsLess, ForBody, AfterFor);
640
641 CGF.EmitBlock(ForBody);
642 llvm::BasicBlock *ContinueBlock = CGF.createBasicBlock("for.inc");
Richard Smithcc1b96d2013-06-12 22:31:48 +0000643
644 // Inside the loop body recurse to emit the inner loop or, eventually, the
645 // constructor call.
646 EmitAggMemberInitializer(CGF, LHS, Init, ArrayIndexVar,
647 Array->getElementType(), ArrayIndexes, Index + 1);
648
Douglas Gregor94f9a482010-05-05 05:51:00 +0000649 CGF.EmitBlock(ContinueBlock);
650
651 // Emit the increment of the loop counter.
652 llvm::Value *NextVal = llvm::ConstantInt::get(Counter->getType(), 1);
653 Counter = CGF.Builder.CreateLoad(IndexVar);
654 NextVal = CGF.Builder.CreateAdd(Counter, NextVal, "inc");
655 CGF.Builder.CreateStore(NextVal, IndexVar);
656
657 // Finally, branch back up to the condition for the next iteration.
658 CGF.EmitBranch(CondBlock);
659
660 // Emit the fall-through block.
661 CGF.EmitBlock(AfterFor, true);
662}
John McCall1d987562010-07-21 01:23:41 +0000663
Richard Smith419bd092015-04-29 19:26:57 +0000664static bool isMemcpyEquivalentSpecialMember(const CXXMethodDecl *D) {
665 auto *CD = dyn_cast<CXXConstructorDecl>(D);
666 if (!(CD && CD->isCopyOrMoveConstructor()) &&
667 !D->isCopyAssignmentOperator() && !D->isMoveAssignmentOperator())
668 return false;
669
670 // We can emit a memcpy for a trivial copy or move constructor/assignment.
671 if (D->isTrivial() && !D->getParent()->mayInsertExtraPadding())
672 return true;
673
674 // We *must* emit a memcpy for a defaulted union copy or move op.
675 if (D->getParent()->isUnion() && D->isDefaulted())
676 return true;
677
678 return false;
679}
680
Alexey Bataev152c71f2015-07-14 07:55:48 +0000681static void EmitLValueForAnyFieldInitialization(CodeGenFunction &CGF,
682 CXXCtorInitializer *MemberInit,
683 LValue &LHS) {
684 FieldDecl *Field = MemberInit->getAnyMember();
685 if (MemberInit->isIndirectMemberInitializer()) {
686 // If we are initializing an anonymous union field, drill down to the field.
687 IndirectFieldDecl *IndirectField = MemberInit->getIndirectMember();
688 for (const auto *I : IndirectField->chain())
689 LHS = CGF.EmitLValueForFieldInitialization(LHS, cast<FieldDecl>(I));
690 } else {
691 LHS = CGF.EmitLValueForFieldInitialization(LHS, Field);
692 }
693}
694
Anders Carlssonfb404882009-12-24 22:46:43 +0000695static void EmitMemberInitializer(CodeGenFunction &CGF,
696 const CXXRecordDecl *ClassDecl,
Alexis Hunt1d792652011-01-08 20:30:50 +0000697 CXXCtorInitializer *MemberInit,
Douglas Gregor94f9a482010-05-05 05:51:00 +0000698 const CXXConstructorDecl *Constructor,
699 FunctionArgList &Args) {
David Blaikiea81d4102015-01-18 00:12:58 +0000700 ApplyDebugLocation Loc(CGF, MemberInit->getSourceLocation());
Francois Pichetd583da02010-12-04 09:14:42 +0000701 assert(MemberInit->isAnyMemberInitializer() &&
Anders Carlssonfb404882009-12-24 22:46:43 +0000702 "Must have member initializer!");
Richard Smith938f40b2011-06-11 17:19:42 +0000703 assert(MemberInit->getInit() && "Must have initializer!");
Justin Bogner1cd11f12015-05-20 15:53:59 +0000704
Anders Carlssonfb404882009-12-24 22:46:43 +0000705 // non-static data member initializers.
Francois Pichetd583da02010-12-04 09:14:42 +0000706 FieldDecl *Field = MemberInit->getAnyMember();
Eli Friedman6ae63022012-02-14 02:15:49 +0000707 QualType FieldType = Field->getType();
Anders Carlssonfb404882009-12-24 22:46:43 +0000708
709 llvm::Value *ThisPtr = CGF.LoadCXXThis();
Eli Friedman7f1ff602012-04-16 03:54:45 +0000710 QualType RecordTy = CGF.getContext().getTypeDeclType(ClassDecl);
Eli Friedmanf6d21842012-08-08 03:51:37 +0000711 LValue LHS = CGF.MakeNaturalAlignAddrLValue(ThisPtr, RecordTy);
Eli Friedman7f1ff602012-04-16 03:54:45 +0000712
Alexey Bataev152c71f2015-07-14 07:55:48 +0000713 EmitLValueForAnyFieldInitialization(CGF, MemberInit, LHS);
Anders Carlssonfb404882009-12-24 22:46:43 +0000714
Eli Friedman6ae63022012-02-14 02:15:49 +0000715 // Special case: if we are in a copy or move constructor, and we are copying
716 // an array of PODs or classes with trivial copy constructors, ignore the
717 // AST and perform the copy we know is equivalent.
718 // FIXME: This is hacky at best... if we had a bit more explicit information
719 // in the AST, we could generalize it more easily.
720 const ConstantArrayType *Array
721 = CGF.getContext().getAsConstantArrayType(FieldType);
Jordan Rose54533f72013-08-07 16:16:48 +0000722 if (Array && Constructor->isDefaulted() &&
Eli Friedman6ae63022012-02-14 02:15:49 +0000723 Constructor->isCopyOrMoveConstructor()) {
724 QualType BaseElementTy = CGF.getContext().getBaseElementType(Array);
Richard Smith993f25a2012-11-07 23:56:21 +0000725 CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(MemberInit->getInit());
Eli Friedman6ae63022012-02-14 02:15:49 +0000726 if (BaseElementTy.isPODType(CGF.getContext()) ||
Richard Smith419bd092015-04-29 19:26:57 +0000727 (CE && isMemcpyEquivalentSpecialMember(CE->getConstructor()))) {
David Majnemer1573d732014-10-15 04:54:54 +0000728 unsigned SrcArgIndex =
729 CGF.CGM.getCXXABI().getSrcArgforCopyCtor(Constructor, Args);
Eli Friedman6ae63022012-02-14 02:15:49 +0000730 llvm::Value *SrcPtr
731 = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(Args[SrcArgIndex]));
Eli Friedman7f1ff602012-04-16 03:54:45 +0000732 LValue ThisRHSLV = CGF.MakeNaturalAlignAddrLValue(SrcPtr, RecordTy);
733 LValue Src = CGF.EmitLValueForFieldInitialization(ThisRHSLV, Field);
Justin Bogner1cd11f12015-05-20 15:53:59 +0000734
Eli Friedman6ae63022012-02-14 02:15:49 +0000735 // Copy the aggregate.
736 CGF.EmitAggregateCopy(LHS.getAddress(), Src.getAddress(), FieldType,
Chad Rosier615ed1a2012-03-29 17:37:10 +0000737 LHS.isVolatileQualified());
Alexey Bataev5d49b832015-07-08 07:31:02 +0000738 // Ensure that we destroy the objects if an exception is thrown later in
739 // the constructor.
740 QualType::DestructionKind dtorKind = FieldType.isDestructedType();
741 if (CGF.needsEHCleanup(dtorKind))
742 CGF.pushEHDestroy(dtorKind, LHS.getAddress(), FieldType);
Eli Friedman6ae63022012-02-14 02:15:49 +0000743 return;
744 }
745 }
746
747 ArrayRef<VarDecl *> ArrayIndexes;
748 if (MemberInit->getNumArrayIndices())
749 ArrayIndexes = MemberInit->getArrayIndexes();
David Blaikie66e41972015-01-14 07:38:27 +0000750 CGF.EmitInitializerForField(Field, LHS, MemberInit->getInit(), ArrayIndexes);
Eli Friedman6ae63022012-02-14 02:15:49 +0000751}
752
John McCall7f416cc2015-09-08 08:05:57 +0000753void CodeGenFunction::EmitInitializerForField(FieldDecl *Field, LValue LHS,
754 Expr *Init, ArrayRef<VarDecl *> ArrayIndexes) {
Eli Friedman6ae63022012-02-14 02:15:49 +0000755 QualType FieldType = Field->getType();
John McCall47fb9502013-03-07 21:37:08 +0000756 switch (getEvaluationKind(FieldType)) {
757 case TEK_Scalar:
John McCall31168b02011-06-15 23:02:42 +0000758 if (LHS.isSimple()) {
David Blaikie66e41972015-01-14 07:38:27 +0000759 EmitExprAsInit(Init, Field, LHS, false);
John McCall31168b02011-06-15 23:02:42 +0000760 } else {
Eli Friedman5f1a04f2012-02-14 02:31:03 +0000761 RValue RHS = RValue::get(EmitScalarExpr(Init));
762 EmitStoreThroughLValue(RHS, LHS);
John McCall31168b02011-06-15 23:02:42 +0000763 }
John McCall47fb9502013-03-07 21:37:08 +0000764 break;
765 case TEK_Complex:
David Blaikie66e41972015-01-14 07:38:27 +0000766 EmitComplexExprIntoLValue(Init, LHS, /*isInit*/ true);
John McCall47fb9502013-03-07 21:37:08 +0000767 break;
768 case TEK_Aggregate: {
John McCall7f416cc2015-09-08 08:05:57 +0000769 Address ArrayIndexVar = Address::invalid();
Eli Friedman6ae63022012-02-14 02:15:49 +0000770 if (ArrayIndexes.size()) {
Douglas Gregor94f9a482010-05-05 05:51:00 +0000771 // The LHS is a pointer to the first object we'll be constructing, as
772 // a flat array.
Eli Friedman5f1a04f2012-02-14 02:31:03 +0000773 QualType BaseElementTy = getContext().getBaseElementType(FieldType);
774 llvm::Type *BasePtr = ConvertType(BaseElementTy);
Douglas Gregor94f9a482010-05-05 05:51:00 +0000775 BasePtr = llvm::PointerType::getUnqual(BasePtr);
John McCall7f416cc2015-09-08 08:05:57 +0000776 Address BaseAddrPtr = Builder.CreateBitCast(LHS.getAddress(), BasePtr);
Eli Friedman5f1a04f2012-02-14 02:31:03 +0000777 LHS = MakeAddrLValue(BaseAddrPtr, BaseElementTy);
Justin Bogner1cd11f12015-05-20 15:53:59 +0000778
Douglas Gregor94f9a482010-05-05 05:51:00 +0000779 // Create an array index that will be used to walk over all of the
780 // objects we're constructing.
John McCall7f416cc2015-09-08 08:05:57 +0000781 ArrayIndexVar = CreateMemTemp(getContext().getSizeType(), "object.index");
782 llvm::Value *Zero =
783 llvm::Constant::getNullValue(ArrayIndexVar.getElementType());
Eli Friedman5f1a04f2012-02-14 02:31:03 +0000784 Builder.CreateStore(Zero, ArrayIndexVar);
Justin Bogner1cd11f12015-05-20 15:53:59 +0000785
Douglas Gregor94f9a482010-05-05 05:51:00 +0000786 // Emit the block variables for the array indices, if any.
Eli Friedman6ae63022012-02-14 02:15:49 +0000787 for (unsigned I = 0, N = ArrayIndexes.size(); I != N; ++I)
Eli Friedman5f1a04f2012-02-14 02:31:03 +0000788 EmitAutoVarDecl(*ArrayIndexes[I]);
Douglas Gregor94f9a482010-05-05 05:51:00 +0000789 }
Justin Bogner1cd11f12015-05-20 15:53:59 +0000790
Eli Friedman5f1a04f2012-02-14 02:31:03 +0000791 EmitAggMemberInitializer(*this, LHS, Init, ArrayIndexVar, FieldType,
Eli Friedman6ae63022012-02-14 02:15:49 +0000792 ArrayIndexes, 0);
Anders Carlssonfb404882009-12-24 22:46:43 +0000793 }
John McCall47fb9502013-03-07 21:37:08 +0000794 }
John McCall12cc42a2013-02-01 05:11:40 +0000795
796 // Ensure that we destroy this object if an exception is thrown
797 // later in the constructor.
798 QualType::DestructionKind dtorKind = FieldType.isDestructedType();
799 if (needsEHCleanup(dtorKind))
800 pushEHDestroy(dtorKind, LHS.getAddress(), FieldType);
Anders Carlssonfb404882009-12-24 22:46:43 +0000801}
802
John McCallf8ff7b92010-02-23 00:48:20 +0000803/// Checks whether the given constructor is a valid subject for the
804/// complete-to-base constructor delegation optimization, i.e.
805/// emitting the complete constructor as a simple call to the base
806/// constructor.
807static bool IsConstructorDelegationValid(const CXXConstructorDecl *Ctor) {
808
809 // Currently we disable the optimization for classes with virtual
810 // bases because (1) the addresses of parameter variables need to be
811 // consistent across all initializers but (2) the delegate function
812 // call necessarily creates a second copy of the parameter variable.
813 //
814 // The limiting example (purely theoretical AFAIK):
815 // struct A { A(int &c) { c++; } };
816 // struct B : virtual A {
817 // B(int count) : A(count) { printf("%d\n", count); }
818 // };
819 // ...although even this example could in principle be emitted as a
820 // delegation since the address of the parameter doesn't escape.
821 if (Ctor->getParent()->getNumVBases()) {
822 // TODO: white-list trivial vbase initializers. This case wouldn't
823 // be subject to the restrictions below.
824
825 // TODO: white-list cases where:
826 // - there are no non-reference parameters to the constructor
827 // - the initializers don't access any non-reference parameters
828 // - the initializers don't take the address of non-reference
829 // parameters
830 // - etc.
831 // If we ever add any of the above cases, remember that:
832 // - function-try-blocks will always blacklist this optimization
833 // - we need to perform the constructor prologue and cleanup in
834 // EmitConstructorBody.
835
836 return false;
837 }
838
839 // We also disable the optimization for variadic functions because
840 // it's impossible to "re-pass" varargs.
841 if (Ctor->getType()->getAs<FunctionProtoType>()->isVariadic())
842 return false;
843
Alexis Hunt61bc1732011-05-01 07:04:31 +0000844 // FIXME: Decide if we can do a delegation of a delegating constructor.
845 if (Ctor->isDelegatingConstructor())
846 return false;
847
John McCallf8ff7b92010-02-23 00:48:20 +0000848 return true;
849}
850
Kostya Serebryany293dc9b2014-10-16 20:54:52 +0000851// Emit code in ctor (Prologue==true) or dtor (Prologue==false)
852// to poison the extra field paddings inserted under
853// -fsanitize-address-field-padding=1|2.
854void CodeGenFunction::EmitAsanPrologueOrEpilogue(bool Prologue) {
855 ASTContext &Context = getContext();
856 const CXXRecordDecl *ClassDecl =
857 Prologue ? cast<CXXConstructorDecl>(CurGD.getDecl())->getParent()
858 : cast<CXXDestructorDecl>(CurGD.getDecl())->getParent();
859 if (!ClassDecl->mayInsertExtraPadding()) return;
860
861 struct SizeAndOffset {
862 uint64_t Size;
863 uint64_t Offset;
864 };
865
866 unsigned PtrSize = CGM.getDataLayout().getPointerSizeInBits();
867 const ASTRecordLayout &Info = Context.getASTRecordLayout(ClassDecl);
868
869 // Populate sizes and offsets of fields.
870 SmallVector<SizeAndOffset, 16> SSV(Info.getFieldCount());
871 for (unsigned i = 0, e = Info.getFieldCount(); i != e; ++i)
872 SSV[i].Offset =
873 Context.toCharUnitsFromBits(Info.getFieldOffset(i)).getQuantity();
874
875 size_t NumFields = 0;
876 for (const auto *Field : ClassDecl->fields()) {
877 const FieldDecl *D = Field;
878 std::pair<CharUnits, CharUnits> FieldInfo =
879 Context.getTypeInfoInChars(D->getType());
880 CharUnits FieldSize = FieldInfo.first;
881 assert(NumFields < SSV.size());
882 SSV[NumFields].Size = D->isBitField() ? 0 : FieldSize.getQuantity();
883 NumFields++;
884 }
885 assert(NumFields == SSV.size());
886 if (SSV.size() <= 1) return;
887
888 // We will insert calls to __asan_* run-time functions.
889 // LLVM AddressSanitizer pass may decide to inline them later.
890 llvm::Type *Args[2] = {IntPtrTy, IntPtrTy};
891 llvm::FunctionType *FTy =
892 llvm::FunctionType::get(CGM.VoidTy, Args, false);
893 llvm::Constant *F = CGM.CreateRuntimeFunction(
894 FTy, Prologue ? "__asan_poison_intra_object_redzone"
895 : "__asan_unpoison_intra_object_redzone");
896
897 llvm::Value *ThisPtr = LoadCXXThis();
898 ThisPtr = Builder.CreatePtrToInt(ThisPtr, IntPtrTy);
Kostya Serebryany64449212014-10-17 21:02:13 +0000899 uint64_t TypeSize = Info.getNonVirtualSize().getQuantity();
Kostya Serebryany293dc9b2014-10-16 20:54:52 +0000900 // For each field check if it has sufficient padding,
901 // if so (un)poison it with a call.
902 for (size_t i = 0; i < SSV.size(); i++) {
903 uint64_t AsanAlignment = 8;
904 uint64_t NextField = i == SSV.size() - 1 ? TypeSize : SSV[i + 1].Offset;
905 uint64_t PoisonSize = NextField - SSV[i].Offset - SSV[i].Size;
906 uint64_t EndOffset = SSV[i].Offset + SSV[i].Size;
907 if (PoisonSize < AsanAlignment || !SSV[i].Size ||
908 (NextField % AsanAlignment) != 0)
909 continue;
David Blaikie43f9bb72015-05-18 22:14:03 +0000910 Builder.CreateCall(
911 F, {Builder.CreateAdd(ThisPtr, Builder.getIntN(PtrSize, EndOffset)),
912 Builder.getIntN(PtrSize, PoisonSize)});
Kostya Serebryany293dc9b2014-10-16 20:54:52 +0000913 }
914}
915
John McCallb81884d2010-02-19 09:25:03 +0000916/// EmitConstructorBody - Emits the body of the current constructor.
917void CodeGenFunction::EmitConstructorBody(FunctionArgList &Args) {
Kostya Serebryany293dc9b2014-10-16 20:54:52 +0000918 EmitAsanPrologueOrEpilogue(true);
John McCallb81884d2010-02-19 09:25:03 +0000919 const CXXConstructorDecl *Ctor = cast<CXXConstructorDecl>(CurGD.getDecl());
920 CXXCtorType CtorType = CurGD.getCtorType();
921
Reid Kleckner340ad862014-01-13 22:57:31 +0000922 assert((CGM.getTarget().getCXXABI().hasConstructorVariants() ||
923 CtorType == Ctor_Complete) &&
924 "can only generate complete ctor for this ABI");
925
John McCallf8ff7b92010-02-23 00:48:20 +0000926 // Before we go any further, try the complete->base constructor
927 // delegation optimization.
Timur Iskhodzhanovf32a3772012-04-20 08:05:00 +0000928 if (CtorType == Ctor_Complete && IsConstructorDelegationValid(Ctor) &&
John McCallc8e01702013-04-16 22:48:15 +0000929 CGM.getTarget().getCXXABI().hasConstructorVariants()) {
Nick Lewycky2d84e842013-10-02 02:29:49 +0000930 EmitDelegateCXXConstructorCall(Ctor, Ctor_Base, Args, Ctor->getLocEnd());
John McCallf8ff7b92010-02-23 00:48:20 +0000931 return;
932 }
933
Hans Wennborgdcfba332015-10-06 23:40:43 +0000934 const FunctionDecl *Definition = nullptr;
Richard Smith46bb5812014-08-01 01:56:39 +0000935 Stmt *Body = Ctor->getBody(Definition);
936 assert(Definition == Ctor && "emitting wrong constructor body");
John McCallb81884d2010-02-19 09:25:03 +0000937
John McCallf8ff7b92010-02-23 00:48:20 +0000938 // Enter the function-try-block before the constructor prologue if
939 // applicable.
John McCallf8ff7b92010-02-23 00:48:20 +0000940 bool IsTryBody = (Body && isa<CXXTryStmt>(Body));
John McCallf8ff7b92010-02-23 00:48:20 +0000941 if (IsTryBody)
John McCallb609d3f2010-07-07 06:56:46 +0000942 EnterCXXTryStmt(*cast<CXXTryStmt>(Body), true);
John McCallb81884d2010-02-19 09:25:03 +0000943
Justin Bogner66242d62015-04-23 23:06:47 +0000944 incrementProfileCounter(Body);
Justin Bogner81c22c22014-01-23 02:54:27 +0000945
Richard Smithcc1b96d2013-06-12 22:31:48 +0000946 RunCleanupsScope RunCleanups(*this);
John McCallb81884d2010-02-19 09:25:03 +0000947
John McCall88313032012-03-30 04:25:03 +0000948 // TODO: in restricted cases, we can emit the vbase initializers of
949 // a complete ctor and then delegate to the base ctor.
950
John McCallf8ff7b92010-02-23 00:48:20 +0000951 // Emit the constructor prologue, i.e. the base and member
952 // initializers.
Douglas Gregor94f9a482010-05-05 05:51:00 +0000953 EmitCtorPrologue(Ctor, CtorType, Args);
John McCallb81884d2010-02-19 09:25:03 +0000954
955 // Emit the body of the statement.
John McCallf8ff7b92010-02-23 00:48:20 +0000956 if (IsTryBody)
John McCallb81884d2010-02-19 09:25:03 +0000957 EmitStmt(cast<CXXTryStmt>(Body)->getTryBlock());
958 else if (Body)
959 EmitStmt(Body);
John McCallb81884d2010-02-19 09:25:03 +0000960
961 // Emit any cleanup blocks associated with the member or base
962 // initializers, which includes (along the exceptional path) the
963 // destructors for those members and bases that were fully
964 // constructed.
Richard Smithcc1b96d2013-06-12 22:31:48 +0000965 RunCleanups.ForceCleanup();
John McCallb81884d2010-02-19 09:25:03 +0000966
John McCallf8ff7b92010-02-23 00:48:20 +0000967 if (IsTryBody)
John McCallb609d3f2010-07-07 06:56:46 +0000968 ExitCXXTryStmt(*cast<CXXTryStmt>(Body), true);
John McCallb81884d2010-02-19 09:25:03 +0000969}
970
Lang Hamesbf122742013-02-17 07:22:09 +0000971namespace {
Nick Lewycky8b4e3792013-09-11 02:03:20 +0000972 /// RAII object to indicate that codegen is copying the value representation
973 /// instead of the object representation. Useful when copying a struct or
974 /// class which has uninitialized members and we're only performing
975 /// lvalue-to-rvalue conversion on the object but not its members.
976 class CopyingValueRepresentation {
977 public:
978 explicit CopyingValueRepresentation(CodeGenFunction &CGF)
Alexey Samsonov035462c2014-10-30 19:33:44 +0000979 : CGF(CGF), OldSanOpts(CGF.SanOpts) {
Alexey Samsonovedf99a92014-11-07 22:29:38 +0000980 CGF.SanOpts.set(SanitizerKind::Bool, false);
981 CGF.SanOpts.set(SanitizerKind::Enum, false);
Nick Lewycky8b4e3792013-09-11 02:03:20 +0000982 }
983 ~CopyingValueRepresentation() {
984 CGF.SanOpts = OldSanOpts;
985 }
986 private:
987 CodeGenFunction &CGF;
Alexey Samsonova0416102014-11-11 01:26:14 +0000988 SanitizerSet OldSanOpts;
Nick Lewycky8b4e3792013-09-11 02:03:20 +0000989 };
Alexander Kornienkoab9db512015-06-22 23:07:51 +0000990}
Hans Wennborgdcfba332015-10-06 23:40:43 +0000991
Nick Lewycky8b4e3792013-09-11 02:03:20 +0000992namespace {
Lang Hamesbf122742013-02-17 07:22:09 +0000993 class FieldMemcpyizer {
994 public:
995 FieldMemcpyizer(CodeGenFunction &CGF, const CXXRecordDecl *ClassDecl,
996 const VarDecl *SrcRec)
Justin Bogner1cd11f12015-05-20 15:53:59 +0000997 : CGF(CGF), ClassDecl(ClassDecl), SrcRec(SrcRec),
Lang Hamesbf122742013-02-17 07:22:09 +0000998 RecLayout(CGF.getContext().getASTRecordLayout(ClassDecl)),
Craig Topper8a13c412014-05-21 05:09:00 +0000999 FirstField(nullptr), LastField(nullptr), FirstFieldOffset(0),
1000 LastFieldOffset(0), LastAddedFieldIndex(0) {}
Lang Hamesbf122742013-02-17 07:22:09 +00001001
Kostya Serebryany293dc9b2014-10-16 20:54:52 +00001002 bool isMemcpyableField(FieldDecl *F) const {
1003 // Never memcpy fields when we are adding poisoned paddings.
Alexey Samsonova0416102014-11-11 01:26:14 +00001004 if (CGF.getContext().getLangOpts().SanitizeAddressFieldPadding)
Kostya Serebryany293dc9b2014-10-16 20:54:52 +00001005 return false;
Lang Hamesbf122742013-02-17 07:22:09 +00001006 Qualifiers Qual = F->getType().getQualifiers();
1007 if (Qual.hasVolatile() || Qual.hasObjCLifetime())
1008 return false;
1009 return true;
1010 }
1011
1012 void addMemcpyableField(FieldDecl *F) {
Craig Topper8a13c412014-05-21 05:09:00 +00001013 if (!FirstField)
Lang Hamesbf122742013-02-17 07:22:09 +00001014 addInitialField(F);
1015 else
1016 addNextField(F);
1017 }
1018
David Majnemera586eb22014-10-10 18:57:10 +00001019 CharUnits getMemcpySize(uint64_t FirstByteOffset) const {
Lang Hamesbf122742013-02-17 07:22:09 +00001020 unsigned LastFieldSize =
1021 LastField->isBitField() ?
1022 LastField->getBitWidthValue(CGF.getContext()) :
Justin Bogner1cd11f12015-05-20 15:53:59 +00001023 CGF.getContext().getTypeSize(LastField->getType());
Lang Hamesbf122742013-02-17 07:22:09 +00001024 uint64_t MemcpySizeBits =
David Majnemera586eb22014-10-10 18:57:10 +00001025 LastFieldOffset + LastFieldSize - FirstByteOffset +
Lang Hamesbf122742013-02-17 07:22:09 +00001026 CGF.getContext().getCharWidth() - 1;
1027 CharUnits MemcpySize =
1028 CGF.getContext().toCharUnitsFromBits(MemcpySizeBits);
1029 return MemcpySize;
1030 }
1031
1032 void emitMemcpy() {
1033 // Give the subclass a chance to bail out if it feels the memcpy isn't
1034 // worth it (e.g. Hasn't aggregated enough data).
Craig Topper8a13c412014-05-21 05:09:00 +00001035 if (!FirstField) {
Lang Hamesbf122742013-02-17 07:22:09 +00001036 return;
1037 }
1038
David Majnemera586eb22014-10-10 18:57:10 +00001039 uint64_t FirstByteOffset;
Lang Hamesbf122742013-02-17 07:22:09 +00001040 if (FirstField->isBitField()) {
1041 const CGRecordLayout &RL =
1042 CGF.getTypes().getCGRecordLayout(FirstField->getParent());
1043 const CGBitFieldInfo &BFInfo = RL.getBitFieldInfo(FirstField);
David Majnemera586eb22014-10-10 18:57:10 +00001044 // FirstFieldOffset is not appropriate for bitfields,
Ulrich Weigand73263d72015-07-13 11:52:14 +00001045 // we need to use the storage offset instead.
Ulrich Weigand03ce2a12015-07-10 17:30:00 +00001046 FirstByteOffset = CGF.getContext().toBits(BFInfo.StorageOffset);
Lang Hames1694e0d2013-02-27 04:14:49 +00001047 } else {
David Majnemera586eb22014-10-10 18:57:10 +00001048 FirstByteOffset = FirstFieldOffset;
Lang Hames1694e0d2013-02-27 04:14:49 +00001049 }
Lang Hamesbf122742013-02-17 07:22:09 +00001050
David Majnemera586eb22014-10-10 18:57:10 +00001051 CharUnits MemcpySize = getMemcpySize(FirstByteOffset);
Lang Hamesbf122742013-02-17 07:22:09 +00001052 QualType RecordTy = CGF.getContext().getTypeDeclType(ClassDecl);
John McCall7f416cc2015-09-08 08:05:57 +00001053 Address ThisPtr = CGF.LoadCXXThisAddress();
1054 LValue DestLV = CGF.MakeAddrLValue(ThisPtr, RecordTy);
Lang Hamesbf122742013-02-17 07:22:09 +00001055 LValue Dest = CGF.EmitLValueForFieldInitialization(DestLV, FirstField);
1056 llvm::Value *SrcPtr = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(SrcRec));
1057 LValue SrcLV = CGF.MakeNaturalAlignAddrLValue(SrcPtr, RecordTy);
1058 LValue Src = CGF.EmitLValueForFieldInitialization(SrcLV, FirstField);
1059
John McCall7f416cc2015-09-08 08:05:57 +00001060 emitMemcpyIR(Dest.isBitField() ? Dest.getBitFieldAddress() : Dest.getAddress(),
1061 Src.isBitField() ? Src.getBitFieldAddress() : Src.getAddress(),
1062 MemcpySize);
Lang Hamesbf122742013-02-17 07:22:09 +00001063 reset();
1064 }
1065
1066 void reset() {
Craig Topper8a13c412014-05-21 05:09:00 +00001067 FirstField = nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001068 }
1069
1070 protected:
1071 CodeGenFunction &CGF;
1072 const CXXRecordDecl *ClassDecl;
1073
1074 private:
1075
John McCall7f416cc2015-09-08 08:05:57 +00001076 void emitMemcpyIR(Address DestPtr, Address SrcPtr, CharUnits Size) {
1077 llvm::PointerType *DPT = DestPtr.getType();
Lang Hamesbf122742013-02-17 07:22:09 +00001078 llvm::Type *DBP =
1079 llvm::Type::getInt8PtrTy(CGF.getLLVMContext(), DPT->getAddressSpace());
1080 DestPtr = CGF.Builder.CreateBitCast(DestPtr, DBP);
1081
John McCall7f416cc2015-09-08 08:05:57 +00001082 llvm::PointerType *SPT = SrcPtr.getType();
Lang Hamesbf122742013-02-17 07:22:09 +00001083 llvm::Type *SBP =
1084 llvm::Type::getInt8PtrTy(CGF.getLLVMContext(), SPT->getAddressSpace());
1085 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, SBP);
1086
John McCall7f416cc2015-09-08 08:05:57 +00001087 CGF.Builder.CreateMemCpy(DestPtr, SrcPtr, Size.getQuantity());
Lang Hamesbf122742013-02-17 07:22:09 +00001088 }
1089
1090 void addInitialField(FieldDecl *F) {
1091 FirstField = F;
1092 LastField = F;
1093 FirstFieldOffset = RecLayout.getFieldOffset(F->getFieldIndex());
1094 LastFieldOffset = FirstFieldOffset;
1095 LastAddedFieldIndex = F->getFieldIndex();
1096 return;
1097 }
1098
1099 void addNextField(FieldDecl *F) {
John McCall6054d5a2013-05-07 05:20:46 +00001100 // For the most part, the following invariant will hold:
1101 // F->getFieldIndex() == LastAddedFieldIndex + 1
1102 // The one exception is that Sema won't add a copy-initializer for an
1103 // unnamed bitfield, which will show up here as a gap in the sequence.
1104 assert(F->getFieldIndex() >= LastAddedFieldIndex + 1 &&
1105 "Cannot aggregate fields out of order.");
Lang Hamesbf122742013-02-17 07:22:09 +00001106 LastAddedFieldIndex = F->getFieldIndex();
1107
1108 // The 'first' and 'last' fields are chosen by offset, rather than field
1109 // index. This allows the code to support bitfields, as well as regular
1110 // fields.
1111 uint64_t FOffset = RecLayout.getFieldOffset(F->getFieldIndex());
1112 if (FOffset < FirstFieldOffset) {
1113 FirstField = F;
1114 FirstFieldOffset = FOffset;
1115 } else if (FOffset > LastFieldOffset) {
1116 LastField = F;
1117 LastFieldOffset = FOffset;
1118 }
1119 }
1120
1121 const VarDecl *SrcRec;
1122 const ASTRecordLayout &RecLayout;
1123 FieldDecl *FirstField;
1124 FieldDecl *LastField;
1125 uint64_t FirstFieldOffset, LastFieldOffset;
1126 unsigned LastAddedFieldIndex;
1127 };
1128
1129 class ConstructorMemcpyizer : public FieldMemcpyizer {
1130 private:
1131
1132 /// Get source argument for copy constructor. Returns null if not a copy
David Majnemer196ac332014-09-11 23:05:02 +00001133 /// constructor.
1134 static const VarDecl *getTrivialCopySource(CodeGenFunction &CGF,
1135 const CXXConstructorDecl *CD,
Lang Hamesbf122742013-02-17 07:22:09 +00001136 FunctionArgList &Args) {
Jordan Rose54533f72013-08-07 16:16:48 +00001137 if (CD->isCopyOrMoveConstructor() && CD->isDefaulted())
David Majnemer196ac332014-09-11 23:05:02 +00001138 return Args[CGF.CGM.getCXXABI().getSrcArgforCopyCtor(CD, Args)];
Craig Topper8a13c412014-05-21 05:09:00 +00001139 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001140 }
1141
1142 // Returns true if a CXXCtorInitializer represents a member initialization
1143 // that can be rolled into a memcpy.
1144 bool isMemberInitMemcpyable(CXXCtorInitializer *MemberInit) const {
1145 if (!MemcpyableCtor)
1146 return false;
1147 FieldDecl *Field = MemberInit->getMember();
Craig Topper8a13c412014-05-21 05:09:00 +00001148 assert(Field && "No field for member init.");
Lang Hamesbf122742013-02-17 07:22:09 +00001149 QualType FieldType = Field->getType();
1150 CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(MemberInit->getInit());
1151
Richard Smith419bd092015-04-29 19:26:57 +00001152 // Bail out on non-memcpyable, not-trivially-copyable members.
1153 if (!(CE && isMemcpyEquivalentSpecialMember(CE->getConstructor())) &&
Lang Hamesbf122742013-02-17 07:22:09 +00001154 !(FieldType.isTriviallyCopyableType(CGF.getContext()) ||
1155 FieldType->isReferenceType()))
1156 return false;
1157
1158 // Bail out on volatile fields.
1159 if (!isMemcpyableField(Field))
1160 return false;
1161
1162 // Otherwise we're good.
1163 return true;
1164 }
1165
1166 public:
1167 ConstructorMemcpyizer(CodeGenFunction &CGF, const CXXConstructorDecl *CD,
1168 FunctionArgList &Args)
David Majnemer196ac332014-09-11 23:05:02 +00001169 : FieldMemcpyizer(CGF, CD->getParent(), getTrivialCopySource(CGF, CD, Args)),
Lang Hamesbf122742013-02-17 07:22:09 +00001170 ConstructorDecl(CD),
Jordan Rose54533f72013-08-07 16:16:48 +00001171 MemcpyableCtor(CD->isDefaulted() &&
Lang Hamesbf122742013-02-17 07:22:09 +00001172 CD->isCopyOrMoveConstructor() &&
1173 CGF.getLangOpts().getGC() == LangOptions::NonGC),
1174 Args(Args) { }
1175
1176 void addMemberInitializer(CXXCtorInitializer *MemberInit) {
1177 if (isMemberInitMemcpyable(MemberInit)) {
1178 AggregatedInits.push_back(MemberInit);
1179 addMemcpyableField(MemberInit->getMember());
1180 } else {
1181 emitAggregatedInits();
1182 EmitMemberInitializer(CGF, ConstructorDecl->getParent(), MemberInit,
1183 ConstructorDecl, Args);
1184 }
1185 }
1186
1187 void emitAggregatedInits() {
1188 if (AggregatedInits.size() <= 1) {
1189 // This memcpy is too small to be worthwhile. Fall back on default
1190 // codegen.
Nick Lewycky8b4e3792013-09-11 02:03:20 +00001191 if (!AggregatedInits.empty()) {
1192 CopyingValueRepresentation CVR(CGF);
Lang Hamesbf122742013-02-17 07:22:09 +00001193 EmitMemberInitializer(CGF, ConstructorDecl->getParent(),
Nick Lewycky8b4e3792013-09-11 02:03:20 +00001194 AggregatedInits[0], ConstructorDecl, Args);
Alexey Bataev152c71f2015-07-14 07:55:48 +00001195 AggregatedInits.clear();
Lang Hamesbf122742013-02-17 07:22:09 +00001196 }
1197 reset();
1198 return;
1199 }
1200
1201 pushEHDestructors();
1202 emitMemcpy();
1203 AggregatedInits.clear();
1204 }
1205
1206 void pushEHDestructors() {
John McCall7f416cc2015-09-08 08:05:57 +00001207 Address ThisPtr = CGF.LoadCXXThisAddress();
Lang Hamesbf122742013-02-17 07:22:09 +00001208 QualType RecordTy = CGF.getContext().getTypeDeclType(ClassDecl);
John McCall7f416cc2015-09-08 08:05:57 +00001209 LValue LHS = CGF.MakeAddrLValue(ThisPtr, RecordTy);
Lang Hamesbf122742013-02-17 07:22:09 +00001210
1211 for (unsigned i = 0; i < AggregatedInits.size(); ++i) {
Alexey Bataev152c71f2015-07-14 07:55:48 +00001212 CXXCtorInitializer *MemberInit = AggregatedInits[i];
1213 QualType FieldType = MemberInit->getAnyMember()->getType();
Lang Hamesbf122742013-02-17 07:22:09 +00001214 QualType::DestructionKind dtorKind = FieldType.isDestructedType();
Alexey Bataev152c71f2015-07-14 07:55:48 +00001215 if (!CGF.needsEHCleanup(dtorKind))
1216 continue;
1217 LValue FieldLHS = LHS;
1218 EmitLValueForAnyFieldInitialization(CGF, MemberInit, FieldLHS);
1219 CGF.pushEHDestroy(dtorKind, FieldLHS.getAddress(), FieldType);
Lang Hamesbf122742013-02-17 07:22:09 +00001220 }
1221 }
1222
1223 void finish() {
1224 emitAggregatedInits();
1225 }
1226
1227 private:
1228 const CXXConstructorDecl *ConstructorDecl;
1229 bool MemcpyableCtor;
1230 FunctionArgList &Args;
1231 SmallVector<CXXCtorInitializer*, 16> AggregatedInits;
1232 };
1233
1234 class AssignmentMemcpyizer : public FieldMemcpyizer {
1235 private:
1236
1237 // Returns the memcpyable field copied by the given statement, if one
Nick Lewycky8b4e3792013-09-11 02:03:20 +00001238 // exists. Otherwise returns null.
1239 FieldDecl *getMemcpyableField(Stmt *S) {
Lang Hamesbf122742013-02-17 07:22:09 +00001240 if (!AssignmentsMemcpyable)
Craig Topper8a13c412014-05-21 05:09:00 +00001241 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001242 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(S)) {
1243 // Recognise trivial assignments.
1244 if (BO->getOpcode() != BO_Assign)
Craig Topper8a13c412014-05-21 05:09:00 +00001245 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001246 MemberExpr *ME = dyn_cast<MemberExpr>(BO->getLHS());
1247 if (!ME)
Craig Topper8a13c412014-05-21 05:09:00 +00001248 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001249 FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl());
1250 if (!Field || !isMemcpyableField(Field))
Craig Topper8a13c412014-05-21 05:09:00 +00001251 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001252 Stmt *RHS = BO->getRHS();
1253 if (ImplicitCastExpr *EC = dyn_cast<ImplicitCastExpr>(RHS))
1254 RHS = EC->getSubExpr();
1255 if (!RHS)
Craig Topper8a13c412014-05-21 05:09:00 +00001256 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001257 MemberExpr *ME2 = dyn_cast<MemberExpr>(RHS);
1258 if (dyn_cast<FieldDecl>(ME2->getMemberDecl()) != Field)
Craig Topper8a13c412014-05-21 05:09:00 +00001259 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001260 return Field;
1261 } else if (CXXMemberCallExpr *MCE = dyn_cast<CXXMemberCallExpr>(S)) {
1262 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MCE->getCalleeDecl());
Richard Smith419bd092015-04-29 19:26:57 +00001263 if (!(MD && isMemcpyEquivalentSpecialMember(MD)))
Craig Topper8a13c412014-05-21 05:09:00 +00001264 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001265 MemberExpr *IOA = dyn_cast<MemberExpr>(MCE->getImplicitObjectArgument());
1266 if (!IOA)
Craig Topper8a13c412014-05-21 05:09:00 +00001267 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001268 FieldDecl *Field = dyn_cast<FieldDecl>(IOA->getMemberDecl());
1269 if (!Field || !isMemcpyableField(Field))
Craig Topper8a13c412014-05-21 05:09:00 +00001270 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001271 MemberExpr *Arg0 = dyn_cast<MemberExpr>(MCE->getArg(0));
1272 if (!Arg0 || Field != dyn_cast<FieldDecl>(Arg0->getMemberDecl()))
Craig Topper8a13c412014-05-21 05:09:00 +00001273 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001274 return Field;
1275 } else if (CallExpr *CE = dyn_cast<CallExpr>(S)) {
1276 FunctionDecl *FD = dyn_cast<FunctionDecl>(CE->getCalleeDecl());
1277 if (!FD || FD->getBuiltinID() != Builtin::BI__builtin_memcpy)
Craig Topper8a13c412014-05-21 05:09:00 +00001278 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001279 Expr *DstPtr = CE->getArg(0);
1280 if (ImplicitCastExpr *DC = dyn_cast<ImplicitCastExpr>(DstPtr))
1281 DstPtr = DC->getSubExpr();
1282 UnaryOperator *DUO = dyn_cast<UnaryOperator>(DstPtr);
1283 if (!DUO || DUO->getOpcode() != UO_AddrOf)
Craig Topper8a13c412014-05-21 05:09:00 +00001284 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001285 MemberExpr *ME = dyn_cast<MemberExpr>(DUO->getSubExpr());
1286 if (!ME)
Craig Topper8a13c412014-05-21 05:09:00 +00001287 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001288 FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl());
1289 if (!Field || !isMemcpyableField(Field))
Craig Topper8a13c412014-05-21 05:09:00 +00001290 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001291 Expr *SrcPtr = CE->getArg(1);
1292 if (ImplicitCastExpr *SC = dyn_cast<ImplicitCastExpr>(SrcPtr))
1293 SrcPtr = SC->getSubExpr();
1294 UnaryOperator *SUO = dyn_cast<UnaryOperator>(SrcPtr);
1295 if (!SUO || SUO->getOpcode() != UO_AddrOf)
Craig Topper8a13c412014-05-21 05:09:00 +00001296 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001297 MemberExpr *ME2 = dyn_cast<MemberExpr>(SUO->getSubExpr());
1298 if (!ME2 || Field != dyn_cast<FieldDecl>(ME2->getMemberDecl()))
Craig Topper8a13c412014-05-21 05:09:00 +00001299 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001300 return Field;
1301 }
1302
Craig Topper8a13c412014-05-21 05:09:00 +00001303 return nullptr;
Lang Hamesbf122742013-02-17 07:22:09 +00001304 }
1305
1306 bool AssignmentsMemcpyable;
1307 SmallVector<Stmt*, 16> AggregatedStmts;
1308
1309 public:
1310
1311 AssignmentMemcpyizer(CodeGenFunction &CGF, const CXXMethodDecl *AD,
1312 FunctionArgList &Args)
1313 : FieldMemcpyizer(CGF, AD->getParent(), Args[Args.size() - 1]),
1314 AssignmentsMemcpyable(CGF.getLangOpts().getGC() == LangOptions::NonGC) {
1315 assert(Args.size() == 2);
1316 }
1317
1318 void emitAssignment(Stmt *S) {
1319 FieldDecl *F = getMemcpyableField(S);
1320 if (F) {
1321 addMemcpyableField(F);
1322 AggregatedStmts.push_back(S);
Justin Bogner1cd11f12015-05-20 15:53:59 +00001323 } else {
Lang Hamesbf122742013-02-17 07:22:09 +00001324 emitAggregatedStmts();
1325 CGF.EmitStmt(S);
1326 }
1327 }
1328
1329 void emitAggregatedStmts() {
1330 if (AggregatedStmts.size() <= 1) {
Nick Lewycky8b4e3792013-09-11 02:03:20 +00001331 if (!AggregatedStmts.empty()) {
1332 CopyingValueRepresentation CVR(CGF);
1333 CGF.EmitStmt(AggregatedStmts[0]);
1334 }
Lang Hamesbf122742013-02-17 07:22:09 +00001335 reset();
1336 }
1337
1338 emitMemcpy();
1339 AggregatedStmts.clear();
1340 }
1341
1342 void finish() {
1343 emitAggregatedStmts();
1344 }
1345 };
Hans Wennborgdcfba332015-10-06 23:40:43 +00001346} // end anonymous namespace
Lang Hamesbf122742013-02-17 07:22:09 +00001347
Piotr Padlewski338c9d02015-09-15 21:46:47 +00001348static bool isInitializerOfDynamicClass(const CXXCtorInitializer *BaseInit) {
1349 const Type *BaseType = BaseInit->getBaseClass();
1350 const auto *BaseClassDecl =
1351 cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl());
1352 return BaseClassDecl->isDynamicClass();
1353}
1354
Anders Carlssonfb404882009-12-24 22:46:43 +00001355/// EmitCtorPrologue - This routine generates necessary code to initialize
1356/// base classes and non-static data members belonging to this constructor.
Anders Carlssonfb404882009-12-24 22:46:43 +00001357void CodeGenFunction::EmitCtorPrologue(const CXXConstructorDecl *CD,
Douglas Gregor94f9a482010-05-05 05:51:00 +00001358 CXXCtorType CtorType,
1359 FunctionArgList &Args) {
Alexis Hunt61bc1732011-05-01 07:04:31 +00001360 if (CD->isDelegatingConstructor())
1361 return EmitDelegatingCXXConstructorCall(CD, Args);
1362
Anders Carlssonfb404882009-12-24 22:46:43 +00001363 const CXXRecordDecl *ClassDecl = CD->getParent();
Anders Carlsson5dc86332010-02-02 19:58:43 +00001364
Timur Iskhodzhanov57cbe5c2013-02-27 13:46:31 +00001365 CXXConstructorDecl::init_const_iterator B = CD->init_begin(),
1366 E = CD->init_end();
1367
Craig Topper8a13c412014-05-21 05:09:00 +00001368 llvm::BasicBlock *BaseCtorContinueBB = nullptr;
Timur Iskhodzhanov57cbe5c2013-02-27 13:46:31 +00001369 if (ClassDecl->getNumVBases() &&
1370 !CGM.getTarget().getCXXABI().hasConstructorVariants()) {
1371 // The ABIs that don't have constructor variants need to put a branch
1372 // before the virtual base initialization code.
Reid Kleckner7810af02013-06-19 15:20:38 +00001373 BaseCtorContinueBB =
1374 CGM.getCXXABI().EmitCtorCompleteObjectHandler(*this, ClassDecl);
Timur Iskhodzhanov57cbe5c2013-02-27 13:46:31 +00001375 assert(BaseCtorContinueBB);
1376 }
1377
Piotr Padlewski276a78d2015-10-02 22:12:40 +00001378 llvm::Value *const OldThis = CXXThisValue;
Timur Iskhodzhanov57cbe5c2013-02-27 13:46:31 +00001379 // Virtual base initializers first.
1380 for (; B != E && (*B)->isBaseInitializer() && (*B)->isBaseVirtual(); B++) {
Piotr Padlewski276a78d2015-10-02 22:12:40 +00001381 if (CGM.getCodeGenOpts().StrictVTablePointers &&
1382 CGM.getCodeGenOpts().OptimizationLevel > 0 &&
1383 isInitializerOfDynamicClass(*B))
1384 CXXThisValue = Builder.CreateInvariantGroupBarrier(LoadCXXThis());
Timur Iskhodzhanov57cbe5c2013-02-27 13:46:31 +00001385 EmitBaseInitializer(*this, ClassDecl, *B, CtorType);
1386 }
1387
1388 if (BaseCtorContinueBB) {
1389 // Complete object handler should continue to the remaining initializers.
1390 Builder.CreateBr(BaseCtorContinueBB);
1391 EmitBlock(BaseCtorContinueBB);
1392 }
1393
1394 // Then, non-virtual base initializers.
1395 for (; B != E && (*B)->isBaseInitializer(); B++) {
1396 assert(!(*B)->isBaseVirtual());
Piotr Padlewski276a78d2015-10-02 22:12:40 +00001397
1398 if (CGM.getCodeGenOpts().StrictVTablePointers &&
1399 CGM.getCodeGenOpts().OptimizationLevel > 0 &&
1400 isInitializerOfDynamicClass(*B))
1401 CXXThisValue = Builder.CreateInvariantGroupBarrier(LoadCXXThis());
Timur Iskhodzhanov57cbe5c2013-02-27 13:46:31 +00001402 EmitBaseInitializer(*this, ClassDecl, *B, CtorType);
Anders Carlssonfb404882009-12-24 22:46:43 +00001403 }
1404
Piotr Padlewski276a78d2015-10-02 22:12:40 +00001405 CXXThisValue = OldThis;
Piotr Padlewski338c9d02015-09-15 21:46:47 +00001406
Anders Carlssond5895932010-03-28 21:07:49 +00001407 InitializeVTablePointers(ClassDecl);
Anders Carlsson5dc86332010-02-02 19:58:43 +00001408
Timur Iskhodzhanov57cbe5c2013-02-27 13:46:31 +00001409 // And finally, initialize class members.
John McCall7f416cc2015-09-08 08:05:57 +00001410 FieldConstructionScope FCS(*this, LoadCXXThisAddress());
Lang Hamesbf122742013-02-17 07:22:09 +00001411 ConstructorMemcpyizer CM(*this, CD, Args);
Timur Iskhodzhanov57cbe5c2013-02-27 13:46:31 +00001412 for (; B != E; B++) {
1413 CXXCtorInitializer *Member = (*B);
1414 assert(!Member->isBaseInitializer());
1415 assert(Member->isAnyMemberInitializer() &&
1416 "Delegating initializer on non-delegating constructor");
1417 CM.addMemberInitializer(Member);
1418 }
Lang Hamesbf122742013-02-17 07:22:09 +00001419 CM.finish();
Anders Carlssonfb404882009-12-24 22:46:43 +00001420}
1421
Anders Carlsson49c0bd22011-05-15 17:36:21 +00001422static bool
1423FieldHasTrivialDestructorBody(ASTContext &Context, const FieldDecl *Field);
1424
1425static bool
Justin Bogner1cd11f12015-05-20 15:53:59 +00001426HasTrivialDestructorBody(ASTContext &Context,
Anders Carlsson49c0bd22011-05-15 17:36:21 +00001427 const CXXRecordDecl *BaseClassDecl,
1428 const CXXRecordDecl *MostDerivedClassDecl)
1429{
1430 // If the destructor is trivial we don't have to check anything else.
1431 if (BaseClassDecl->hasTrivialDestructor())
1432 return true;
1433
1434 if (!BaseClassDecl->getDestructor()->hasTrivialBody())
1435 return false;
1436
1437 // Check fields.
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00001438 for (const auto *Field : BaseClassDecl->fields())
Anders Carlsson49c0bd22011-05-15 17:36:21 +00001439 if (!FieldHasTrivialDestructorBody(Context, Field))
1440 return false;
Anders Carlsson49c0bd22011-05-15 17:36:21 +00001441
1442 // Check non-virtual bases.
Aaron Ballman574705e2014-03-13 15:41:46 +00001443 for (const auto &I : BaseClassDecl->bases()) {
1444 if (I.isVirtual())
Anders Carlsson49c0bd22011-05-15 17:36:21 +00001445 continue;
1446
1447 const CXXRecordDecl *NonVirtualBase =
Aaron Ballman574705e2014-03-13 15:41:46 +00001448 cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
Anders Carlsson49c0bd22011-05-15 17:36:21 +00001449 if (!HasTrivialDestructorBody(Context, NonVirtualBase,
1450 MostDerivedClassDecl))
1451 return false;
1452 }
1453
1454 if (BaseClassDecl == MostDerivedClassDecl) {
1455 // Check virtual bases.
Aaron Ballman445a9392014-03-13 16:15:17 +00001456 for (const auto &I : BaseClassDecl->vbases()) {
Anders Carlsson49c0bd22011-05-15 17:36:21 +00001457 const CXXRecordDecl *VirtualBase =
Aaron Ballman445a9392014-03-13 16:15:17 +00001458 cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
Anders Carlsson49c0bd22011-05-15 17:36:21 +00001459 if (!HasTrivialDestructorBody(Context, VirtualBase,
1460 MostDerivedClassDecl))
Justin Bogner1cd11f12015-05-20 15:53:59 +00001461 return false;
Anders Carlsson49c0bd22011-05-15 17:36:21 +00001462 }
1463 }
1464
1465 return true;
1466}
1467
1468static bool
1469FieldHasTrivialDestructorBody(ASTContext &Context,
Naomi Musgrave866af2d2015-09-03 23:02:30 +00001470 const FieldDecl *Field)
Anders Carlsson49c0bd22011-05-15 17:36:21 +00001471{
1472 QualType FieldBaseElementType = Context.getBaseElementType(Field->getType());
1473
1474 const RecordType *RT = FieldBaseElementType->getAs<RecordType>();
1475 if (!RT)
1476 return true;
Justin Bogner1cd11f12015-05-20 15:53:59 +00001477
Anders Carlsson49c0bd22011-05-15 17:36:21 +00001478 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
Davide Italiano982bbf42015-06-26 00:18:35 +00001479
1480 // The destructor for an implicit anonymous union member is never invoked.
1481 if (FieldClassDecl->isUnion() && FieldClassDecl->isAnonymousStructOrUnion())
1482 return false;
1483
Anders Carlsson49c0bd22011-05-15 17:36:21 +00001484 return HasTrivialDestructorBody(Context, FieldClassDecl, FieldClassDecl);
1485}
1486
Anders Carlsson9bd7d162011-05-14 23:26:09 +00001487/// CanSkipVTablePointerInitialization - Check whether we need to initialize
1488/// any vtable pointers before calling this destructor.
Naomi Musgrave866af2d2015-09-03 23:02:30 +00001489static bool CanSkipVTablePointerInitialization(CodeGenFunction &CGF,
Anders Carlssond6f15182011-05-16 04:08:36 +00001490 const CXXDestructorDecl *Dtor) {
Piotr Padlewski338c9d02015-09-15 21:46:47 +00001491 const CXXRecordDecl *ClassDecl = Dtor->getParent();
1492 if (!ClassDecl->isDynamicClass())
1493 return true;
1494
Anders Carlsson9bd7d162011-05-14 23:26:09 +00001495 if (!Dtor->hasTrivialBody())
1496 return false;
1497
1498 // Check the fields.
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00001499 for (const auto *Field : ClassDecl->fields())
Naomi Musgrave866af2d2015-09-03 23:02:30 +00001500 if (!FieldHasTrivialDestructorBody(CGF.getContext(), Field))
Anders Carlsson49c0bd22011-05-15 17:36:21 +00001501 return false;
Anders Carlsson9bd7d162011-05-14 23:26:09 +00001502
1503 return true;
1504}
1505
John McCallb81884d2010-02-19 09:25:03 +00001506/// EmitDestructorBody - Emits the body of the current destructor.
1507void CodeGenFunction::EmitDestructorBody(FunctionArgList &Args) {
1508 const CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(CurGD.getDecl());
1509 CXXDtorType DtorType = CurGD.getDtorType();
1510
Justin Bognerfb298222015-05-20 16:16:23 +00001511 Stmt *Body = Dtor->getBody();
1512 if (Body)
1513 incrementProfileCounter(Body);
1514
John McCallf99a6312010-07-21 05:30:47 +00001515 // The call to operator delete in a deleting destructor happens
1516 // outside of the function-try-block, which means it's always
1517 // possible to delegate the destructor body to the complete
1518 // destructor. Do so.
1519 if (DtorType == Dtor_Deleting) {
1520 EnterDtorCleanups(Dtor, Dtor_Deleting);
1521 EmitCXXDestructorCall(Dtor, Dtor_Complete, /*ForVirtualBase=*/false,
John McCall7f416cc2015-09-08 08:05:57 +00001522 /*Delegating=*/false, LoadCXXThisAddress());
John McCallf99a6312010-07-21 05:30:47 +00001523 PopCleanupBlock();
1524 return;
1525 }
1526
John McCallb81884d2010-02-19 09:25:03 +00001527 // If the body is a function-try-block, enter the try before
John McCallf99a6312010-07-21 05:30:47 +00001528 // anything else.
1529 bool isTryBody = (Body && isa<CXXTryStmt>(Body));
John McCallb81884d2010-02-19 09:25:03 +00001530 if (isTryBody)
John McCallb609d3f2010-07-07 06:56:46 +00001531 EnterCXXTryStmt(*cast<CXXTryStmt>(Body), true);
Kostya Serebryany293dc9b2014-10-16 20:54:52 +00001532 EmitAsanPrologueOrEpilogue(false);
John McCallb81884d2010-02-19 09:25:03 +00001533
John McCallf99a6312010-07-21 05:30:47 +00001534 // Enter the epilogue cleanups.
1535 RunCleanupsScope DtorEpilogue(*this);
Justin Bogner1cd11f12015-05-20 15:53:59 +00001536
John McCallb81884d2010-02-19 09:25:03 +00001537 // If this is the complete variant, just invoke the base variant;
1538 // the epilogue will destruct the virtual bases. But we can't do
1539 // this optimization if the body is a function-try-block, because
Justin Bogner1cd11f12015-05-20 15:53:59 +00001540 // we'd introduce *two* handler blocks. In the Microsoft ABI, we
Reid Klecknere7de47e2013-07-22 13:51:44 +00001541 // always delegate because we might not have a definition in this TU.
John McCallf99a6312010-07-21 05:30:47 +00001542 switch (DtorType) {
Rafael Espindola1e4df922014-09-16 15:18:21 +00001543 case Dtor_Comdat:
1544 llvm_unreachable("not expecting a COMDAT");
1545
John McCallf99a6312010-07-21 05:30:47 +00001546 case Dtor_Deleting: llvm_unreachable("already handled deleting case");
1547
1548 case Dtor_Complete:
Reid Klecknere7de47e2013-07-22 13:51:44 +00001549 assert((Body || getTarget().getCXXABI().isMicrosoft()) &&
1550 "can't emit a dtor without a body for non-Microsoft ABIs");
1551
John McCallf99a6312010-07-21 05:30:47 +00001552 // Enter the cleanup scopes for virtual bases.
1553 EnterDtorCleanups(Dtor, Dtor_Complete);
1554
Reid Klecknere7de47e2013-07-22 13:51:44 +00001555 if (!isTryBody) {
John McCallf99a6312010-07-21 05:30:47 +00001556 EmitCXXDestructorCall(Dtor, Dtor_Base, /*ForVirtualBase=*/false,
John McCall7f416cc2015-09-08 08:05:57 +00001557 /*Delegating=*/false, LoadCXXThisAddress());
John McCallf99a6312010-07-21 05:30:47 +00001558 break;
1559 }
1560 // Fallthrough: act like we're in the base variant.
Justin Bogner1cd11f12015-05-20 15:53:59 +00001561
John McCallf99a6312010-07-21 05:30:47 +00001562 case Dtor_Base:
Reid Klecknere7de47e2013-07-22 13:51:44 +00001563 assert(Body);
1564
John McCallf99a6312010-07-21 05:30:47 +00001565 // Enter the cleanup scopes for fields and non-virtual bases.
1566 EnterDtorCleanups(Dtor, Dtor_Base);
1567
1568 // Initialize the vtable pointers before entering the body.
Piotr Padlewski338c9d02015-09-15 21:46:47 +00001569 if (!CanSkipVTablePointerInitialization(*this, Dtor)) {
1570 // Insert the llvm.invariant.group.barrier intrinsic before initializing
1571 // the vptrs to cancel any previous assumptions we might have made.
1572 if (CGM.getCodeGenOpts().StrictVTablePointers &&
1573 CGM.getCodeGenOpts().OptimizationLevel > 0)
1574 CXXThisValue = Builder.CreateInvariantGroupBarrier(LoadCXXThis());
1575 InitializeVTablePointers(Dtor->getParent());
1576 }
John McCallf99a6312010-07-21 05:30:47 +00001577
1578 if (isTryBody)
1579 EmitStmt(cast<CXXTryStmt>(Body)->getTryBlock());
1580 else if (Body)
1581 EmitStmt(Body);
1582 else {
1583 assert(Dtor->isImplicit() && "bodyless dtor not implicit");
1584 // nothing to do besides what's in the epilogue
1585 }
Fariborz Jahanian0c12ed12011-02-02 23:12:46 +00001586 // -fapple-kext must inline any call to this dtor into
1587 // the caller's body.
Richard Smith9c6890a2012-11-01 22:30:59 +00001588 if (getLangOpts().AppleKext)
Evgeniy Stepanov6b2a61d2015-09-14 21:35:16 +00001589 CurFn->addFnAttr(llvm::Attribute::AlwaysInline);
Naomi Musgravee50cb9b2015-08-13 18:35:11 +00001590
John McCallf99a6312010-07-21 05:30:47 +00001591 break;
John McCallb81884d2010-02-19 09:25:03 +00001592 }
1593
John McCallf99a6312010-07-21 05:30:47 +00001594 // Jump out through the epilogue cleanups.
1595 DtorEpilogue.ForceCleanup();
John McCallb81884d2010-02-19 09:25:03 +00001596
1597 // Exit the try if applicable.
1598 if (isTryBody)
John McCallb609d3f2010-07-07 06:56:46 +00001599 ExitCXXTryStmt(*cast<CXXTryStmt>(Body), true);
John McCallb81884d2010-02-19 09:25:03 +00001600}
1601
Lang Hamesbf122742013-02-17 07:22:09 +00001602void CodeGenFunction::emitImplicitAssignmentOperatorBody(FunctionArgList &Args) {
1603 const CXXMethodDecl *AssignOp = cast<CXXMethodDecl>(CurGD.getDecl());
1604 const Stmt *RootS = AssignOp->getBody();
1605 assert(isa<CompoundStmt>(RootS) &&
1606 "Body of an implicit assignment operator should be compound stmt.");
1607 const CompoundStmt *RootCS = cast<CompoundStmt>(RootS);
1608
1609 LexicalScope Scope(*this, RootCS->getSourceRange());
1610
1611 AssignmentMemcpyizer AM(*this, AssignOp, Args);
Aaron Ballmanc7e4e212014-03-17 14:19:37 +00001612 for (auto *I : RootCS->body())
Justin Bogner1cd11f12015-05-20 15:53:59 +00001613 AM.emitAssignment(I);
Lang Hamesbf122742013-02-17 07:22:09 +00001614 AM.finish();
1615}
1616
John McCallf99a6312010-07-21 05:30:47 +00001617namespace {
1618 /// Call the operator delete associated with the current destructor.
David Blaikie7e70d682015-08-18 22:40:54 +00001619 struct CallDtorDelete final : EHScopeStack::Cleanup {
John McCallf99a6312010-07-21 05:30:47 +00001620 CallDtorDelete() {}
1621
Craig Topper4f12f102014-03-12 06:41:41 +00001622 void Emit(CodeGenFunction &CGF, Flags flags) override {
John McCallf99a6312010-07-21 05:30:47 +00001623 const CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(CGF.CurCodeDecl);
1624 const CXXRecordDecl *ClassDecl = Dtor->getParent();
1625 CGF.EmitDeleteCall(Dtor->getOperatorDelete(), CGF.LoadCXXThis(),
1626 CGF.getContext().getTagDeclType(ClassDecl));
1627 }
1628 };
1629
David Blaikie7e70d682015-08-18 22:40:54 +00001630 struct CallDtorDeleteConditional final : EHScopeStack::Cleanup {
Timur Iskhodzhanovee6bc532013-02-13 08:37:51 +00001631 llvm::Value *ShouldDeleteCondition;
1632 public:
1633 CallDtorDeleteConditional(llvm::Value *ShouldDeleteCondition)
Naomi Musgrave866af2d2015-09-03 23:02:30 +00001634 : ShouldDeleteCondition(ShouldDeleteCondition) {
Craig Topper8a13c412014-05-21 05:09:00 +00001635 assert(ShouldDeleteCondition != nullptr);
Timur Iskhodzhanovee6bc532013-02-13 08:37:51 +00001636 }
1637
Craig Topper4f12f102014-03-12 06:41:41 +00001638 void Emit(CodeGenFunction &CGF, Flags flags) override {
Timur Iskhodzhanovee6bc532013-02-13 08:37:51 +00001639 llvm::BasicBlock *callDeleteBB = CGF.createBasicBlock("dtor.call_delete");
1640 llvm::BasicBlock *continueBB = CGF.createBasicBlock("dtor.continue");
1641 llvm::Value *ShouldCallDelete
1642 = CGF.Builder.CreateIsNull(ShouldDeleteCondition);
1643 CGF.Builder.CreateCondBr(ShouldCallDelete, continueBB, callDeleteBB);
1644
1645 CGF.EmitBlock(callDeleteBB);
1646 const CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(CGF.CurCodeDecl);
1647 const CXXRecordDecl *ClassDecl = Dtor->getParent();
1648 CGF.EmitDeleteCall(Dtor->getOperatorDelete(), CGF.LoadCXXThis(),
1649 CGF.getContext().getTagDeclType(ClassDecl));
1650 CGF.Builder.CreateBr(continueBB);
1651
1652 CGF.EmitBlock(continueBB);
1653 }
1654 };
1655
David Blaikie7e70d682015-08-18 22:40:54 +00001656 class DestroyField final : public EHScopeStack::Cleanup {
John McCall4bd0fb12011-07-12 16:41:08 +00001657 const FieldDecl *field;
Peter Collingbourne1425b452012-01-26 03:33:36 +00001658 CodeGenFunction::Destroyer *destroyer;
John McCall4bd0fb12011-07-12 16:41:08 +00001659 bool useEHCleanupForArray;
John McCallf99a6312010-07-21 05:30:47 +00001660
John McCall4bd0fb12011-07-12 16:41:08 +00001661 public:
1662 DestroyField(const FieldDecl *field, CodeGenFunction::Destroyer *destroyer,
1663 bool useEHCleanupForArray)
Naomi Musgrave866af2d2015-09-03 23:02:30 +00001664 : field(field), destroyer(destroyer),
1665 useEHCleanupForArray(useEHCleanupForArray) {}
John McCallf99a6312010-07-21 05:30:47 +00001666
Craig Topper4f12f102014-03-12 06:41:41 +00001667 void Emit(CodeGenFunction &CGF, Flags flags) override {
John McCall4bd0fb12011-07-12 16:41:08 +00001668 // Find the address of the field.
John McCall7f416cc2015-09-08 08:05:57 +00001669 Address thisValue = CGF.LoadCXXThisAddress();
Eli Friedman7f1ff602012-04-16 03:54:45 +00001670 QualType RecordTy = CGF.getContext().getTagDeclType(field->getParent());
1671 LValue ThisLV = CGF.MakeAddrLValue(thisValue, RecordTy);
1672 LValue LV = CGF.EmitLValueForField(ThisLV, field);
John McCall4bd0fb12011-07-12 16:41:08 +00001673 assert(LV.isSimple());
Justin Bogner1cd11f12015-05-20 15:53:59 +00001674
John McCall4bd0fb12011-07-12 16:41:08 +00001675 CGF.emitDestroy(LV.getAddress(), field->getType(), destroyer,
John McCall30317fd2011-07-12 20:27:29 +00001676 flags.isForNormalCleanup() && useEHCleanupForArray);
John McCallf99a6312010-07-21 05:30:47 +00001677 }
1678 };
Naomi Musgrave866af2d2015-09-03 23:02:30 +00001679
Naomi Musgrave703835c2015-09-16 00:38:22 +00001680 static void EmitSanitizerDtorCallback(CodeGenFunction &CGF, llvm::Value *Ptr,
1681 CharUnits::QuantityType PoisonSize) {
1682 // Pass in void pointer and size of region as arguments to runtime
1683 // function
1684 llvm::Value *Args[] = {CGF.Builder.CreateBitCast(Ptr, CGF.VoidPtrTy),
1685 llvm::ConstantInt::get(CGF.SizeTy, PoisonSize)};
1686
1687 llvm::Type *ArgTypes[] = {CGF.VoidPtrTy, CGF.SizeTy};
1688
1689 llvm::FunctionType *FnType =
1690 llvm::FunctionType::get(CGF.VoidTy, ArgTypes, false);
1691 llvm::Value *Fn =
1692 CGF.CGM.CreateRuntimeFunction(FnType, "__sanitizer_dtor_callback");
1693 CGF.EmitNounwindRuntimeCall(Fn, Args);
1694 }
1695
1696 class SanitizeDtorMembers final : public EHScopeStack::Cleanup {
Naomi Musgrave866af2d2015-09-03 23:02:30 +00001697 const CXXDestructorDecl *Dtor;
1698
1699 public:
Naomi Musgrave703835c2015-09-16 00:38:22 +00001700 SanitizeDtorMembers(const CXXDestructorDecl *Dtor) : Dtor(Dtor) {}
Naomi Musgrave866af2d2015-09-03 23:02:30 +00001701
1702 // Generate function call for handling object poisoning.
1703 // Disables tail call elimination, to prevent the current stack frame
1704 // from disappearing from the stack trace.
1705 void Emit(CodeGenFunction &CGF, Flags flags) override {
1706 const ASTRecordLayout &Layout =
1707 CGF.getContext().getASTRecordLayout(Dtor->getParent());
1708
1709 // Nothing to poison.
1710 if (Layout.getFieldCount() == 0)
1711 return;
1712
1713 // Prevent the current stack frame from disappearing from the stack trace.
1714 CGF.CurFn->addFnAttr("disable-tail-calls", "true");
1715
1716 // Construct pointer to region to begin poisoning, and calculate poison
1717 // size, so that only members declared in this class are poisoned.
1718 ASTContext &Context = CGF.getContext();
1719 unsigned fieldIndex = 0;
1720 int startIndex = -1;
1721 // RecordDecl::field_iterator Field;
1722 for (const FieldDecl *Field : Dtor->getParent()->fields()) {
1723 // Poison field if it is trivial
1724 if (FieldHasTrivialDestructorBody(Context, Field)) {
1725 // Start sanitizing at this field
1726 if (startIndex < 0)
1727 startIndex = fieldIndex;
1728
1729 // Currently on the last field, and it must be poisoned with the
1730 // current block.
1731 if (fieldIndex == Layout.getFieldCount() - 1) {
Naomi Musgrave703835c2015-09-16 00:38:22 +00001732 PoisonMembers(CGF, startIndex, Layout.getFieldCount());
Naomi Musgrave866af2d2015-09-03 23:02:30 +00001733 }
1734 } else if (startIndex >= 0) {
1735 // No longer within a block of memory to poison, so poison the block
Naomi Musgrave703835c2015-09-16 00:38:22 +00001736 PoisonMembers(CGF, startIndex, fieldIndex);
Naomi Musgrave866af2d2015-09-03 23:02:30 +00001737 // Re-set the start index
1738 startIndex = -1;
1739 }
1740 fieldIndex += 1;
1741 }
1742 }
1743
1744 private:
NAKAMURA Takumif6cef72f2015-09-04 05:19:31 +00001745 /// \param layoutStartOffset index of the ASTRecordLayout field to
Naomi Musgrave866af2d2015-09-03 23:02:30 +00001746 /// start poisoning (inclusive)
NAKAMURA Takumif6cef72f2015-09-04 05:19:31 +00001747 /// \param layoutEndOffset index of the ASTRecordLayout field to
Naomi Musgrave866af2d2015-09-03 23:02:30 +00001748 /// end poisoning (exclusive)
Naomi Musgrave703835c2015-09-16 00:38:22 +00001749 void PoisonMembers(CodeGenFunction &CGF, unsigned layoutStartOffset,
Naomi Musgrave866af2d2015-09-03 23:02:30 +00001750 unsigned layoutEndOffset) {
1751 ASTContext &Context = CGF.getContext();
1752 const ASTRecordLayout &Layout =
1753 Context.getASTRecordLayout(Dtor->getParent());
1754
1755 llvm::ConstantInt *OffsetSizePtr = llvm::ConstantInt::get(
1756 CGF.SizeTy,
1757 Context.toCharUnitsFromBits(Layout.getFieldOffset(layoutStartOffset))
1758 .getQuantity());
1759
1760 llvm::Value *OffsetPtr = CGF.Builder.CreateGEP(
1761 CGF.Builder.CreateBitCast(CGF.LoadCXXThis(), CGF.Int8PtrTy),
1762 OffsetSizePtr);
1763
1764 CharUnits::QuantityType PoisonSize;
1765 if (layoutEndOffset >= Layout.getFieldCount()) {
1766 PoisonSize = Layout.getNonVirtualSize().getQuantity() -
1767 Context.toCharUnitsFromBits(
1768 Layout.getFieldOffset(layoutStartOffset))
1769 .getQuantity();
1770 } else {
1771 PoisonSize = Context.toCharUnitsFromBits(
1772 Layout.getFieldOffset(layoutEndOffset) -
1773 Layout.getFieldOffset(layoutStartOffset))
1774 .getQuantity();
1775 }
1776
1777 if (PoisonSize == 0)
1778 return;
1779
Naomi Musgrave703835c2015-09-16 00:38:22 +00001780 EmitSanitizerDtorCallback(CGF, OffsetPtr, PoisonSize);
Naomi Musgrave866af2d2015-09-03 23:02:30 +00001781 }
1782 };
Naomi Musgrave703835c2015-09-16 00:38:22 +00001783
1784 class SanitizeDtorVTable final : public EHScopeStack::Cleanup {
1785 const CXXDestructorDecl *Dtor;
1786
1787 public:
1788 SanitizeDtorVTable(const CXXDestructorDecl *Dtor) : Dtor(Dtor) {}
1789
1790 // Generate function call for handling vtable pointer poisoning.
1791 void Emit(CodeGenFunction &CGF, Flags flags) override {
1792 assert(Dtor->getParent()->isDynamicClass());
NAKAMURA Takumiee82b492015-09-16 06:26:56 +00001793 (void)Dtor;
Naomi Musgrave703835c2015-09-16 00:38:22 +00001794 ASTContext &Context = CGF.getContext();
1795 // Poison vtable and vtable ptr if they exist for this class.
1796 llvm::Value *VTablePtr = CGF.LoadCXXThis();
1797
1798 CharUnits::QuantityType PoisonSize =
1799 Context.toCharUnitsFromBits(CGF.PointerWidthInBits).getQuantity();
1800 // Pass in void pointer and size of region as arguments to runtime
1801 // function
1802 EmitSanitizerDtorCallback(CGF, VTablePtr, PoisonSize);
1803 }
1804 };
Hans Wennborgdcfba332015-10-06 23:40:43 +00001805} // end anonymous namespace
John McCallf99a6312010-07-21 05:30:47 +00001806
Hans Wennborgdeff7032013-12-18 01:39:59 +00001807/// \brief Emit all code that comes at the end of class's
Anders Carlssonfb404882009-12-24 22:46:43 +00001808/// destructor. This is to call destructors on members and base classes
1809/// in reverse order of their construction.
John McCallf99a6312010-07-21 05:30:47 +00001810void CodeGenFunction::EnterDtorCleanups(const CXXDestructorDecl *DD,
1811 CXXDtorType DtorType) {
Hans Wennborg853ae942014-05-30 16:59:42 +00001812 assert((!DD->isTrivial() || DD->hasAttr<DLLExportAttr>()) &&
1813 "Should not emit dtor epilogue for non-exported trivial dtor!");
Anders Carlssonfb404882009-12-24 22:46:43 +00001814
John McCallf99a6312010-07-21 05:30:47 +00001815 // The deleting-destructor phase just needs to call the appropriate
1816 // operator delete that Sema picked up.
John McCall5c60a6f2010-02-18 19:59:28 +00001817 if (DtorType == Dtor_Deleting) {
Justin Bogner1cd11f12015-05-20 15:53:59 +00001818 assert(DD->getOperatorDelete() &&
Hans Wennborgdeff7032013-12-18 01:39:59 +00001819 "operator delete missing - EnterDtorCleanups");
Timur Iskhodzhanovee6bc532013-02-13 08:37:51 +00001820 if (CXXStructorImplicitParamValue) {
1821 // If there is an implicit param to the deleting dtor, it's a boolean
1822 // telling whether we should call delete at the end of the dtor.
1823 EHStack.pushCleanup<CallDtorDeleteConditional>(
1824 NormalAndEHCleanup, CXXStructorImplicitParamValue);
1825 } else {
1826 EHStack.pushCleanup<CallDtorDelete>(NormalAndEHCleanup);
1827 }
John McCall5c60a6f2010-02-18 19:59:28 +00001828 return;
1829 }
1830
John McCallf99a6312010-07-21 05:30:47 +00001831 const CXXRecordDecl *ClassDecl = DD->getParent();
1832
Richard Smith20104042011-09-18 12:11:43 +00001833 // Unions have no bases and do not call field destructors.
1834 if (ClassDecl->isUnion())
1835 return;
1836
John McCallf99a6312010-07-21 05:30:47 +00001837 // The complete-destructor phase just destructs all the virtual bases.
John McCall5c60a6f2010-02-18 19:59:28 +00001838 if (DtorType == Dtor_Complete) {
Naomi Musgrave703835c2015-09-16 00:38:22 +00001839 // Poison the vtable pointer such that access after the base
1840 // and member destructors are invoked is invalid.
1841 if (CGM.getCodeGenOpts().SanitizeMemoryUseAfterDtor &&
1842 SanOpts.has(SanitizerKind::Memory) && ClassDecl->getNumVBases() &&
1843 ClassDecl->isPolymorphic())
1844 EHStack.pushCleanup<SanitizeDtorVTable>(NormalAndEHCleanup, DD);
John McCallf99a6312010-07-21 05:30:47 +00001845
1846 // We push them in the forward order so that they'll be popped in
1847 // the reverse order.
Aaron Ballman445a9392014-03-13 16:15:17 +00001848 for (const auto &Base : ClassDecl->vbases()) {
John McCall5c60a6f2010-02-18 19:59:28 +00001849 CXXRecordDecl *BaseClassDecl
1850 = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
Justin Bogner1cd11f12015-05-20 15:53:59 +00001851
John McCall5c60a6f2010-02-18 19:59:28 +00001852 // Ignore trivial destructors.
1853 if (BaseClassDecl->hasTrivialDestructor())
1854 continue;
John McCallf99a6312010-07-21 05:30:47 +00001855
John McCallcda666c2010-07-21 07:22:38 +00001856 EHStack.pushCleanup<CallBaseDtor>(NormalAndEHCleanup,
1857 BaseClassDecl,
1858 /*BaseIsVirtual*/ true);
John McCall5c60a6f2010-02-18 19:59:28 +00001859 }
John McCallf99a6312010-07-21 05:30:47 +00001860
John McCall5c60a6f2010-02-18 19:59:28 +00001861 return;
1862 }
1863
1864 assert(DtorType == Dtor_Base);
Naomi Musgrave703835c2015-09-16 00:38:22 +00001865 // Poison the vtable pointer if it has no virtual bases, but inherits
1866 // virtual functions.
1867 if (CGM.getCodeGenOpts().SanitizeMemoryUseAfterDtor &&
1868 SanOpts.has(SanitizerKind::Memory) && !ClassDecl->getNumVBases() &&
1869 ClassDecl->isPolymorphic())
1870 EHStack.pushCleanup<SanitizeDtorVTable>(NormalAndEHCleanup, DD);
Justin Bogner1cd11f12015-05-20 15:53:59 +00001871
John McCallf99a6312010-07-21 05:30:47 +00001872 // Destroy non-virtual bases.
Aaron Ballman574705e2014-03-13 15:41:46 +00001873 for (const auto &Base : ClassDecl->bases()) {
John McCallf99a6312010-07-21 05:30:47 +00001874 // Ignore virtual bases.
1875 if (Base.isVirtual())
1876 continue;
Justin Bogner1cd11f12015-05-20 15:53:59 +00001877
John McCallf99a6312010-07-21 05:30:47 +00001878 CXXRecordDecl *BaseClassDecl = Base.getType()->getAsCXXRecordDecl();
Justin Bogner1cd11f12015-05-20 15:53:59 +00001879
John McCallf99a6312010-07-21 05:30:47 +00001880 // Ignore trivial destructors.
1881 if (BaseClassDecl->hasTrivialDestructor())
1882 continue;
John McCall5c60a6f2010-02-18 19:59:28 +00001883
John McCallcda666c2010-07-21 07:22:38 +00001884 EHStack.pushCleanup<CallBaseDtor>(NormalAndEHCleanup,
1885 BaseClassDecl,
1886 /*BaseIsVirtual*/ false);
John McCallf99a6312010-07-21 05:30:47 +00001887 }
1888
Naomi Musgrave866af2d2015-09-03 23:02:30 +00001889 // Poison fields such that access after their destructors are
1890 // invoked, and before the base class destructor runs, is invalid.
1891 if (CGM.getCodeGenOpts().SanitizeMemoryUseAfterDtor &&
1892 SanOpts.has(SanitizerKind::Memory))
Naomi Musgrave703835c2015-09-16 00:38:22 +00001893 EHStack.pushCleanup<SanitizeDtorMembers>(NormalAndEHCleanup, DD);
Naomi Musgrave866af2d2015-09-03 23:02:30 +00001894
John McCallf99a6312010-07-21 05:30:47 +00001895 // Destroy direct fields.
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00001896 for (const auto *Field : ClassDecl->fields()) {
1897 QualType type = Field->getType();
John McCall4bd0fb12011-07-12 16:41:08 +00001898 QualType::DestructionKind dtorKind = type.isDestructedType();
1899 if (!dtorKind) continue;
John McCallf99a6312010-07-21 05:30:47 +00001900
Richard Smith921bd202012-02-26 09:11:52 +00001901 // Anonymous union members do not have their destructors called.
1902 const RecordType *RT = type->getAsUnionType();
1903 if (RT && RT->getDecl()->isAnonymousStructOrUnion()) continue;
1904
John McCall4bd0fb12011-07-12 16:41:08 +00001905 CleanupKind cleanupKind = getCleanupKind(dtorKind);
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00001906 EHStack.pushCleanup<DestroyField>(cleanupKind, Field,
John McCall4bd0fb12011-07-12 16:41:08 +00001907 getDestroyer(dtorKind),
1908 cleanupKind & EHCleanup);
Anders Carlssonfb404882009-12-24 22:46:43 +00001909 }
Anders Carlssonfb404882009-12-24 22:46:43 +00001910}
1911
John McCallf677a8e2011-07-13 06:10:41 +00001912/// EmitCXXAggrConstructorCall - Emit a loop to call a particular
1913/// constructor for each of several members of an array.
Douglas Gregor05fc5be2010-07-21 01:10:17 +00001914///
John McCallf677a8e2011-07-13 06:10:41 +00001915/// \param ctor the constructor to call for each element
John McCallf677a8e2011-07-13 06:10:41 +00001916/// \param arrayType the type of the array to initialize
1917/// \param arrayBegin an arrayType*
1918/// \param zeroInitialize true if each element should be
1919/// zero-initialized before it is constructed
Alexey Samsonov70b9c012014-08-21 20:26:47 +00001920void CodeGenFunction::EmitCXXAggrConstructorCall(
1921 const CXXConstructorDecl *ctor, const ConstantArrayType *arrayType,
John McCall7f416cc2015-09-08 08:05:57 +00001922 Address arrayBegin, const CXXConstructExpr *E, bool zeroInitialize) {
John McCallf677a8e2011-07-13 06:10:41 +00001923 QualType elementType;
1924 llvm::Value *numElements =
1925 emitArrayLength(arrayType, elementType, arrayBegin);
Anders Carlsson27da15b2010-01-01 20:29:01 +00001926
Alexey Samsonov70b9c012014-08-21 20:26:47 +00001927 EmitCXXAggrConstructorCall(ctor, numElements, arrayBegin, E, zeroInitialize);
Anders Carlsson27da15b2010-01-01 20:29:01 +00001928}
1929
John McCallf677a8e2011-07-13 06:10:41 +00001930/// EmitCXXAggrConstructorCall - Emit a loop to call a particular
1931/// constructor for each of several members of an array.
1932///
1933/// \param ctor the constructor to call for each element
1934/// \param numElements the number of elements in the array;
John McCall6549b312011-07-13 07:37:11 +00001935/// may be zero
NAKAMURA Takumiff7a9252015-09-08 09:42:41 +00001936/// \param arrayBase a T*, where T is the type constructed by ctor
John McCallf677a8e2011-07-13 06:10:41 +00001937/// \param zeroInitialize true if each element should be
1938/// zero-initialized before it is constructed
Alexey Samsonov70b9c012014-08-21 20:26:47 +00001939void CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *ctor,
1940 llvm::Value *numElements,
John McCall7f416cc2015-09-08 08:05:57 +00001941 Address arrayBase,
Alexey Samsonov70b9c012014-08-21 20:26:47 +00001942 const CXXConstructExpr *E,
1943 bool zeroInitialize) {
John McCall6549b312011-07-13 07:37:11 +00001944 // It's legal for numElements to be zero. This can happen both
1945 // dynamically, because x can be zero in 'new A[x]', and statically,
1946 // because of GCC extensions that permit zero-length arrays. There
1947 // are probably legitimate places where we could assume that this
1948 // doesn't happen, but it's not clear that it's worth it.
Craig Topper8a13c412014-05-21 05:09:00 +00001949 llvm::BranchInst *zeroCheckBranch = nullptr;
John McCall6549b312011-07-13 07:37:11 +00001950
1951 // Optimize for a constant count.
1952 llvm::ConstantInt *constantCount
1953 = dyn_cast<llvm::ConstantInt>(numElements);
1954 if (constantCount) {
1955 // Just skip out if the constant count is zero.
1956 if (constantCount->isZero()) return;
1957
1958 // Otherwise, emit the check.
1959 } else {
1960 llvm::BasicBlock *loopBB = createBasicBlock("new.ctorloop");
1961 llvm::Value *iszero = Builder.CreateIsNull(numElements, "isempty");
1962 zeroCheckBranch = Builder.CreateCondBr(iszero, loopBB, loopBB);
1963 EmitBlock(loopBB);
1964 }
Justin Bogner1cd11f12015-05-20 15:53:59 +00001965
John McCallf677a8e2011-07-13 06:10:41 +00001966 // Find the end of the array.
John McCall7f416cc2015-09-08 08:05:57 +00001967 llvm::Value *arrayBegin = arrayBase.getPointer();
John McCallf677a8e2011-07-13 06:10:41 +00001968 llvm::Value *arrayEnd = Builder.CreateInBoundsGEP(arrayBegin, numElements,
1969 "arrayctor.end");
Anders Carlsson27da15b2010-01-01 20:29:01 +00001970
John McCallf677a8e2011-07-13 06:10:41 +00001971 // Enter the loop, setting up a phi for the current location to initialize.
1972 llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
1973 llvm::BasicBlock *loopBB = createBasicBlock("arrayctor.loop");
1974 EmitBlock(loopBB);
1975 llvm::PHINode *cur = Builder.CreatePHI(arrayBegin->getType(), 2,
1976 "arrayctor.cur");
1977 cur->addIncoming(arrayBegin, entryBB);
Anders Carlsson27da15b2010-01-01 20:29:01 +00001978
Anders Carlsson27da15b2010-01-01 20:29:01 +00001979 // Inside the loop body, emit the constructor call on the array element.
John McCallf677a8e2011-07-13 06:10:41 +00001980
John McCall7f416cc2015-09-08 08:05:57 +00001981 // The alignment of the base, adjusted by the size of a single element,
1982 // provides a conservative estimate of the alignment of every element.
1983 // (This assumes we never start tracking offsetted alignments.)
1984 //
1985 // Note that these are complete objects and so we don't need to
1986 // use the non-virtual size or alignment.
John McCallf677a8e2011-07-13 06:10:41 +00001987 QualType type = getContext().getTypeDeclType(ctor->getParent());
John McCall7f416cc2015-09-08 08:05:57 +00001988 CharUnits eltAlignment =
1989 arrayBase.getAlignment()
1990 .alignmentOfArrayElement(getContext().getTypeSizeInChars(type));
1991 Address curAddr = Address(cur, eltAlignment);
Anders Carlsson27da15b2010-01-01 20:29:01 +00001992
Douglas Gregor05fc5be2010-07-21 01:10:17 +00001993 // Zero initialize the storage, if requested.
John McCallf677a8e2011-07-13 06:10:41 +00001994 if (zeroInitialize)
John McCall7f416cc2015-09-08 08:05:57 +00001995 EmitNullInitialization(curAddr, type);
Justin Bogner1cd11f12015-05-20 15:53:59 +00001996
1997 // C++ [class.temporary]p4:
Anders Carlsson27da15b2010-01-01 20:29:01 +00001998 // There are two contexts in which temporaries are destroyed at a different
1999 // point than the end of the full-expression. The first context is when a
Justin Bogner1cd11f12015-05-20 15:53:59 +00002000 // default constructor is called to initialize an element of an array.
2001 // If the constructor has one or more default arguments, the destruction of
2002 // every temporary created in a default argument expression is sequenced
Anders Carlsson27da15b2010-01-01 20:29:01 +00002003 // before the construction of the next array element, if any.
Justin Bogner1cd11f12015-05-20 15:53:59 +00002004
Anders Carlssonb9fd57f2010-03-30 03:14:41 +00002005 {
John McCallbd309292010-07-06 01:34:17 +00002006 RunCleanupsScope Scope(*this);
Anders Carlsson27da15b2010-01-01 20:29:01 +00002007
John McCallf677a8e2011-07-13 06:10:41 +00002008 // Evaluate the constructor and its arguments in a regular
2009 // partial-destroy cleanup.
David Blaikiebbafb8a2012-03-11 07:00:24 +00002010 if (getLangOpts().Exceptions &&
John McCallf677a8e2011-07-13 06:10:41 +00002011 !ctor->getParent()->hasTrivialDestructor()) {
2012 Destroyer *destroyer = destroyCXXObject;
John McCall7f416cc2015-09-08 08:05:57 +00002013 pushRegularPartialArrayCleanup(arrayBegin, cur, type, eltAlignment,
2014 *destroyer);
John McCallf677a8e2011-07-13 06:10:41 +00002015 }
2016
Alexey Samsonov70b9c012014-08-21 20:26:47 +00002017 EmitCXXConstructorCall(ctor, Ctor_Complete, /*ForVirtualBase=*/false,
John McCall7f416cc2015-09-08 08:05:57 +00002018 /*Delegating=*/false, curAddr, E);
Anders Carlssonb9fd57f2010-03-30 03:14:41 +00002019 }
Anders Carlsson27da15b2010-01-01 20:29:01 +00002020
John McCallf677a8e2011-07-13 06:10:41 +00002021 // Go to the next element.
2022 llvm::Value *next =
2023 Builder.CreateInBoundsGEP(cur, llvm::ConstantInt::get(SizeTy, 1),
2024 "arrayctor.next");
2025 cur->addIncoming(next, Builder.GetInsertBlock());
Anders Carlsson27da15b2010-01-01 20:29:01 +00002026
John McCallf677a8e2011-07-13 06:10:41 +00002027 // Check whether that's the end of the loop.
2028 llvm::Value *done = Builder.CreateICmpEQ(next, arrayEnd, "arrayctor.done");
2029 llvm::BasicBlock *contBB = createBasicBlock("arrayctor.cont");
2030 Builder.CreateCondBr(done, contBB, loopBB);
Anders Carlsson27da15b2010-01-01 20:29:01 +00002031
John McCall6549b312011-07-13 07:37:11 +00002032 // Patch the earlier check to skip over the loop.
2033 if (zeroCheckBranch) zeroCheckBranch->setSuccessor(0, contBB);
2034
John McCallf677a8e2011-07-13 06:10:41 +00002035 EmitBlock(contBB);
Anders Carlsson27da15b2010-01-01 20:29:01 +00002036}
2037
John McCall82fe67b2011-07-09 01:37:26 +00002038void CodeGenFunction::destroyCXXObject(CodeGenFunction &CGF,
John McCall7f416cc2015-09-08 08:05:57 +00002039 Address addr,
John McCall82fe67b2011-07-09 01:37:26 +00002040 QualType type) {
2041 const RecordType *rtype = type->castAs<RecordType>();
2042 const CXXRecordDecl *record = cast<CXXRecordDecl>(rtype->getDecl());
2043 const CXXDestructorDecl *dtor = record->getDestructor();
2044 assert(!dtor->isTrivial());
2045 CGF.EmitCXXDestructorCall(dtor, Dtor_Complete, /*for vbase*/ false,
Douglas Gregor61535002013-01-31 05:50:40 +00002046 /*Delegating=*/false, addr);
John McCall82fe67b2011-07-09 01:37:26 +00002047}
2048
Alexey Samsonov70b9c012014-08-21 20:26:47 +00002049void CodeGenFunction::EmitCXXConstructorCall(const CXXConstructorDecl *D,
2050 CXXCtorType Type,
2051 bool ForVirtualBase,
John McCall7f416cc2015-09-08 08:05:57 +00002052 bool Delegating, Address This,
Alexey Samsonov70b9c012014-08-21 20:26:47 +00002053 const CXXConstructExpr *E) {
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002054 const CXXRecordDecl *ClassDecl = D->getParent();
2055
Richard Smith419bd092015-04-29 19:26:57 +00002056 // C++11 [class.mfct.non-static]p2:
2057 // If a non-static member function of a class X is called for an object that
2058 // is not of type X, or of a type derived from X, the behavior is undefined.
2059 // FIXME: Provide a source location here.
John McCall7f416cc2015-09-08 08:05:57 +00002060 EmitTypeCheck(CodeGenFunction::TCK_ConstructorCall, SourceLocation(),
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002061 This.getPointer(), getContext().getRecordType(ClassDecl));
John McCallca972cd2010-02-06 00:25:16 +00002062
Richard Smith419bd092015-04-29 19:26:57 +00002063 if (D->isTrivial() && D->isDefaultConstructor()) {
2064 assert(E->getNumArgs() == 0 && "trivial default ctor with args");
2065 return;
2066 }
2067
2068 // If this is a trivial constructor, just emit what's needed. If this is a
2069 // union copy constructor, we must emit a memcpy, because the AST does not
2070 // model that copy.
2071 if (isMemcpyEquivalentSpecialMember(D)) {
Alexey Samsonov70b9c012014-08-21 20:26:47 +00002072 assert(E->getNumArgs() == 1 && "unexpected argcount for trivial ctor");
John McCallca972cd2010-02-06 00:25:16 +00002073
Alexey Samsonov70b9c012014-08-21 20:26:47 +00002074 const Expr *Arg = E->getArg(0);
David Majnemerfd1e7392015-02-03 23:04:06 +00002075 QualType SrcTy = Arg->getType();
John McCall7f416cc2015-09-08 08:05:57 +00002076 Address Src = EmitLValue(Arg).getAddress();
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002077 QualType DestTy = getContext().getTypeDeclType(ClassDecl);
David Majnemerfd1e7392015-02-03 23:04:06 +00002078 EmitAggregateCopyCtor(This, Src, DestTy, SrcTy);
Anders Carlsson27da15b2010-01-01 20:29:01 +00002079 return;
2080 }
2081
Reid Kleckner89077a12013-12-17 19:46:40 +00002082 CallArgList Args;
2083
2084 // Push the this ptr.
John McCall7f416cc2015-09-08 08:05:57 +00002085 Args.add(RValue::get(This.getPointer()), D->getThisType(getContext()));
Reid Kleckner89077a12013-12-17 19:46:40 +00002086
2087 // Add the rest of the user-supplied arguments.
2088 const FunctionProtoType *FPT = D->getType()->castAs<FunctionProtoType>();
David Blaikief05779e2015-07-21 18:37:18 +00002089 EmitCallArgs(Args, FPT, E->arguments(), E->getConstructor());
Reid Kleckner89077a12013-12-17 19:46:40 +00002090
2091 // Insert any ABI-specific implicit constructor arguments.
2092 unsigned ExtraArgs = CGM.getCXXABI().addImplicitConstructorArgs(
2093 *this, D, Type, ForVirtualBase, Delegating, Args);
2094
2095 // Emit the call.
Rafael Espindola1ac0ec82014-09-11 15:42:06 +00002096 llvm::Value *Callee = CGM.getAddrOfCXXStructor(D, getFromCtorType(Type));
Reid Kleckner89077a12013-12-17 19:46:40 +00002097 const CGFunctionInfo &Info =
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002098 CGM.getTypes().arrangeCXXConstructorCall(Args, D, Type, ExtraArgs);
Reid Kleckner89077a12013-12-17 19:46:40 +00002099 EmitCall(Info, Callee, ReturnValueSlot(), Args, D);
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002100
2101 // Generate vtable assumptions if we're constructing a complete object
2102 // with a vtable. We don't do this for base subobjects for two reasons:
2103 // first, it's incorrect for classes with virtual bases, and second, we're
2104 // about to overwrite the vptrs anyway.
2105 // We also have to make sure if we can refer to vtable:
2106 // - Otherwise we can refer to vtable if it's safe to speculatively emit.
2107 // FIXME: If vtable is used by ctor/dtor, or if vtable is external and we are
2108 // sure that definition of vtable is not hidden,
2109 // then we are always safe to refer to it.
Piotr Padlewski69dc9712015-09-28 20:30:22 +00002110 // FIXME: It looks like InstCombine is very inefficient on dealing with
2111 // assumes. Make assumption loads require -fstrict-vtable-pointers temporarily.
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002112 if (CGM.getCodeGenOpts().OptimizationLevel > 0 &&
2113 ClassDecl->isDynamicClass() && Type != Ctor_Base &&
Piotr Padlewski69dc9712015-09-28 20:30:22 +00002114 CGM.getCXXABI().canSpeculativelyEmitVTable(ClassDecl) &&
2115 CGM.getCodeGenOpts().StrictVTablePointers)
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002116 EmitVTableAssumptionLoads(ClassDecl, This);
2117}
2118
2119void CodeGenFunction::EmitVTableAssumptionLoad(const VPtr &Vptr, Address This) {
2120 llvm::Value *VTableGlobal =
2121 CGM.getCXXABI().getVTableAddressPoint(Vptr.Base, Vptr.VTableClass);
2122 if (!VTableGlobal)
2123 return;
2124
2125 // We can just use the base offset in the complete class.
2126 CharUnits NonVirtualOffset = Vptr.Base.getBaseOffset();
2127
2128 if (!NonVirtualOffset.isZero())
2129 This =
2130 ApplyNonVirtualAndVirtualOffset(*this, This, NonVirtualOffset, nullptr,
2131 Vptr.VTableClass, Vptr.NearestVBase);
2132
Piotr Padlewski4b1ac722015-09-15 21:46:55 +00002133 llvm::Value *VPtrValue =
2134 GetVTablePtr(This, VTableGlobal->getType(), Vptr.VTableClass);
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002135 llvm::Value *Cmp =
2136 Builder.CreateICmpEQ(VPtrValue, VTableGlobal, "cmp.vtables");
2137 Builder.CreateAssumption(Cmp);
2138}
2139
2140void CodeGenFunction::EmitVTableAssumptionLoads(const CXXRecordDecl *ClassDecl,
2141 Address This) {
2142 if (CGM.getCXXABI().doStructorsInitializeVPtrs(ClassDecl))
2143 for (const VPtr &Vptr : getVTablePointers(ClassDecl))
2144 EmitVTableAssumptionLoad(Vptr, This);
Anders Carlsson27da15b2010-01-01 20:29:01 +00002145}
2146
John McCallf8ff7b92010-02-23 00:48:20 +00002147void
Fariborz Jahaniane988bda2010-11-13 21:53:34 +00002148CodeGenFunction::EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D,
John McCall7f416cc2015-09-08 08:05:57 +00002149 Address This, Address Src,
2150 const CXXConstructExpr *E) {
Richard Smith419bd092015-04-29 19:26:57 +00002151 if (isMemcpyEquivalentSpecialMember(D)) {
Alexey Samsonov96fd0a42014-08-26 20:18:26 +00002152 assert(E->getNumArgs() == 1 && "unexpected argcount for trivial ctor");
Sebastian Redl22653ba2011-08-30 19:58:05 +00002153 assert(D->isCopyOrMoveConstructor() &&
2154 "trivial 1-arg ctor not a copy/move ctor");
David Majnemerfd1e7392015-02-03 23:04:06 +00002155 EmitAggregateCopyCtor(This, Src,
2156 getContext().getTypeDeclType(D->getParent()),
Benjamin Kramerf48ee442015-07-18 14:35:53 +00002157 (*E->arg_begin())->getType());
Fariborz Jahaniane988bda2010-11-13 21:53:34 +00002158 return;
2159 }
Rafael Espindola1ac0ec82014-09-11 15:42:06 +00002160 llvm::Value *Callee = CGM.getAddrOfCXXStructor(D, StructorType::Complete);
Fariborz Jahaniane988bda2010-11-13 21:53:34 +00002161 assert(D->isInstance() &&
2162 "Trying to emit a member call expr on a static method!");
Justin Bogner1cd11f12015-05-20 15:53:59 +00002163
Reid Kleckner739756c2013-12-04 19:23:12 +00002164 const FunctionProtoType *FPT = D->getType()->castAs<FunctionProtoType>();
Justin Bogner1cd11f12015-05-20 15:53:59 +00002165
Fariborz Jahaniane988bda2010-11-13 21:53:34 +00002166 CallArgList Args;
Justin Bogner1cd11f12015-05-20 15:53:59 +00002167
Fariborz Jahaniane988bda2010-11-13 21:53:34 +00002168 // Push the this ptr.
John McCall7f416cc2015-09-08 08:05:57 +00002169 Args.add(RValue::get(This.getPointer()), D->getThisType(getContext()));
Justin Bogner1cd11f12015-05-20 15:53:59 +00002170
Fariborz Jahaniane988bda2010-11-13 21:53:34 +00002171 // Push the src ptr.
Alp Toker9cacbab2014-01-20 20:26:09 +00002172 QualType QT = *(FPT->param_type_begin());
Chris Lattner2192fe52011-07-18 04:24:23 +00002173 llvm::Type *t = CGM.getTypes().ConvertType(QT);
Fariborz Jahaniane988bda2010-11-13 21:53:34 +00002174 Src = Builder.CreateBitCast(Src, t);
John McCall7f416cc2015-09-08 08:05:57 +00002175 Args.add(RValue::get(Src.getPointer()), QT);
Reid Kleckner739756c2013-12-04 19:23:12 +00002176
Fariborz Jahaniane988bda2010-11-13 21:53:34 +00002177 // Skip over first argument (Src).
David Blaikief05779e2015-07-21 18:37:18 +00002178 EmitCallArgs(Args, FPT, drop_begin(E->arguments(), 1), E->getConstructor(),
Alexey Samsonov8e1162c2014-09-08 17:22:45 +00002179 /*ParamsToSkip*/ 1);
Reid Kleckner739756c2013-12-04 19:23:12 +00002180
John McCall8dda7b22012-07-07 06:41:13 +00002181 EmitCall(CGM.getTypes().arrangeCXXMethodCall(Args, FPT, RequiredArgs::All),
2182 Callee, ReturnValueSlot(), Args, D);
Fariborz Jahaniane988bda2010-11-13 21:53:34 +00002183}
2184
2185void
John McCallf8ff7b92010-02-23 00:48:20 +00002186CodeGenFunction::EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor,
2187 CXXCtorType CtorType,
Nick Lewycky2d84e842013-10-02 02:29:49 +00002188 const FunctionArgList &Args,
2189 SourceLocation Loc) {
John McCallf8ff7b92010-02-23 00:48:20 +00002190 CallArgList DelegateArgs;
2191
2192 FunctionArgList::const_iterator I = Args.begin(), E = Args.end();
2193 assert(I != E && "no parameters to constructor");
2194
2195 // this
Eli Friedman43dca6a2011-05-02 17:57:46 +00002196 DelegateArgs.add(RValue::get(LoadCXXThis()), (*I)->getType());
John McCallf8ff7b92010-02-23 00:48:20 +00002197 ++I;
2198
2199 // vtt
Timur Iskhodzhanov57cbe5c2013-02-27 13:46:31 +00002200 if (llvm::Value *VTT = GetVTTParameter(GlobalDecl(Ctor, CtorType),
Douglas Gregor61535002013-01-31 05:50:40 +00002201 /*ForVirtualBase=*/false,
2202 /*Delegating=*/true)) {
John McCallf8ff7b92010-02-23 00:48:20 +00002203 QualType VoidPP = getContext().getPointerType(getContext().VoidPtrTy);
Eli Friedman43dca6a2011-05-02 17:57:46 +00002204 DelegateArgs.add(RValue::get(VTT), VoidPP);
John McCallf8ff7b92010-02-23 00:48:20 +00002205
Peter Collingbourne66f82e62013-06-28 20:45:28 +00002206 if (CGM.getCXXABI().NeedsVTTParameter(CurGD)) {
John McCallf8ff7b92010-02-23 00:48:20 +00002207 assert(I != E && "cannot skip vtt parameter, already done with args");
John McCalla738c252011-03-09 04:27:21 +00002208 assert((*I)->getType() == VoidPP && "skipping parameter not of vtt type");
John McCallf8ff7b92010-02-23 00:48:20 +00002209 ++I;
2210 }
2211 }
2212
2213 // Explicit arguments.
2214 for (; I != E; ++I) {
John McCall32ea9692011-03-11 20:59:21 +00002215 const VarDecl *param = *I;
Nick Lewycky2d84e842013-10-02 02:29:49 +00002216 // FIXME: per-argument source location
2217 EmitDelegateCallArg(DelegateArgs, param, Loc);
John McCallf8ff7b92010-02-23 00:48:20 +00002218 }
2219
Rafael Espindola1ac0ec82014-09-11 15:42:06 +00002220 llvm::Value *Callee =
2221 CGM.getAddrOfCXXStructor(Ctor, getFromCtorType(CtorType));
Rafael Espindola8d2a19b2014-09-08 16:01:27 +00002222 EmitCall(CGM.getTypes()
2223 .arrangeCXXStructorDeclaration(Ctor, getFromCtorType(CtorType)),
Manman Ren01754612013-03-20 16:59:38 +00002224 Callee, ReturnValueSlot(), DelegateArgs, Ctor);
John McCallf8ff7b92010-02-23 00:48:20 +00002225}
2226
Alexis Hunt9d47faf2011-05-03 23:05:34 +00002227namespace {
David Blaikie7e70d682015-08-18 22:40:54 +00002228 struct CallDelegatingCtorDtor final : EHScopeStack::Cleanup {
Alexis Hunt9d47faf2011-05-03 23:05:34 +00002229 const CXXDestructorDecl *Dtor;
John McCall7f416cc2015-09-08 08:05:57 +00002230 Address Addr;
Alexis Hunt9d47faf2011-05-03 23:05:34 +00002231 CXXDtorType Type;
2232
John McCall7f416cc2015-09-08 08:05:57 +00002233 CallDelegatingCtorDtor(const CXXDestructorDecl *D, Address Addr,
Alexis Hunt9d47faf2011-05-03 23:05:34 +00002234 CXXDtorType Type)
2235 : Dtor(D), Addr(Addr), Type(Type) {}
2236
Craig Topper4f12f102014-03-12 06:41:41 +00002237 void Emit(CodeGenFunction &CGF, Flags flags) override {
Alexis Hunt9d47faf2011-05-03 23:05:34 +00002238 CGF.EmitCXXDestructorCall(Dtor, Type, /*ForVirtualBase=*/false,
Douglas Gregor61535002013-01-31 05:50:40 +00002239 /*Delegating=*/true, Addr);
Alexis Hunt9d47faf2011-05-03 23:05:34 +00002240 }
2241 };
Hans Wennborgdcfba332015-10-06 23:40:43 +00002242} // end anonymous namespace
Alexis Hunt9d47faf2011-05-03 23:05:34 +00002243
Alexis Hunt61bc1732011-05-01 07:04:31 +00002244void
2245CodeGenFunction::EmitDelegatingCXXConstructorCall(const CXXConstructorDecl *Ctor,
2246 const FunctionArgList &Args) {
2247 assert(Ctor->isDelegatingConstructor());
2248
John McCall7f416cc2015-09-08 08:05:57 +00002249 Address ThisPtr = LoadCXXThisAddress();
Alexis Hunt61bc1732011-05-01 07:04:31 +00002250
John McCall31168b02011-06-15 23:02:42 +00002251 AggValueSlot AggSlot =
John McCall7f416cc2015-09-08 08:05:57 +00002252 AggValueSlot::forAddr(ThisPtr, Qualifiers(),
John McCall8d6fc952011-08-25 20:40:09 +00002253 AggValueSlot::IsDestructed,
John McCalla5efa732011-08-25 23:04:34 +00002254 AggValueSlot::DoesNotNeedGCBarriers,
Chad Rosier615ed1a2012-03-29 17:37:10 +00002255 AggValueSlot::IsNotAliased);
Alexis Hunt61bc1732011-05-01 07:04:31 +00002256
2257 EmitAggExpr(Ctor->init_begin()[0]->getInit(), AggSlot);
Alexis Hunt61bc1732011-05-01 07:04:31 +00002258
Alexis Hunt9d47faf2011-05-03 23:05:34 +00002259 const CXXRecordDecl *ClassDecl = Ctor->getParent();
David Blaikiebbafb8a2012-03-11 07:00:24 +00002260 if (CGM.getLangOpts().Exceptions && !ClassDecl->hasTrivialDestructor()) {
Alexis Hunt9d47faf2011-05-03 23:05:34 +00002261 CXXDtorType Type =
2262 CurGD.getCtorType() == Ctor_Complete ? Dtor_Complete : Dtor_Base;
2263
2264 EHStack.pushCleanup<CallDelegatingCtorDtor>(EHCleanup,
2265 ClassDecl->getDestructor(),
2266 ThisPtr, Type);
2267 }
2268}
Alexis Hunt61bc1732011-05-01 07:04:31 +00002269
Anders Carlsson27da15b2010-01-01 20:29:01 +00002270void CodeGenFunction::EmitCXXDestructorCall(const CXXDestructorDecl *DD,
2271 CXXDtorType Type,
Anders Carlssonf8a71f02010-05-02 23:29:11 +00002272 bool ForVirtualBase,
Douglas Gregor61535002013-01-31 05:50:40 +00002273 bool Delegating,
John McCall7f416cc2015-09-08 08:05:57 +00002274 Address This) {
Reid Kleckner6fe771a2013-12-13 00:53:54 +00002275 CGM.getCXXABI().EmitDestructorCall(*this, DD, Type, ForVirtualBase,
2276 Delegating, This);
Anders Carlsson27da15b2010-01-01 20:29:01 +00002277}
2278
John McCall53cad2e2010-07-21 01:41:18 +00002279namespace {
David Blaikie7e70d682015-08-18 22:40:54 +00002280 struct CallLocalDtor final : EHScopeStack::Cleanup {
John McCall53cad2e2010-07-21 01:41:18 +00002281 const CXXDestructorDecl *Dtor;
John McCall7f416cc2015-09-08 08:05:57 +00002282 Address Addr;
John McCall53cad2e2010-07-21 01:41:18 +00002283
John McCall7f416cc2015-09-08 08:05:57 +00002284 CallLocalDtor(const CXXDestructorDecl *D, Address Addr)
John McCall53cad2e2010-07-21 01:41:18 +00002285 : Dtor(D), Addr(Addr) {}
2286
Craig Topper4f12f102014-03-12 06:41:41 +00002287 void Emit(CodeGenFunction &CGF, Flags flags) override {
John McCall53cad2e2010-07-21 01:41:18 +00002288 CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete,
Douglas Gregor61535002013-01-31 05:50:40 +00002289 /*ForVirtualBase=*/false,
2290 /*Delegating=*/false, Addr);
John McCall53cad2e2010-07-21 01:41:18 +00002291 }
2292 };
Alexander Kornienkoab9db512015-06-22 23:07:51 +00002293}
John McCall53cad2e2010-07-21 01:41:18 +00002294
John McCall8680f872010-07-21 06:29:51 +00002295void CodeGenFunction::PushDestructorCleanup(const CXXDestructorDecl *D,
John McCall7f416cc2015-09-08 08:05:57 +00002296 Address Addr) {
John McCallcda666c2010-07-21 07:22:38 +00002297 EHStack.pushCleanup<CallLocalDtor>(NormalAndEHCleanup, D, Addr);
John McCall8680f872010-07-21 06:29:51 +00002298}
2299
John McCall7f416cc2015-09-08 08:05:57 +00002300void CodeGenFunction::PushDestructorCleanup(QualType T, Address Addr) {
John McCallbd309292010-07-06 01:34:17 +00002301 CXXRecordDecl *ClassDecl = T->getAsCXXRecordDecl();
2302 if (!ClassDecl) return;
2303 if (ClassDecl->hasTrivialDestructor()) return;
2304
2305 const CXXDestructorDecl *D = ClassDecl->getDestructor();
John McCalla85af562011-04-28 02:15:35 +00002306 assert(D && D->isUsed() && "destructor not marked as used!");
John McCall8680f872010-07-21 06:29:51 +00002307 PushDestructorCleanup(D, Addr);
John McCallbd309292010-07-06 01:34:17 +00002308}
2309
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002310void CodeGenFunction::InitializeVTablePointer(const VPtr &Vptr) {
Anders Carlssone87fae92010-03-28 19:40:00 +00002311 // Compute the address point.
Timur Iskhodzhanov8b5987e2013-09-27 14:48:01 +00002312 llvm::Value *VTableAddressPoint =
2313 CGM.getCXXABI().getVTableAddressPointInStructor(
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002314 *this, Vptr.VTableClass, Vptr.Base, Vptr.NearestVBase);
2315
Timur Iskhodzhanov8b5987e2013-09-27 14:48:01 +00002316 if (!VTableAddressPoint)
2317 return;
Anders Carlssone87fae92010-03-28 19:40:00 +00002318
Anders Carlsson6a0227d2010-04-20 16:22:16 +00002319 // Compute where to store the address point.
Craig Topper8a13c412014-05-21 05:09:00 +00002320 llvm::Value *VirtualOffset = nullptr;
Ken Dyckcfc332c2011-03-23 00:45:26 +00002321 CharUnits NonVirtualOffset = CharUnits::Zero();
Justin Bogner1cd11f12015-05-20 15:53:59 +00002322
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002323 if (CGM.getCXXABI().isVirtualOffsetNeededForVTableField(*this, Vptr)) {
Anders Carlsson91baecf2010-04-20 18:05:10 +00002324 // We need to use the virtual base offset offset because the virtual base
2325 // might have a different offset in the most derived class.
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002326
2327 VirtualOffset = CGM.getCXXABI().GetVirtualBaseClassOffset(
2328 *this, LoadCXXThisAddress(), Vptr.VTableClass, Vptr.NearestVBase);
2329 NonVirtualOffset = Vptr.OffsetFromNearestVBase;
Anders Carlsson91baecf2010-04-20 18:05:10 +00002330 } else {
Anders Carlssonc58fb552010-05-03 00:29:58 +00002331 // We can just use the base offset in the complete class.
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002332 NonVirtualOffset = Vptr.Base.getBaseOffset();
Anders Carlsson91baecf2010-04-20 18:05:10 +00002333 }
Justin Bogner1cd11f12015-05-20 15:53:59 +00002334
Anders Carlssonc58fb552010-05-03 00:29:58 +00002335 // Apply the offsets.
John McCall7f416cc2015-09-08 08:05:57 +00002336 Address VTableField = LoadCXXThisAddress();
Justin Bogner1cd11f12015-05-20 15:53:59 +00002337
Ken Dyckcfc332c2011-03-23 00:45:26 +00002338 if (!NonVirtualOffset.isZero() || VirtualOffset)
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002339 VTableField = ApplyNonVirtualAndVirtualOffset(
2340 *this, VTableField, NonVirtualOffset, VirtualOffset, Vptr.VTableClass,
2341 Vptr.NearestVBase);
Anders Carlsson6a0227d2010-04-20 16:22:16 +00002342
Reid Kleckner8d585132014-12-03 21:00:21 +00002343 // Finally, store the address point. Use the same LLVM types as the field to
2344 // support optimization.
2345 llvm::Type *VTablePtrTy =
2346 llvm::FunctionType::get(CGM.Int32Ty, /*isVarArg=*/true)
2347 ->getPointerTo()
2348 ->getPointerTo();
2349 VTableField = Builder.CreateBitCast(VTableField, VTablePtrTy->getPointerTo());
2350 VTableAddressPoint = Builder.CreateBitCast(VTableAddressPoint, VTablePtrTy);
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002351
Kostya Serebryany141e46f2012-03-26 17:03:51 +00002352 llvm::StoreInst *Store = Builder.CreateStore(VTableAddressPoint, VTableField);
Piotr Padlewski4b1ac722015-09-15 21:46:55 +00002353 CGM.DecorateInstructionWithTBAA(Store, CGM.getTBAAInfoForVTablePtr());
2354 if (CGM.getCodeGenOpts().OptimizationLevel > 0 &&
2355 CGM.getCodeGenOpts().StrictVTablePointers)
2356 CGM.DecorateInstructionWithInvariantGroup(Store, Vptr.VTableClass);
Anders Carlssone87fae92010-03-28 19:40:00 +00002357}
2358
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002359CodeGenFunction::VPtrsVector
2360CodeGenFunction::getVTablePointers(const CXXRecordDecl *VTableClass) {
2361 CodeGenFunction::VPtrsVector VPtrsResult;
2362 VisitedVirtualBasesSetTy VBases;
2363 getVTablePointers(BaseSubobject(VTableClass, CharUnits::Zero()),
2364 /*NearestVBase=*/nullptr,
2365 /*OffsetFromNearestVBase=*/CharUnits::Zero(),
2366 /*BaseIsNonVirtualPrimaryBase=*/false, VTableClass, VBases,
2367 VPtrsResult);
2368 return VPtrsResult;
2369}
2370
2371void CodeGenFunction::getVTablePointers(BaseSubobject Base,
2372 const CXXRecordDecl *NearestVBase,
2373 CharUnits OffsetFromNearestVBase,
2374 bool BaseIsNonVirtualPrimaryBase,
2375 const CXXRecordDecl *VTableClass,
2376 VisitedVirtualBasesSetTy &VBases,
2377 VPtrsVector &Vptrs) {
Anders Carlssond5895932010-03-28 21:07:49 +00002378 // If this base is a non-virtual primary base the address point has already
2379 // been set.
2380 if (!BaseIsNonVirtualPrimaryBase) {
2381 // Initialize the vtable pointer for this base.
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002382 VPtr Vptr = {Base, NearestVBase, OffsetFromNearestVBase, VTableClass};
2383 Vptrs.push_back(Vptr);
Anders Carlssond5895932010-03-28 21:07:49 +00002384 }
Justin Bogner1cd11f12015-05-20 15:53:59 +00002385
Anders Carlssond5895932010-03-28 21:07:49 +00002386 const CXXRecordDecl *RD = Base.getBase();
2387
2388 // Traverse bases.
Aaron Ballman574705e2014-03-13 15:41:46 +00002389 for (const auto &I : RD->bases()) {
Anders Carlssond5895932010-03-28 21:07:49 +00002390 CXXRecordDecl *BaseDecl
Aaron Ballman574705e2014-03-13 15:41:46 +00002391 = cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
Anders Carlssond5895932010-03-28 21:07:49 +00002392
2393 // Ignore classes without a vtable.
2394 if (!BaseDecl->isDynamicClass())
2395 continue;
2396
Ken Dyck3fb4c892011-03-23 01:04:18 +00002397 CharUnits BaseOffset;
2398 CharUnits BaseOffsetFromNearestVBase;
Anders Carlsson948d3f42010-03-29 01:16:41 +00002399 bool BaseDeclIsNonVirtualPrimaryBase;
Anders Carlssond5895932010-03-28 21:07:49 +00002400
Aaron Ballman574705e2014-03-13 15:41:46 +00002401 if (I.isVirtual()) {
Anders Carlssond5895932010-03-28 21:07:49 +00002402 // Check if we've visited this virtual base before.
David Blaikie82e95a32014-11-19 07:49:47 +00002403 if (!VBases.insert(BaseDecl).second)
Anders Carlssond5895932010-03-28 21:07:49 +00002404 continue;
2405
Justin Bogner1cd11f12015-05-20 15:53:59 +00002406 const ASTRecordLayout &Layout =
Anders Carlssond5895932010-03-28 21:07:49 +00002407 getContext().getASTRecordLayout(VTableClass);
2408
Ken Dyck3fb4c892011-03-23 01:04:18 +00002409 BaseOffset = Layout.getVBaseClassOffset(BaseDecl);
2410 BaseOffsetFromNearestVBase = CharUnits::Zero();
Anders Carlsson948d3f42010-03-29 01:16:41 +00002411 BaseDeclIsNonVirtualPrimaryBase = false;
Anders Carlssond5895932010-03-28 21:07:49 +00002412 } else {
2413 const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
2414
Ken Dyck16ffcac2011-03-24 01:21:01 +00002415 BaseOffset = Base.getBaseOffset() + Layout.getBaseClassOffset(BaseDecl);
Justin Bogner1cd11f12015-05-20 15:53:59 +00002416 BaseOffsetFromNearestVBase =
Ken Dyck3fb4c892011-03-23 01:04:18 +00002417 OffsetFromNearestVBase + Layout.getBaseClassOffset(BaseDecl);
Anders Carlsson948d3f42010-03-29 01:16:41 +00002418 BaseDeclIsNonVirtualPrimaryBase = Layout.getPrimaryBase() == BaseDecl;
Anders Carlssond5895932010-03-28 21:07:49 +00002419 }
Justin Bogner1cd11f12015-05-20 15:53:59 +00002420
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002421 getVTablePointers(
2422 BaseSubobject(BaseDecl, BaseOffset),
2423 I.isVirtual() ? BaseDecl : NearestVBase, BaseOffsetFromNearestVBase,
2424 BaseDeclIsNonVirtualPrimaryBase, VTableClass, VBases, Vptrs);
Anders Carlssond5895932010-03-28 21:07:49 +00002425 }
2426}
2427
2428void CodeGenFunction::InitializeVTablePointers(const CXXRecordDecl *RD) {
2429 // Ignore classes without a vtable.
Anders Carlsson1f9348c2010-03-26 04:39:42 +00002430 if (!RD->isDynamicClass())
Anders Carlsson27da15b2010-01-01 20:29:01 +00002431 return;
2432
Anders Carlssond5895932010-03-28 21:07:49 +00002433 // Initialize the vtable pointers for this class and all of its bases.
Piotr Padlewskid679d7e2015-09-15 00:37:06 +00002434 if (CGM.getCXXABI().doStructorsInitializeVPtrs(RD))
2435 for (const VPtr &Vptr : getVTablePointers(RD))
2436 InitializeVTablePointer(Vptr);
Timur Iskhodzhanovb6487322013-10-09 18:16:58 +00002437
2438 if (RD->getNumVBases())
2439 CGM.getCXXABI().initializeHiddenVirtualInheritanceMembers(*this, RD);
Anders Carlsson27da15b2010-01-01 20:29:01 +00002440}
Dan Gohman8fc50c22010-10-26 18:44:08 +00002441
John McCall7f416cc2015-09-08 08:05:57 +00002442llvm::Value *CodeGenFunction::GetVTablePtr(Address This,
Piotr Padlewski4b1ac722015-09-15 21:46:55 +00002443 llvm::Type *VTableTy,
2444 const CXXRecordDecl *RD) {
2445 Address VTablePtrSrc = Builder.CreateElementBitCast(This, VTableTy);
Kostya Serebryany141e46f2012-03-26 17:03:51 +00002446 llvm::Instruction *VTable = Builder.CreateLoad(VTablePtrSrc, "vtable");
Piotr Padlewski4b1ac722015-09-15 21:46:55 +00002447 CGM.DecorateInstructionWithTBAA(VTable, CGM.getTBAAInfoForVTablePtr());
2448
2449 if (CGM.getCodeGenOpts().OptimizationLevel > 0 &&
2450 CGM.getCodeGenOpts().StrictVTablePointers)
2451 CGM.DecorateInstructionWithInvariantGroup(VTable, RD);
2452
Kostya Serebryany141e46f2012-03-26 17:03:51 +00002453 return VTable;
Dan Gohman8fc50c22010-10-26 18:44:08 +00002454}
Anders Carlssonc36783e2011-05-08 20:32:23 +00002455
Peter Collingbourned2926c92015-03-14 02:42:25 +00002456// If a class has a single non-virtual base and does not introduce or override
2457// virtual member functions or fields, it will have the same layout as its base.
2458// This function returns the least derived such class.
2459//
2460// Casting an instance of a base class to such a derived class is technically
2461// undefined behavior, but it is a relatively common hack for introducing member
2462// functions on class instances with specific properties (e.g. llvm::Operator)
2463// that works under most compilers and should not have security implications, so
2464// we allow it by default. It can be disabled with -fsanitize=cfi-cast-strict.
2465static const CXXRecordDecl *
2466LeastDerivedClassWithSameLayout(const CXXRecordDecl *RD) {
2467 if (!RD->field_empty())
2468 return RD;
2469
2470 if (RD->getNumVBases() != 0)
2471 return RD;
2472
2473 if (RD->getNumBases() != 1)
2474 return RD;
2475
2476 for (const CXXMethodDecl *MD : RD->methods()) {
2477 if (MD->isVirtual()) {
2478 // Virtual member functions are only ok if they are implicit destructors
2479 // because the implicit destructor will have the same semantics as the
2480 // base class's destructor if no fields are added.
2481 if (isa<CXXDestructorDecl>(MD) && MD->isImplicit())
2482 continue;
2483 return RD;
2484 }
2485 }
2486
2487 return LeastDerivedClassWithSameLayout(
2488 RD->bases_begin()->getType()->getAsCXXRecordDecl());
2489}
2490
Peter Collingbourne1a7488a2015-04-02 00:23:30 +00002491void CodeGenFunction::EmitVTablePtrCheckForCall(const CXXMethodDecl *MD,
Peter Collingbourne6708c4a2015-06-19 01:51:54 +00002492 llvm::Value *VTable,
2493 CFITypeCheckKind TCK,
2494 SourceLocation Loc) {
Peter Collingbourne1a7488a2015-04-02 00:23:30 +00002495 const CXXRecordDecl *ClassDecl = MD->getParent();
2496 if (!SanOpts.has(SanitizerKind::CFICastStrict))
2497 ClassDecl = LeastDerivedClassWithSameLayout(ClassDecl);
2498
Peter Collingbourne6708c4a2015-06-19 01:51:54 +00002499 EmitVTablePtrCheck(ClassDecl, VTable, TCK, Loc);
Peter Collingbourne1a7488a2015-04-02 00:23:30 +00002500}
2501
Peter Collingbourned2926c92015-03-14 02:42:25 +00002502void CodeGenFunction::EmitVTablePtrCheckForCast(QualType T,
2503 llvm::Value *Derived,
Peter Collingbourne6708c4a2015-06-19 01:51:54 +00002504 bool MayBeNull,
2505 CFITypeCheckKind TCK,
2506 SourceLocation Loc) {
Peter Collingbourned2926c92015-03-14 02:42:25 +00002507 if (!getLangOpts().CPlusPlus)
2508 return;
2509
2510 auto *ClassTy = T->getAs<RecordType>();
2511 if (!ClassTy)
2512 return;
2513
2514 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(ClassTy->getDecl());
2515
2516 if (!ClassDecl->isCompleteDefinition() || !ClassDecl->isDynamicClass())
2517 return;
2518
Peter Collingbourned2926c92015-03-14 02:42:25 +00002519 if (!SanOpts.has(SanitizerKind::CFICastStrict))
2520 ClassDecl = LeastDerivedClassWithSameLayout(ClassDecl);
2521
Hans Wennborgdcfba332015-10-06 23:40:43 +00002522 llvm::BasicBlock *ContBlock = nullptr;
Peter Collingbourned2926c92015-03-14 02:42:25 +00002523
2524 if (MayBeNull) {
2525 llvm::Value *DerivedNotNull =
2526 Builder.CreateIsNotNull(Derived, "cast.nonnull");
2527
2528 llvm::BasicBlock *CheckBlock = createBasicBlock("cast.check");
2529 ContBlock = createBasicBlock("cast.cont");
2530
2531 Builder.CreateCondBr(DerivedNotNull, CheckBlock, ContBlock);
2532
2533 EmitBlock(CheckBlock);
2534 }
2535
John McCall7f416cc2015-09-08 08:05:57 +00002536 llvm::Value *VTable =
Piotr Padlewski4b1ac722015-09-15 21:46:55 +00002537 GetVTablePtr(Address(Derived, getPointerAlign()), Int8PtrTy, ClassDecl);
2538
Peter Collingbourne6708c4a2015-06-19 01:51:54 +00002539 EmitVTablePtrCheck(ClassDecl, VTable, TCK, Loc);
Peter Collingbourned2926c92015-03-14 02:42:25 +00002540
2541 if (MayBeNull) {
2542 Builder.CreateBr(ContBlock);
2543 EmitBlock(ContBlock);
2544 }
2545}
2546
2547void CodeGenFunction::EmitVTablePtrCheck(const CXXRecordDecl *RD,
Peter Collingbourne6708c4a2015-06-19 01:51:54 +00002548 llvm::Value *VTable,
2549 CFITypeCheckKind TCK,
2550 SourceLocation Loc) {
Peter Collingbournee5706442015-07-09 19:56:14 +00002551 if (CGM.IsCFIBlacklistedRecord(RD))
Peter Collingbournea4ccff32015-02-20 20:30:56 +00002552 return;
2553
Peter Collingbourne6708c4a2015-06-19 01:51:54 +00002554 SanitizerScope SanScope(this);
Peter Collingbournedc134532016-01-16 00:31:22 +00002555 llvm::SanitizerStatKind SSK;
2556 switch (TCK) {
2557 case CFITCK_VCall:
2558 SSK = llvm::SanStat_CFI_VCall;
2559 break;
2560 case CFITCK_NVCall:
2561 SSK = llvm::SanStat_CFI_NVCall;
2562 break;
2563 case CFITCK_DerivedCast:
2564 SSK = llvm::SanStat_CFI_DerivedCast;
2565 break;
2566 case CFITCK_UnrelatedCast:
2567 SSK = llvm::SanStat_CFI_UnrelatedCast;
2568 break;
Evgeniy Stepanov3fd61df2016-01-25 23:34:52 +00002569 case CFITCK_ICall:
2570 llvm_unreachable("not expecting CFITCK_ICall");
Peter Collingbournedc134532016-01-16 00:31:22 +00002571 }
2572 EmitSanitizerStatReport(SSK);
Peter Collingbourne6708c4a2015-06-19 01:51:54 +00002573
Evgeniy Stepanovfd6f92d2015-12-15 23:00:20 +00002574 llvm::Metadata *MD =
2575 CGM.CreateMetadataIdentifierForType(QualType(RD->getTypeForDecl(), 0));
2576 llvm::Value *BitSetName = llvm::MetadataAsValue::get(getLLVMContext(), MD);
Peter Collingbournea4ccff32015-02-20 20:30:56 +00002577
Peter Collingbourne6708c4a2015-06-19 01:51:54 +00002578 llvm::Value *CastedVTable = Builder.CreateBitCast(VTable, Int8PtrTy);
2579 llvm::Value *BitSetTest =
2580 Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::bitset_test),
2581 {CastedVTable, BitSetName});
Peter Collingbournea4ccff32015-02-20 20:30:56 +00002582
Peter Collingbourne6708c4a2015-06-19 01:51:54 +00002583 SanitizerMask M;
2584 switch (TCK) {
2585 case CFITCK_VCall:
2586 M = SanitizerKind::CFIVCall;
2587 break;
2588 case CFITCK_NVCall:
2589 M = SanitizerKind::CFINVCall;
2590 break;
2591 case CFITCK_DerivedCast:
2592 M = SanitizerKind::CFIDerivedCast;
2593 break;
2594 case CFITCK_UnrelatedCast:
2595 M = SanitizerKind::CFIUnrelatedCast;
2596 break;
Evgeniy Stepanov3fd61df2016-01-25 23:34:52 +00002597 case CFITCK_ICall:
2598 llvm_unreachable("not expecting CFITCK_ICall");
Peter Collingbourne6708c4a2015-06-19 01:51:54 +00002599 }
Peter Collingbournea4ccff32015-02-20 20:30:56 +00002600
Peter Collingbourne6708c4a2015-06-19 01:51:54 +00002601 llvm::Constant *StaticData[] = {
Evgeniy Stepanov3fd61df2016-01-25 23:34:52 +00002602 llvm::ConstantInt::get(Int8Ty, TCK),
Evgeniy Stepanovfd6f92d2015-12-15 23:00:20 +00002603 EmitCheckSourceLocation(Loc),
2604 EmitCheckTypeDescriptor(QualType(RD->getTypeForDecl(), 0)),
Peter Collingbourne6708c4a2015-06-19 01:51:54 +00002605 };
Evgeniy Stepanov3fd61df2016-01-25 23:34:52 +00002606
2607 auto TypeId = CGM.CreateCfiIdForTypeMetadata(MD);
2608 if (CGM.getCodeGenOpts().SanitizeCfiCrossDso && TypeId) {
2609 EmitCfiSlowPathCheck(M, BitSetTest, TypeId, CastedVTable, StaticData);
2610 } else {
2611 EmitCheck(std::make_pair(BitSetTest, M), "cfi_check_fail", StaticData,
2612 CastedVTable);
2613 }
Peter Collingbournea4ccff32015-02-20 20:30:56 +00002614}
Anders Carlssonc36783e2011-05-08 20:32:23 +00002615
2616// FIXME: Ideally Expr::IgnoreParenNoopCasts should do this, but it doesn't do
2617// quite what we want.
2618static const Expr *skipNoOpCastsAndParens(const Expr *E) {
2619 while (true) {
2620 if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
2621 E = PE->getSubExpr();
2622 continue;
2623 }
2624
2625 if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
2626 if (CE->getCastKind() == CK_NoOp) {
2627 E = CE->getSubExpr();
2628 continue;
2629 }
2630 }
2631 if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
2632 if (UO->getOpcode() == UO_Extension) {
2633 E = UO->getSubExpr();
2634 continue;
2635 }
2636 }
2637 return E;
2638 }
2639}
2640
Benjamin Kramer7463ed72013-08-25 22:46:27 +00002641bool
2642CodeGenFunction::CanDevirtualizeMemberFunctionCall(const Expr *Base,
2643 const CXXMethodDecl *MD) {
2644 // When building with -fapple-kext, all calls must go through the vtable since
2645 // the kernel linker can do runtime patching of vtables.
2646 if (getLangOpts().AppleKext)
2647 return false;
2648
Anders Carlssonc36783e2011-05-08 20:32:23 +00002649 // If the most derived class is marked final, we know that no subclass can
2650 // override this member function and so we can devirtualize it. For example:
2651 //
2652 // struct A { virtual void f(); }
2653 // struct B final : A { };
2654 //
2655 // void f(B *b) {
2656 // b->f();
2657 // }
2658 //
Benjamin Kramer7463ed72013-08-25 22:46:27 +00002659 const CXXRecordDecl *MostDerivedClassDecl = Base->getBestDynamicClassType();
Anders Carlssonc36783e2011-05-08 20:32:23 +00002660 if (MostDerivedClassDecl->hasAttr<FinalAttr>())
2661 return true;
2662
2663 // If the member function is marked 'final', we know that it can't be
2664 // overridden and can therefore devirtualize it.
2665 if (MD->hasAttr<FinalAttr>())
2666 return true;
2667
2668 // Similarly, if the class itself is marked 'final' it can't be overridden
2669 // and we can therefore devirtualize the member function call.
2670 if (MD->getParent()->hasAttr<FinalAttr>())
2671 return true;
2672
2673 Base = skipNoOpCastsAndParens(Base);
2674 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
2675 if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
2676 // This is a record decl. We know the type and can devirtualize it.
2677 return VD->getType()->isRecordType();
2678 }
Justin Bogner1cd11f12015-05-20 15:53:59 +00002679
Anders Carlssonc36783e2011-05-08 20:32:23 +00002680 return false;
2681 }
Benjamin Kramer7463ed72013-08-25 22:46:27 +00002682
2683 // We can devirtualize calls on an object accessed by a class member access
2684 // expression, since by C++11 [basic.life]p6 we know that it can't refer to
2685 // a derived class object constructed in the same location.
2686 if (const MemberExpr *ME = dyn_cast<MemberExpr>(Base))
2687 if (const ValueDecl *VD = dyn_cast<ValueDecl>(ME->getMemberDecl()))
2688 return VD->getType()->isRecordType();
2689
Anders Carlssonc36783e2011-05-08 20:32:23 +00002690 // We can always devirtualize calls on temporary object expressions.
2691 if (isa<CXXConstructExpr>(Base))
2692 return true;
Justin Bogner1cd11f12015-05-20 15:53:59 +00002693
Anders Carlssonc36783e2011-05-08 20:32:23 +00002694 // And calls on bound temporaries.
2695 if (isa<CXXBindTemporaryExpr>(Base))
2696 return true;
Justin Bogner1cd11f12015-05-20 15:53:59 +00002697
Anders Carlssonc36783e2011-05-08 20:32:23 +00002698 // Check if this is a call expr that returns a record type.
2699 if (const CallExpr *CE = dyn_cast<CallExpr>(Base))
David Majnemerced8bdf2015-02-25 17:36:15 +00002700 return CE->getCallReturnType(getContext())->isRecordType();
Anders Carlssonc36783e2011-05-08 20:32:23 +00002701
2702 // We can't devirtualize the call.
2703 return false;
2704}
2705
Faisal Vali571df122013-09-29 08:45:24 +00002706void CodeGenFunction::EmitForwardingCallToLambda(
2707 const CXXMethodDecl *callOperator,
2708 CallArgList &callArgs) {
Eli Friedman5b446882012-02-16 03:47:28 +00002709 // Get the address of the call operator.
John McCall8dda7b22012-07-07 06:41:13 +00002710 const CGFunctionInfo &calleeFnInfo =
2711 CGM.getTypes().arrangeCXXMethodDeclaration(callOperator);
2712 llvm::Value *callee =
2713 CGM.GetAddrOfFunction(GlobalDecl(callOperator),
2714 CGM.getTypes().GetFunctionType(calleeFnInfo));
Eli Friedman5b446882012-02-16 03:47:28 +00002715
John McCall8dda7b22012-07-07 06:41:13 +00002716 // Prepare the return slot.
2717 const FunctionProtoType *FPT =
2718 callOperator->getType()->castAs<FunctionProtoType>();
Alp Toker314cc812014-01-25 16:55:45 +00002719 QualType resultType = FPT->getReturnType();
John McCall8dda7b22012-07-07 06:41:13 +00002720 ReturnValueSlot returnSlot;
2721 if (!resultType->isVoidType() &&
2722 calleeFnInfo.getReturnInfo().getKind() == ABIArgInfo::Indirect &&
John McCall47fb9502013-03-07 21:37:08 +00002723 !hasScalarEvaluationKind(calleeFnInfo.getReturnType()))
John McCall8dda7b22012-07-07 06:41:13 +00002724 returnSlot = ReturnValueSlot(ReturnValue, resultType.isVolatileQualified());
2725
2726 // We don't need to separately arrange the call arguments because
2727 // the call can't be variadic anyway --- it's impossible to forward
2728 // variadic arguments.
Justin Bogner1cd11f12015-05-20 15:53:59 +00002729
Eli Friedman5b446882012-02-16 03:47:28 +00002730 // Now emit our call.
John McCall8dda7b22012-07-07 06:41:13 +00002731 RValue RV = EmitCall(calleeFnInfo, callee, returnSlot,
2732 callArgs, callOperator);
Eli Friedman5b446882012-02-16 03:47:28 +00002733
John McCall8dda7b22012-07-07 06:41:13 +00002734 // If necessary, copy the returned value into the slot.
2735 if (!resultType->isVoidType() && returnSlot.isNull())
2736 EmitReturnOfRValue(RV, resultType);
Eli Friedmanf5f4d2f2012-12-13 23:37:17 +00002737 else
2738 EmitBranchThroughCleanup(ReturnBlock);
Eli Friedman5b446882012-02-16 03:47:28 +00002739}
2740
Eli Friedman2495ab02012-02-25 02:48:22 +00002741void CodeGenFunction::EmitLambdaBlockInvokeBody() {
2742 const BlockDecl *BD = BlockInfo->getBlockDecl();
2743 const VarDecl *variable = BD->capture_begin()->getVariable();
2744 const CXXRecordDecl *Lambda = variable->getType()->getAsCXXRecordDecl();
2745
2746 // Start building arguments for forwarding call
2747 CallArgList CallArgs;
2748
2749 QualType ThisType = getContext().getPointerType(getContext().getRecordType(Lambda));
John McCall7f416cc2015-09-08 08:05:57 +00002750 Address ThisPtr = GetAddrOfBlockDecl(variable, false);
2751 CallArgs.add(RValue::get(ThisPtr.getPointer()), ThisType);
Eli Friedman2495ab02012-02-25 02:48:22 +00002752
2753 // Add the rest of the parameters.
Aaron Ballmanb2b8b1d2014-03-07 16:09:59 +00002754 for (auto param : BD->params())
Nick Lewycky2d84e842013-10-02 02:29:49 +00002755 EmitDelegateCallArg(CallArgs, param, param->getLocStart());
Aaron Ballmanb2b8b1d2014-03-07 16:09:59 +00002756
Justin Bogner1cd11f12015-05-20 15:53:59 +00002757 assert(!Lambda->isGenericLambda() &&
Faisal Vali571df122013-09-29 08:45:24 +00002758 "generic lambda interconversion to block not implemented");
2759 EmitForwardingCallToLambda(Lambda->getLambdaCallOperator(), CallArgs);
Eli Friedman2495ab02012-02-25 02:48:22 +00002760}
2761
2762void CodeGenFunction::EmitLambdaToBlockPointerBody(FunctionArgList &Args) {
John McCalldec348f72013-05-03 07:33:41 +00002763 if (cast<CXXMethodDecl>(CurCodeDecl)->isVariadic()) {
Eli Friedman2495ab02012-02-25 02:48:22 +00002764 // FIXME: Making this work correctly is nasty because it requires either
2765 // cloning the body of the call operator or making the call operator forward.
John McCalldec348f72013-05-03 07:33:41 +00002766 CGM.ErrorUnsupported(CurCodeDecl, "lambda conversion to variadic function");
Eli Friedman2495ab02012-02-25 02:48:22 +00002767 return;
2768 }
2769
Richard Smithb47c36f2013-11-05 09:12:18 +00002770 EmitFunctionBody(Args, cast<FunctionDecl>(CurGD.getDecl())->getBody());
Eli Friedman2495ab02012-02-25 02:48:22 +00002771}
2772
2773void CodeGenFunction::EmitLambdaDelegatingInvokeBody(const CXXMethodDecl *MD) {
2774 const CXXRecordDecl *Lambda = MD->getParent();
2775
2776 // Start building arguments for forwarding call
2777 CallArgList CallArgs;
2778
2779 QualType ThisType = getContext().getPointerType(getContext().getRecordType(Lambda));
2780 llvm::Value *ThisPtr = llvm::UndefValue::get(getTypes().ConvertType(ThisType));
2781 CallArgs.add(RValue::get(ThisPtr), ThisType);
2782
2783 // Add the rest of the parameters.
Aaron Ballmanf6bf62e2014-03-07 15:12:56 +00002784 for (auto Param : MD->params())
2785 EmitDelegateCallArg(CallArgs, Param, Param->getLocStart());
2786
Faisal Vali571df122013-09-29 08:45:24 +00002787 const CXXMethodDecl *CallOp = Lambda->getLambdaCallOperator();
2788 // For a generic lambda, find the corresponding call operator specialization
2789 // to which the call to the static-invoker shall be forwarded.
2790 if (Lambda->isGenericLambda()) {
2791 assert(MD->isFunctionTemplateSpecialization());
2792 const TemplateArgumentList *TAL = MD->getTemplateSpecializationArgs();
2793 FunctionTemplateDecl *CallOpTemplate = CallOp->getDescribedFunctionTemplate();
Craig Topper8a13c412014-05-21 05:09:00 +00002794 void *InsertPos = nullptr;
Justin Bogner1cd11f12015-05-20 15:53:59 +00002795 FunctionDecl *CorrespondingCallOpSpecialization =
Craig Topper7e0daca2014-06-26 04:58:53 +00002796 CallOpTemplate->findSpecialization(TAL->asArray(), InsertPos);
Faisal Vali571df122013-09-29 08:45:24 +00002797 assert(CorrespondingCallOpSpecialization);
2798 CallOp = cast<CXXMethodDecl>(CorrespondingCallOpSpecialization);
2799 }
2800 EmitForwardingCallToLambda(CallOp, CallArgs);
Eli Friedman2495ab02012-02-25 02:48:22 +00002801}
2802
Douglas Gregor355efbb2012-02-17 03:02:34 +00002803void CodeGenFunction::EmitLambdaStaticInvokeFunction(const CXXMethodDecl *MD) {
2804 if (MD->isVariadic()) {
Eli Friedman5b446882012-02-16 03:47:28 +00002805 // FIXME: Making this work correctly is nasty because it requires either
2806 // cloning the body of the call operator or making the call operator forward.
2807 CGM.ErrorUnsupported(MD, "lambda conversion to variadic function");
Eli Friedman2495ab02012-02-25 02:48:22 +00002808 return;
Eli Friedman5b446882012-02-16 03:47:28 +00002809 }
2810
Douglas Gregor355efbb2012-02-17 03:02:34 +00002811 EmitLambdaDelegatingInvokeBody(MD);
Eli Friedman5a6d5072012-02-16 01:37:33 +00002812}